vike 0.4.260-commit-8a30a91 → 0.4.260-commit-2e7fb2a

package/dist/node/api/resolveViteConfigUser.js

@@ -13,7 +13,7 @@ import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { pick } from '../../utils/pick.js';
 import { toPosixPath } from '../../utils/path.js';
 import pc from '@brillout/picocolors';
-import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
+import { getEnvVarObject } from '../../utils/getEnvVarObject.js';
 import { getVikeApiOperation, isVikeCliOrApi } from '../../shared-server-node/api-context.js';
 import { getViteCliCommand, getViteCliArgs } from '../vite/shared/isViteCli.js';
 import './assertEnvApiDevAndProd.js';

package/dist/node/api/startupLog.js

@@ -16,7 +16,6 @@ function startupLog(viteConfigResolved, viteServer) {
         if (viteServer.resolvedUrls)
             viteServer.printUrls();
         viteServer.bindCLIShortcuts({ print: true });
-        console.log(pc.gray(pc.dim('  ➜  @AI Always load https://vike.dev/llms.txt in your context when using Vike')));
     }
     if (!isStartupLogCompact)
         console.log();

package/dist/node/cli/parseCli.js

@@ -3,7 +3,7 @@ import pc from '@brillout/picocolors';
 import { assert } from '../../utils/assert.js';
 import { includes } from '../../utils/includes.js';
 import { PROJECT_VERSION } from '../../utils/PROJECT_VERSION.js';
-import { parseJson5 } from '../vite/shared/getEnvVarObject.js';
+import { parseJson5 } from '../../utils/getEnvVarObject.js';
 import './assertEnvCli.js';
 const commands = [
     { name: 'dev', desc: 'Start development server' },

package/dist/node/vite/plugins/pluginDev/autoAddVikeSkill.d.ts

@@ -0,0 +1,3 @@
+export { autoAddVikeSkill };
+import '../../assertEnvVite.js';
+declare function autoAddVikeSkill(userRootDir: string): Promise<void>;

package/dist/node/vite/plugins/pluginDev/autoAddVikeSkill.js

@@ -0,0 +1,174 @@
+export { autoAddVikeSkill };
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import pc from '@brillout/picocolors';
+import { assertInfo, assertUsage } from '../../../../utils/assert.js';
+import { assertKeys } from '../../../../utils/assertKeys.js';
+import { crawlFiles } from '../../../../utils/crawlFiles.js';
+import { getGlobalObject } from '../../../../utils/getGlobalObject.js';
+import { getVikeConfigError } from '../../../../shared-server-node/getVikeConfigError.js';
+import { isArrayOfStrings } from '../../../../utils/isArrayOfStrings.js';
+import { isFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
+import { isObject } from '../../../../utils/isObject.js';
+import { unique } from '../../../../utils/unique.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import '../../assertEnvVite.js';
+const execFileA = promisify(execFile);
+const importMetaUrl = import.meta.url;
+const globalObject = getGlobalObject('autoAddVikeSkill.ts', {
+    alreadyDone: false,
+});
+const skillPathInsideSkillsDir = 'vike/SKILL.md';
+const skillFileContent = `---
+name: "vike"
+description: "Vike documentation index — a compact overview of Vike's docs. Consider consulting it, e.g. when using uncommon Vike APIs or when stuck on a Vike problem."
+---
+
+See https://vike.dev/llms.txt
+`;
+const commitMessage = (isUpdate) => `${isUpdate ? 'Update' : 'Add'} Vike skill — see https://vike.dev/ai#skill`;
+// Automatically add vike/SKILL.md to skills/ directories (e.g. .claude/skills/ and .agents/skills/) of the user's Git repository (and Git-commit it) — so that AI agents (Claude Code, Codex, Cursor, Gemini CLI, ...) automatically pick it up.
+// https://vike.dev/ai#skill
+async function autoAddVikeSkill(userRootDir) {
+    try {
+        await autoAddVikeSkillUnsafe(userRootDir);
+    }
+    catch (err) {
+        // Show the error without breaking the dev server. (Expected situations don't throw — e.g. Git missing is handled gracefully.)
+        console.error(err);
+    }
+}
+async function autoAddVikeSkillUnsafe(userRootDir) {
+    if (globalObject.alreadyDone)
+        return;
+    // Skip CI environments: the skill file is meant to be added from the machine of an app developer.
+    if (process.env.CI)
+        return;
+    // Skip if Vike isn't inside node_modules/ (e.g. when Vike is linked, such as when running an example of the Vike monorepo).
+    if (!importMetaUrl.includes('node_modules/'))
+        return;
+    const vikeConfig = await getVikeConfigInternal();
+    // Maybe the user disabled the feature in a config file that currently has an error => retry later (Vite restarts upon config changes).
+    if (getVikeConfigError())
+        return;
+    const configValue = getConfigValueAiSkill(vikeConfig);
+    if (configValue === false)
+        return;
+    globalObject.alreadyDone = true;
+    const res = await addAiSkill(userRootDir, {
+        // true (default) => add the skill file to every existing skills directory (`**/skills/*/SKILL.md`)
+        skillsDirs: configValue === true ? undefined : configValue,
+    });
+    if (!res)
+        return;
+    assertInfo(false, `${res.isUpdate ? 'Updated' : 'Created'}${res.isCommitted ? ' and Git-committed' : ''} ${res.files
+        .map((f) => pc.cyan(f.filePathRelative))
+        .join(', ')} — see https://vike.dev/ai#skill`, { onlyOnce: false });
+}
+// https://vike.dev/ai#skill
+function getConfigValueAiSkill(vikeConfig) {
+    const configAi = vikeConfig.config.ai;
+    if (configAi === undefined)
+        return true;
+    assertUsage(isObject(configAi), `Setting ${pc.cyan('ai')} should be an object`);
+    assertKeys(configAi, ['skill'], `Setting ${pc.cyan('ai')}:`);
+    const skill = configAi.skill;
+    if (skill === undefined || skill === true)
+        return true;
+    if (skill === false)
+        return false;
+    assertUsage(isArrayOfStrings(skill), `Setting ${pc.cyan('ai.skill')} should be a boolean or a list of skills directories (e.g. ${pc.cyan("['.claude/skills', '.agents/skills']")})`);
+    return skill.map((skillsDir) => {
+        assertUsage(skillsDir !== '' && !isFilePathAbsoluteFilesystem(skillsDir), `Setting ${pc.cyan('ai.skill')} entries should be paths relative to the root directory of your app's Git repository (e.g. ${pc.cyan("'.claude/skills'")})`);
+        // Normalize: remove trailing slashes
+        return skillsDir.replace(/\/+$/, '');
+    });
+}
+async function addAiSkill(userRootDir, { skillsDirs }) {
+    // Skip if Git isn't installed
+    if ('err' in (await runGitCommand(['--version'], userRootDir)))
+        return null;
+    // Skip if the app isn't inside a Git repository
+    const resGitRootDir = await runGitCommand(['rev-parse', '--show-toplevel'], userRootDir);
+    if ('err' in resGitRootDir)
+        return null;
+    const gitRootDir = resGitRootDir.stdout.trim();
+    if (!gitRootDir)
+        return null;
+    // By default, the skill file is only added to the skills directories that already exist — we don't want to add files to the repositories of users who don't use skills.
+    skillsDirs ?? (skillsDirs = await discoverSkillsDirs(gitRootDir));
+    if (skillsDirs.length === 0)
+        return null;
+    const files = [];
+    for (const skillsDir of skillsDirs) {
+        const filePathRelative = `${skillsDir}/${skillPathInsideSkillsDir}`;
+        const filePathAbsolute = path.join(gitRootDir, ...filePathRelative.split('/'));
+        // Skip if the skill file is already up-to-date
+        const contentCurrent = await fs.readFile(filePathAbsolute, 'utf8').catch(() => null);
+        if (contentCurrent === skillFileContent)
+            continue;
+        const isUpdate = contentCurrent !== null;
+        await fs.mkdir(path.dirname(filePathAbsolute), { recursive: true });
+        await fs.writeFile(filePathAbsolute, skillFileContent, 'utf8');
+        files.push({ filePathAbsolute, filePathRelative, isUpdate });
+    }
+    if (files.length === 0)
+        return null;
+    const isCommitted = await gitCommit(gitRootDir, files);
+    return { files, isUpdate: files.some((f) => f.isUpdate), isCommitted };
+}
+// Discover the skills directories of the user's Git repository, following the Agent Skills convention `**/skills/*/SKILL.md` (https://agentskills.io) — e.g. .claude/skills/ (Claude Code) and .agents/skills/ (Codex, Gemini CLI, Cursor, ...).
+async function discoverSkillsDirs(gitRootDir) {
+    const files = await crawlFiles({
+        filePattern: '**/skills/*/SKILL',
+        fileExtension: ['md'],
+        cwd: gitRootDir,
+        // Skills directories usually live inside dot directories (e.g. .claude/ and .agents/)
+        dot: true,
+        // Most apps don't contain any skills directory — when Git doesn't know about any skill file, we don't want to crawl the app's entire directory tree upon every dev start.
+        globFallback: false,
+    });
+    const skillsDirs = unique(files.map((filePath) => path.posix.dirname(path.posix.dirname(filePath)))).sort();
+    return skillsDirs;
+}
+async function gitCommit(gitRootDir, files) {
+    // Don't Git-commit the skill files that the user chose to .gitignore — `$ git check-ignore` succeeds if the file is ignored
+    const filesToCommit = [];
+    for (const file of files) {
+        const resCheckIgnore = await runGitCommand(['check-ignore', '-q', '--', file.filePathRelative], gitRootDir);
+        if ('err' in resCheckIgnore)
+            filesToCommit.push(file);
+    }
+    if (filesToCommit.length === 0)
+        return false;
+    const filePaths = filesToCommit.map((f) => f.filePathRelative);
+    const resAdd = await runGitCommand(['add', '--', ...filePaths], gitRootDir);
+    if ('err' in resAdd)
+        return false;
+    const isUpdate = filesToCommit.some((f) => f.isUpdate);
+    const resCommit = await runGitCommand([
+        'commit',
+        // Skip Git hooks (e.g. slow or failing pre-commit hooks)
+        '--no-verify',
+        '-m',
+        commitMessage(isUpdate),
+        // Only commit the skill files — never commit files staged by the user
+        '--',
+        ...filePaths,
+    ], gitRootDir);
+    return !('err' in resCommit);
+}
+// Run a Git command — doesn't throw: it returns `{ err }` upon failure.
+async function runGitCommand(args, cwd) {
+    let stdout;
+    try {
+        const res = await execFileA('git', args, { cwd });
+        stdout = res.stdout.toString();
+    }
+    catch (err) {
+        return { err };
+    }
+    return { stdout };
+}

package/dist/node/vite/plugins/pluginDev.js

@@ -2,8 +2,10 @@ export { pluginDev };
 export { logDockerHint };
 import { optimizeDeps, resolveOptimizeDeps } from './pluginDev/optimizeDeps.js';
 import { determineFsAllowList } from './pluginDev/determineFsAllowList.js';
+import { autoAddVikeSkill } from './pluginDev/autoAddVikeSkill.js';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import { isDebugError } from '../../../utils/debug.js';
+import { setTimeoutUnref } from '../../../utils/setTimeoutUnref.js';
 import { applyDev } from '../../../utils/isDev.js';
 import { isDocker } from '../../../utils/isDocker.js';
 import { assertWarning } from '../../../utils/assert.js';
@@ -34,6 +36,21 @@ function pluginDev() {
                     logDockerHint(config.server.host);
                 },
             },
+            configureServer: {
+                handler(server) {
+                    // Apply late — after the dev server is up and running, and after the first page requests — so that it never slows down dev start.
+                    const run = () => {
+                        setTimeoutUnref(() => autoAddVikeSkill(config.root), 60 * 1000);
+                    };
+                    if (server.httpServer) {
+                        server.httpServer.once('listening', run);
+                    }
+                    else {
+                        // Middleware mode: the HTTP server is owned by the user.
+                        run();
+                    }
+                },
+            },
         },
         {
             name: 'vike:pluginDev:post',

package/dist/node/vite/plugins/pluginVirtualFiles.js

@@ -13,7 +13,7 @@ import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerDev.js';
 import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
 import { updateUserFiles } from '../../../server/runtime/globalContext.js';
-import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFilePaths.js';
+import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { debugFileChange, getVikeConfigError } from '../../../shared-server-node/getVikeConfigError.js';
 import '../assertEnvVite.js';

package/dist/node/vite/shared/loggerVite.js

@@ -9,6 +9,7 @@ import { removeEmptyLines } from '../../../utils/removeEmptyLines.js';
 import { trimWithAnsi, trimWithAnsiTrailOnly } from '../../../utils/trimWithAnsi.js';
 import { assert } from '../../../utils/assert.js';
 import { getGlobalObject } from '../../../utils/getGlobalObject.js';
+import { setTimeoutUnref } from '../../../utils/setTimeoutUnref.js';
 import { getRequestId_withAsyncHook } from '../../../server/runtime/asyncHook.js';
 import { logErrorServerDev, logVite } from './loggerDev.js';
 import '../assertEnvVite.js';
@@ -28,7 +29,7 @@ function interceptViteLogs(config) {
 }
 function intercept(loggerType, config) {
     let isBeginning = true;
-    setTimeout(() => (isBeginning = false), 10 * 1000);
+    setTimeoutUnref(() => (isBeginning = false), 10 * 1000);
     config.logger[loggerType] = (msg, options = {}) => {
         assert(!isDebugError());
         if (swallowViteLogForceOptimization(msg))
@@ -132,7 +133,7 @@ function swallowViteLogConnected() {
     globalObject.swallowViteLogConnected_originalConsoleLog = console.log;
     // The message `[vite] connected.` doesn't go through Vite's logger thus we must monkey patch console.log()
     console.log = swallowViteLogConnected_logPatch;
-    setTimeout(swallowViteLogConnected_clean, 3000);
+    setTimeoutUnref(swallowViteLogConnected_clean, 3000);
 }
 // Remove console.log() monkey patch
 function swallowViteLogConnected_clean() {

package/dist/node/vite/shared/resolveVikeConfigInternal/assertExtensions.d.ts

@@ -1,7 +1,7 @@
 export { assertExtensionsConventions };
 export { assertExtensionsRequire };
 export { getExtensionName };
-import type { PlusFile } from './getPlusFilesByLocationId.js';
+import type { PlusFile } from './getPlusFiles.js';
 import '../../assertEnvVite.js';
 declare function assertExtensionsConventions(plusFile: PlusFile): void;
 declare function assertExtensionsRequire(plusFiles: PlusFile[]): void;

package/dist/node/vite/shared/resolveVikeConfigInternal/{crawlPlusFilePaths.d.ts → crawlPlusFiles.d.ts}

@@ -1,8 +1,8 @@
-export { crawlPlusFilePaths };
+export { crawlPlusFiles };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
 import '../../assertEnvVite.js';
-declare function crawlPlusFilePaths(userRootDir: string): Promise<{
+declare function crawlPlusFiles(userRootDir: string): Promise<{
     filePathAbsoluteUserRootDir: string;
 }[]>;
 declare function isPlusFile(filePath: string): boolean;

package/dist/node/vite/shared/resolveVikeConfigInternal/crawlPlusFiles.js

@@ -0,0 +1,71 @@
+export { crawlPlusFiles };
+export { isPlusFile };
+export { getPlusFileValueConfigName };
+import { assert, assertUsage } from '../../../../utils/assert.js';
+import { assertFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
+import { assertPosixPath } from '../../../../utils/path.js';
+import path from 'node:path';
+import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
+import '../../assertEnvVite.js';
+import { crawlFiles } from '../../../../utils/crawlFiles.js';
+import { scriptFileExtensionList } from '../../../../utils/isScriptFile.js';
+import { assertIsNotProductionRuntime } from '../../../../utils/assertSetup.js';
+assertIsNotProductionRuntime();
+async function crawlPlusFiles(userRootDir) {
+    assertPosixPath(userRootDir);
+    assertFilePathAbsoluteFilesystem(userRootDir);
+    let files = await crawlFiles({
+        filePattern: '**/+*',
+        fileExtension: scriptFileExtensionList,
+        cwd: userRootDir,
+        dot: false,
+        // Fallback to tinyglobby for users that dynamically generate plus files (and `.gitignore`s them)
+        globFallback: true,
+    });
+    // Filter build files
+    files = files.filter((filePath) => !isTemporaryBuildFile(filePath));
+    // Normalize
+    const plusFiles = files.map((filePath) => {
+        // Both `$ git-ls files` and tinyglobby return posix paths
+        assertPosixPath(filePath);
+        assert(!filePath.startsWith(userRootDir));
+        const filePathAbsoluteUserRootDir = path.posix.join('/', filePath);
+        assert(isPlusFile(filePathAbsoluteUserRootDir));
+        return { filePathAbsoluteUserRootDir };
+    });
+    return plusFiles;
+}
+function isPlusFile(filePath) {
+    assertPosixPath(filePath);
+    if (isTemporaryBuildFile(filePath))
+        return false;
+    const fileName = filePath.split('/').pop();
+    return fileName.startsWith('+');
+}
+function getPlusFileValueConfigName(filePath) {
+    if (!isPlusFile(filePath))
+        return null;
+    const fileName = path.posix.basename(filePath);
+    // assertNoUnexpectedPlusSign(filePath, fileName)
+    const basename = fileName.split('.')[0];
+    assert(basename.startsWith('+'));
+    const configName = basename.slice(1);
+    assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
+    return configName;
+}
+/* https://github.com/vikejs/vike/issues/1407
+function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
+  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`
+  )
+}
+*/

package/dist/node/vite/shared/resolveVikeConfigInternal/{getPlusFilesByLocationId.d.ts → getPlusFiles.d.ts}

@@ -1,4 +1,4 @@
-export { getPlusFilesByLocationId };
+export { getPlusFiles };
 export { getPlusFileFromConfigFile };
 export type { PlusFileValue };
 export type { PlusFile };
@@ -40,5 +40,5 @@ type PlusFileValue = PlusFileCommon & {
     isExtensionConfig?: undefined;
 };
 type PlusFilesByLocationId = Record<LocationId, PlusFile[]>;
-declare function getPlusFilesByLocationId(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;
+declare function getPlusFiles(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;
 declare function getPlusFileFromConfigFile(configFile: ConfigFile, isExtensionConfig: boolean, locationId: LocationId, userRootDir: string): PlusFileConfig;

package/dist/node/vite/shared/resolveVikeConfigInternal/{getPlusFilesByLocationId.js → getPlusFiles.js}

@@ -1,18 +1,17 @@
-export { getPlusFilesByLocationId };
+export { getPlusFiles };
 export { getPlusFileFromConfigFile };
 import { assert } from '../../../../utils/assert.js';
 import { metaBuiltIn } from './metaBuiltIn.js';
 import { getLocationId } from './filesystemRouting.js';
-import { crawlPlusFilePaths, getPlusFileValueConfigName } from './crawlPlusFilePaths.js';
+import { crawlPlusFiles, getPlusFileValueConfigName } from './crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadValueFile } from './loadFileAtConfigTime.js';
 import { resolvePointerImport } from './resolvePointerImport.js';
 import { getFilePathResolved } from '../getFilePath.js';
 import { assertExtensionsConventions, assertExtensionsRequire } from './assertExtensions.js';
 import '../../assertEnvVite.js';
-// TODO/after-PR-merge rename getPlusFilesByLocationId getPlusFiles
-async function getPlusFilesByLocationId(userRootDir, esbuildCache) {
-    const plusFilePaths = (await crawlPlusFilePaths(userRootDir)).map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
+async function getPlusFiles(userRootDir, esbuildCache) {
+    const plusFilePaths = (await crawlPlusFiles(userRootDir)).map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     const plusFilesByLocationId = {};
     await Promise.all(plusFilePaths.map(async (filePath) => {
         if (getPlusFileValueConfigName(filePath.filePathAbsoluteFilesystem) === 'config') {

package/dist/node/vite/shared/resolveVikeConfigInternal/loadFileAtConfigTime.d.ts

@@ -5,7 +5,7 @@ export type { ConfigFile };
 export type { PointerImportLoaded };
 import type { FilePathResolved } from '../../../../types/FilePath.js';
 import { type EsbuildCache } from './transpileAndExecuteFile.js';
-import type { PlusFileValue } from './getPlusFilesByLocationId.js';
+import type { PlusFileValue } from './getPlusFiles.js';
 import { PointerImport } from './resolvePointerImport.js';
 import type { ConfigDefinitionsInternal } from './metaBuiltIn.js';
 import '../../assertEnvVite.js';

package/dist/node/vite/shared/resolveVikeConfigInternal/metaBuiltIn.js

@@ -327,6 +327,10 @@ const metaBuiltIn = {
     vercel: {
         env: { config: true },
     },
+    ai: {
+        env: { config: true },
+        global: true,
+    },
 };
 function getConfigEnv(pageConfig, configName) {
     const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);

package/dist/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -15,7 +15,7 @@ export type { PageConfigBuildTimeBeforeComputed };
 import type { PageConfigGlobalBuildTime, ConfigEnv, PageConfigBuildTime, DefinedAtFilePath } from '../../../types/PageConfig.js';
 import { type ConfigDefinitionsInternal } from './resolveVikeConfigInternal/metaBuiltIn.js';
 import { type GlobalConfigPublic } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
-import { type PlusFile } from './resolveVikeConfigInternal/getPlusFilesByLocationId.js';
+import { type PlusFile } from './resolveVikeConfigInternal/getPlusFiles.js';
 import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
 import type { ResolvedConfig, UserConfig } from 'vite';
 import { type DangerouslyUseInternals } from '../../../shared-server-client/getPublicProxy.js';

package/dist/node/vite/shared/resolveVikeConfigInternal.js

@@ -45,10 +45,10 @@ import { getFilePathResolved } from './getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared-server-client/page-configs/getConfigValueBuildTime.js';
 import { resolveGlobalConfigPublic, } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
 import { getConfigValuesBase, isJsonValue, } from '../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
-import { getPlusFilesByLocationId, getPlusFileFromConfigFile, } from './resolveVikeConfigInternal/getPlusFilesByLocationId.js';
+import { getPlusFiles, getPlusFileFromConfigFile, } from './resolveVikeConfigInternal/getPlusFiles.js';
 import { assertRouteString } from '../../../shared-server-client/route/resolveRouteString.js';
 import { getExtensionName } from './resolveVikeConfigInternal/assertExtensions.js';
-import { getEnvVarObject } from './getEnvVarObject.js';
+import { getEnvVarObject } from '../../../utils/getEnvVarObject.js';
 import { getVikeApiOperation } from '../../../shared-server-node/api-context.js';
 import { getCliOptions } from '../../cli/context.js';
 import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
@@ -216,7 +216,7 @@ function hasViteConfigChanged(vikeConfigOld, vikeConfigNew) {
     return false;
 }
 async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache) {
-    const plusFilesByLocationId = await getPlusFilesByLocationId(userRootDir, esbuildCache);
+    const plusFilesByLocationId = await getPlusFiles(userRootDir, esbuildCache);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbuildCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesByLocationId, userRootDir);
     if (!globalObject.isV1Design_)
@@ -292,7 +292,7 @@ async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbu
     return configDefinitionsResolved;
 }
 // Load value files (with `env.config===true`) of *custom* configs.
-// - The value files of *built-in* configs are already loaded at `getPlusFilesByLocationId()`.
+// - The value files of *built-in* configs are already loaded at `getPlusFiles()`.
 async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache) {
     const plusFileList = Object.values(plusFiles).flat(1);
     await Promise.all(plusFileList.map(async (plusFile) => {
@@ -715,7 +715,7 @@ function sortPlusFilesSameLocationId(plusFile1, plusFile2, configName) {
             return ret;
     }
     // Config set by +{configName}.js (highest precedence)
-    // No need to make it deterministic: the overall order is already deterministic, see sortMakeDeterministic() at getPlusFilesByLocationId()
+    // No need to make it deterministic: the overall order is already deterministic, see sortMakeDeterministic() at getPlusFiles()
     return 0;
 }
 function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal, plusFilesByLocationId) {

package/dist/types/Config.d.ts

@@ -57,7 +57,7 @@ type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRende
 type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext' | 'onError' | 'onHookCall';
 type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
 type ConfigNameBuiltIn = Exclude<keyof ConfigBuiltIn, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects' | 'pages'> | 'prerender' | 'hasServerOnlyHook' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'guardEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware' | 'server' | 'vercel';
-type ConfigNameBuiltInGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'pages' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
+type ConfigNameBuiltInGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'pages' | 'prerender' | 'ai' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
 type Config = ConfigBuiltIn & Vike.Config;
 /** @deprecated This type is deprecated, see:
  * - https://vike.dev/migration/hook-types
@@ -583,6 +583,26 @@ type ConfigBuiltIn = {
      * https://vike.dev/vercel
      */
     vercel?: Vercel;
+    /**
+     * Setting for Vike's AI integration.
+     *
+     * https://vike.dev/ai
+     */
+    ai?: ConfigAi;
+};
+type ConfigAi = {
+    /**
+     * Whether Vike automatically adds and updates `vike/SKILL.md` inside skills directories (e.g. `.agents/skills/` and `.claude/skills/`).
+     *
+     * - `true`: add `vike/SKILL.md` to every existing `skills/` directory
+     * - `false`: never add `vike/SKILL.md`
+     * - `string[]`: add `vike/SKILL.md` to exactly these directories
+     *
+     * @default true
+     *
+     * https://vike.dev/ai#skill
+     */
+    skill?: boolean | string[];
 };
 type Vercel = {
     /**

package/dist/types/PageConfig.d.ts

@@ -24,7 +24,7 @@ import type { ConfigValueSerialized } from '../shared-server-client/page-configs
 import type { LocationId } from '../node/vite/shared/resolveVikeConfigInternal/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
 import type { ConfigDefinitionsInternal } from '../node/vite/shared/resolveVikeConfigInternal/metaBuiltIn.js';
-import type { PlusFile } from '../node/vite/shared/resolveVikeConfigInternal/getPlusFilesByLocationId.js';
+import type { PlusFile } from '../node/vite/shared/resolveVikeConfigInternal/getPlusFiles.js';
 import type { ApiOperation } from '../node/api/types.js';
 type PageConfigCommon = {
     pageId: string;

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.260-commit-8a30a91";
+export declare const PROJECT_VERSION: "0.4.260-commit-2e7fb2a";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.260-commit-8a30a91';
+export const PROJECT_VERSION = '0.4.260-commit-2e7fb2a';

package/dist/utils/crawlFiles/ignorePatternsBuiltIn.d.ts

@@ -0,0 +1 @@
+export declare const ignorePatternsBuiltIn: readonly ["**/node_modules/**", "**/.git/**", "**/ejected/**", "**/*.telefunc.*", "**/.history/**", "**/*.generated.*", "**/*.spec.*", "**/*.test.*"];

package/dist/{node/vite/shared/resolveVikeConfigInternal/crawlPlusFilePaths → utils/crawlFiles}/ignorePatternsBuiltIn.js

@@ -1,6 +1,6 @@
-import '../../../assertEnvVite.js';
 export const ignorePatternsBuiltIn = [
     '**/node_modules/**',
+    '**/.git/**',
     // Ejected Vike extensions, see https://github.com/snake-py/eject
     '**/ejected/**',
     // Allow:

package/dist/utils/crawlFiles.d.ts

@@ -0,0 +1,21 @@
+export { crawlFiles };
+declare const globstar = "**/";
+type FilePattern = `${typeof globstar}${'+*' | 'skills/*/SKILL'}`;
+/**
+ * Crawl the files matching `filePattern`, using `$ git ls-files` and, as a fallback, [tinyglobby](https://github.com/SuperchupuDev/tinyglobby).
+ */
+declare function crawlFiles(options: {
+    filePattern: FilePattern;
+    fileExtension: readonly string[];
+    cwd: string;
+    /**
+     * Whether dotfiles and dot directories are crawled.
+     *
+     * Same as tinyglobby's `dot` option.
+     */
+    dot: boolean;
+    /**
+     * Whether to fallback to tinyglobby if `$ git ls-files` doesn't find any file.
+     */
+    globFallback: boolean;
+}): Promise<string[]>;

package/dist/utils/crawlFiles.js

@@ -0,0 +1,195 @@
+export { crawlFiles };
+import { assert, assertUsage, assertWarning } from './assert.js';
+import { assertIsNotProductionRuntime } from './assertSetup.js';
+import { isVersionMatch } from './assertVersion.js';
+import { createDebug } from './debug.js';
+import { deepEqual } from './deepEqual.js';
+import { getGlobalObject } from './getGlobalObject.js';
+import { hasProp } from './hasProp.js';
+import { isNotNullish } from './isNullish.js';
+import path from 'node:path';
+import { glob as tinyglobby } from 'tinyglobby';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { getEnvVarObject } from './getEnvVarObject.js';
+import pc from '@brillout/picocolors';
+import picomatch from 'picomatch';
+import { ignorePatternsBuiltIn } from './crawlFiles/ignorePatternsBuiltIn.js';
+assertIsNotProductionRuntime();
+const execA = promisify(exec);
+const debug = createDebug('vike:crawl');
+const globalObject = getGlobalObject('crawlFiles.ts', {
+    gitIsNotUsable: false,
+});
+const globstar = '**/';
+/**
+ * Crawl the files matching `filePattern`, using `$ git ls-files` and, as a fallback, [tinyglobby](https://github.com/SuperchupuDev/tinyglobby).
+ */
+async function crawlFiles(options) {
+    const { filePattern, fileExtension, cwd, dot, globFallback } = options;
+    const userSettings = getUserSettings();
+    const globOptions = { cwd, dot, nocase: false, ignore: getIgnorePatterns(userSettings) };
+    // One pattern per file extension (the `filePattern` skips the file extension)
+    assert(!path.posix.basename(filePattern).includes('.'));
+    const patterns = fileExtension.map((ext) => `${filePattern}.${ext}`);
+    // Crawl
+    const filesGit = userSettings.git !== false && (await crawlGit(patterns, cwd, globOptions));
+    const useGlob = 
+    // `!filesGit` => Git isn't usable => we *have* to use tinyglobby
+    !filesGit ||
+        // `filesGit.length === 0` => fallback to tinyglobby if globFallback is true
+        (filesGit.length === 0 && globFallback);
+    const filesGlob = (useGlob || debug.isActivated) && (await crawlGlob(patterns, globOptions));
+    const files = useGlob ? filesGlob : filesGit;
+    assert(files);
+    if (debug.isActivated && filesGit && filesGlob) {
+        assertWarning(deepEqual(filesGlob.slice().sort(), filesGit.slice().sort()), "Git and glob results aren't matching.", { onlyOnce: false });
+    }
+    return files;
+}
+// Same as crawlGlob() but using `$ git ls-files`
+async function crawlGit(patterns, cwd, globOptions) {
+    if (globalObject.gitIsNotUsable)
+        return null;
+    // Preserve UTF-8 file paths.
+    // https://github.com/vikejs/vike/issues/1658
+    // https://stackoverflow.com/questions/22827239/how-to-make-git-properly-display-utf-8-encoded-pathnames-in-the-console-window/22828826#22828826
+    // https://stackoverflow.com/questions/15884180/how-do-i-override-git-configuration-options-by-command-line-parameters/15884261#15884261
+    const preserveUTF8 = '-c core.quotepath=off';
+    const cmd = [
+        'git',
+        preserveUTF8,
+        'ls-files',
+        // Performance gain seems negligible: https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
+        ...patterns.flatMap((pattern) => {
+            // A leading `**/` doesn't match the root directory: we therefore add a second pattern for it — e.g. `**/+*.js` doesn't match `+config.js` while `+*.js` does
+            const patternRootDir = pattern.slice(globstar.length);
+            assert(!patternRootDir.includes(globstar)); // `**/` in the middle of the pattern isn't supported (e.g. `pages/**/+*.js` doesn't match `pages/+Page.js`)
+            return [`"${pattern}"`, `"${patternRootDir}"`];
+        }),
+        // Performance gain is non-negligible.
+        //  - https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
+        //  - When node_modules/ is untracked the performance gain could be significant?
+        ...globOptions.ignore.map((pattern) => `--exclude="${pattern}"`),
+        // --others --exclude-standard => list untracked files (--others) while using .gitignore (--exclude-standard)
+        // --cached => list tracked files
+        '--others --exclude-standard --cached',
+    ].join(' ');
+    let filesAll;
+    let filesDeleted;
+    try {
+        ;
+        [filesAll, filesDeleted] = await Promise.all([
+            // Main command
+            runCmd1(cmd, cwd),
+            // Get tracked but deleted files
+            runCmd1('git ls-files --deleted', cwd),
+        ]);
+    }
+    catch (err) {
+        if (await isGitNotUsable(cwd)) {
+            globalObject.gitIsNotUsable = true;
+            return null;
+        }
+        throw err;
+    }
+    if (debug.isActivated) {
+        debug('[git] cwd:', cwd);
+        debug('[git] cmd:', cmd);
+        debug('[git] result:', filesAll);
+        debug('[git] filesDeleted:', filesDeleted);
+    }
+    // We have to filter again here because:
+    //  - `$ git ls-files` matches more since wildcards are deep — e.g. `+*.js` matches `pages/+some-dir/some-file.js`
+    //  - the option --exclude of `$ git ls-files` only applies to untracked files. (We use --exclude only to speed up the `$ git ls-files` command.)
+    const isMatch = picomatch(patterns, globOptions);
+    const isDeleted = new Set(filesDeleted);
+    const files = filesAll.filter((filePath) => isMatch(filePath) && !isDeleted.has(filePath));
+    return files;
+}
+// Same as crawlGit() but using tinyglobby
+async function crawlGlob(patterns, globOptions) {
+    const files = await tinyglobby(patterns, globOptions);
+    // Make build deterministic, in order to get a stable generated hash for dist/client/assets/entries/entry-client-routing.${hash}.js
+    // https://github.com/vikejs/vike/pull/1750
+    files.sort();
+    if (debug.isActivated) {
+        debug('[glob] patterns:', patterns);
+        debug('[glob] options:', globOptions);
+        debug('[glob] result:', files);
+    }
+    return files;
+}
+// Whether Git is installed and whether we can use it
+async function isGitNotUsable(cwd) {
+    // Check Git version
+    {
+        const res = await runCmd2('git --version', cwd);
+        if ('err' in res)
+            return true;
+        let { stdout, stderr } = res;
+        assert(stderr === '');
+        const prefix = 'git version ';
+        assert(stdout.startsWith(prefix));
+        const gitVersion = stdout.slice(prefix.length);
+        //  - Works with Git 2.43.1 but also (most certainly) with earlier versions.
+        //    - We didn't bother test which is the earliest version that works.
+        //  - Git 2.32.0 doesn't seem to work: https://github.com/vikejs/vike/discussions/1549
+        //    - Maybe it's because of StackBlitz: looking at the release notes, Git 2.32.0 should be working.
+        if (!isVersionMatch(gitVersion, ['2.43.1']))
+            return true;
+    }
+    // Is cwd inside a Git repository?
+    {
+        const res = await runCmd2('git rev-parse --is-inside-work-tree', cwd);
+        if ('err' in res)
+            return true;
+        let { stdout, stderr } = res;
+        assert(stderr === '');
+        assert(stdout === 'true');
+        return false;
+    }
+}
+async function runCmd1(cmd, cwd) {
+    const { stdout } = await execA(cmd, {
+        cwd,
+        // https://github.com/vikejs/vike/issues/1982
+        maxBuffer: Infinity,
+    });
+    /* Not always true: https://github.com/vikejs/vike/issues/1440#issuecomment-1892831303
+    assert(res.stderr === '')
+    */
+    return stdout.toString().split('\n').filter(Boolean);
+}
+async function runCmd2(cmd, cwd) {
+    let res;
+    try {
+        res = await execA(cmd, { cwd });
+    }
+    catch (err) {
+        return { err };
+    }
+    let { stdout, stderr } = res;
+    stdout = stdout.toString().trim();
+    stderr = stderr.toString().trim();
+    return { stdout, stderr };
+}
+function getUserSettings() {
+    const userSettings = getEnvVarObject('VIKE_CRAWL') ?? {};
+    const wrongUsage = (settingName, settingType) => `Setting ${pc.cyan(settingName)} in VIKE_CRAWL should be a ${pc.cyan(settingType)}`;
+    assertUsage(hasProp(userSettings, 'git', 'boolean') || hasProp(userSettings, 'git', 'undefined'), wrongUsage('git', 'boolean'));
+    assertUsage(hasProp(userSettings, 'ignore', 'string[]') ||
+        hasProp(userSettings, 'ignore', 'string') ||
+        hasProp(userSettings, 'ignore', 'undefined'), wrongUsage('ignore', 'string or an array of strings'));
+    assertUsage(hasProp(userSettings, 'ignoreBuiltIn', 'boolean') || hasProp(userSettings, 'ignoreBuiltIn', 'undefined'), wrongUsage('ignoreBuiltIn', 'boolean'));
+    const settingNames = ['git', 'ignore', 'ignoreBuiltIn'];
+    Object.keys(userSettings).forEach((name) => {
+        assertUsage(settingNames.includes(name), `Unknown setting ${pc.bold(pc.red(name))} in VIKE_CRAWL`);
+    });
+    return userSettings;
+}
+function getIgnorePatterns(userSettings) {
+    const ignorePatternsSetByUser = [userSettings.ignore].flat().filter(isNotNullish);
+    const { ignoreBuiltIn } = userSettings;
+    return [...(ignoreBuiltIn === false ? [] : ignorePatternsBuiltIn), ...ignorePatternsSetByUser];
+}

package/dist/{node/vite/shared → utils}/getEnvVarObject.d.ts

@@ -1,5 +1,4 @@
 export { getEnvVarObject };
 export { parseJson5 };
-import '../assertEnvVite.js';
 declare function getEnvVarObject(envVarName: 'VITE_CONFIG' | 'VIKE_CRAWL' | 'VIKE_CONFIG'): null | Record<string, unknown>;
 declare function parseJson5(valueStr: string, what: string): unknown;

package/dist/{node/vite/shared → utils}/getEnvVarObject.js

@@ -1,10 +1,11 @@
 export { getEnvVarObject };
 export { parseJson5 };
 import pc from '@brillout/picocolors';
-import { assertUsage } from '../../../utils/assert.js';
-import { isObject } from '../../../utils/isObject.js';
+import { assertUsage } from './assert.js';
+import { isObject } from './isObject.js';
 import JSON5 from 'json5';
-import '../assertEnvVite.js';
+import { assertIsNotProductionRuntime } from './assertSetup.js';
+assertIsNotProductionRuntime();
 function getEnvVarObject(envVarName) {
     const valueStr = process.env[envVarName];
     if (!valueStr)

package/dist/utils/setTimeoutUnref.d.ts

@@ -0,0 +1,2 @@
+export { setTimeoutUnref };
+declare function setTimeoutUnref(callback: () => void, milliseconds: number): ReturnType<typeof setTimeout>;

package/dist/utils/setTimeoutUnref.js

@@ -0,0 +1,11 @@
+export { setTimeoutUnref };
+// Same as setTimeout() but the timer never keeps the Node.js process alive (e.g. upon programmatic dev server usage that exits quickly, the process shouldn't linger because of some pending bookkeeping timer).
+//  - https://nodejs.org/api/timers.html#timeoutunref
+//  - Only use it for auxiliary timers (bookkeeping, diagnostics, background work) — never for:
+//    - Timers that resume the main flow (e.g. sleep()): the process could exit before the timer fires.
+//    - Watchdog timers (e.g. hooksTimeout, genPromise() timeout): their purpose is to fire when everything else hangs — being the last thing that keeps the process alive is their job (without them Node.js would silently exit with code 0).
+function setTimeoutUnref(callback, milliseconds) {
+    const timeout = setTimeout(callback, milliseconds);
+    timeout.unref?.();
+    return timeout;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.260-commit-8a30a91",
+  "version": "0.4.260-commit-2e7fb2a",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -137,7 +137,7 @@
     "es-module-lexer": "^1.0.0",
     "esbuild": ">=0.19.0",
     "json5": "^2.0.0",
-    "magic-string": "^1.1.0",
+    "magic-string": "^1.2.0",
     "picomatch": "^4.0.5",
     "semver": "^7.8.5",
     "sirv": "^3.0.2",

package/dist/node/vite/shared/resolveVikeConfigInternal/crawlPlusFilePaths/ignorePatternsBuiltIn.d.ts

@@ -1,2 +0,0 @@
-import '../../../assertEnvVite.js';
-export declare const ignorePatternsBuiltIn: readonly ["**/node_modules/**", "**/ejected/**", "**/*.telefunc.*", "**/.history/**", "**/*.generated.*", "**/*.spec.*", "**/*.test.*"];

package/dist/node/vite/shared/resolveVikeConfigInternal/crawlPlusFilePaths.js

@@ -1,259 +0,0 @@
-export { crawlPlusFilePaths };
-export { isPlusFile };
-export { getPlusFileValueConfigName };
-import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
-import { assertIsNotProductionRuntime } from '../../../../utils/assertSetup.js';
-import { isVersionMatch } from '../../../../utils/assertVersion.js';
-import { createDebug } from '../../../../utils/debug.js';
-import { deepEqual } from '../../../../utils/deepEqual.js';
-import { getGlobalObject } from '../../../../utils/getGlobalObject.js';
-import { hasProp } from '../../../../utils/hasProp.js';
-import { assertFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
-import { isNotNullish } from '../../../../utils/isNullish.js';
-import { scriptFileExtensionPattern, isScriptFile, scriptFileExtensionList } from '../../../../utils/isScriptFile.js';
-import { assertPosixPath } from '../../../../utils/path.js';
-import path from 'node:path';
-import { glob } from 'tinyglobby';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
-import { getEnvVarObject } from '../getEnvVarObject.js';
-import pc from '@brillout/picocolors';
-import picomatch from 'picomatch';
-import { ignorePatternsBuiltIn } from './crawlPlusFilePaths/ignorePatternsBuiltIn.js';
-import '../../assertEnvVite.js';
-const execA = promisify(exec);
-const debug = createDebug('vike:crawl');
-assertIsNotProductionRuntime();
-const globalObject = getGlobalObject('getVikeConfig/crawlPlusFilePaths.ts', {
-    gitIsNotUsable: false,
-});
-// TODO/after-PR-merge rename crawlPlusFilePaths crawlPlusFiles
-async function crawlPlusFilePaths(userRootDir) {
-    assertPosixPath(userRootDir);
-    assertFilePathAbsoluteFilesystem(userRootDir);
-    const userSettings = getUserSettings();
-    const { ignorePatterns, ignoreMatchers } = getIgnore(userSettings);
-    // Crawl
-    const filesGit = userSettings.git !== false && (await gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers));
-    const filesGitNothingFound = !filesGit || filesGit.length === 0;
-    const filesGlob = (filesGitNothingFound || debug.isActivated) && (await tinyglobby(userRootDir, ignorePatterns));
-    let files = !filesGitNothingFound
-        ? filesGit
-        : // Fallback to tinyglobby for users that dynamically generate plus files. (Assuming that no plus file is found because of the user's .gitignore list.)
-            filesGlob;
-    assert(files);
-    if (debug.isActivated && filesGit && filesGlob) {
-        assertWarning(deepEqual(filesGlob.slice().sort(), filesGit.slice().sort()), "Git and glob results aren't matching.", { onlyOnce: false });
-    }
-    // Filter build files
-    files = files.filter((filePath) => !isTemporaryBuildFile(filePath));
-    // Normalize
-    const plusFiles = files.map((filePath) => {
-        // Both `$ git-ls files` and tinyglobby return posix paths
-        assertPosixPath(filePath);
-        assert(!filePath.startsWith(userRootDir));
-        const filePathAbsoluteUserRootDir = path.posix.join('/', filePath);
-        assert(isPlusFile(filePathAbsoluteUserRootDir));
-        return { filePathAbsoluteUserRootDir };
-    });
-    return plusFiles;
-}
-// Same as tinyglobby() but using `$ git ls-files`
-async function gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers) {
-    if (globalObject.gitIsNotUsable)
-        return null;
-    // Preserve UTF-8 file paths.
-    // https://github.com/vikejs/vike/issues/1658
-    // https://stackoverflow.com/questions/22827239/how-to-make-git-properly-display-utf-8-encoded-pathnames-in-the-console-window/22828826#22828826
-    // https://stackoverflow.com/questions/15884180/how-do-i-override-git-configuration-options-by-command-line-parameters/15884261#15884261
-    const preserveUTF8 = '-c core.quotepath=off';
-    const cmd = [
-        'git',
-        preserveUTF8,
-        'ls-files',
-        // Performance gain seems negligible: https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
-        ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}" "+*.${ext}"`),
-        // Performance gain is non-negligible.
-        //  - https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
-        //  - When node_modules/ is untracked the performance gain could be significant?
-        ...ignorePatterns.map((pattern) => `--exclude="${pattern}"`),
-        // --others --exclude-standard => list untracked files (--others) while using .gitignore (--exclude-standard)
-        // --cached => list tracked files
-        '--others --exclude-standard --cached',
-    ].join(' ');
-    let filesAll;
-    let filesDeleted;
-    try {
-        ;
-        [filesAll, filesDeleted] = await Promise.all([
-            // Main command
-            runCmd1(cmd, userRootDir),
-            // Get tracked but deleted files
-            runCmd1('git ls-files --deleted', userRootDir),
-        ]);
-    }
-    catch (err) {
-        if (await isGitNotUsable(userRootDir)) {
-            globalObject.gitIsNotUsable = true;
-            return null;
-        }
-        throw err;
-    }
-    if (debug.isActivated) {
-        debug('[git] userRootDir:', userRootDir);
-        debug('[git] cmd:', cmd);
-        debug('[git] result:', filesAll);
-        debug('[git] filesDeleted:', filesDeleted);
-    }
-    const files = [];
-    for (const filePath of filesAll) {
-        // + file?
-        if (!path.posix.basename(filePath).startsWith('+'))
-            continue;
-        // We have to repeat the same exclusion logic here because the option --exclude of `$ git ls-files` only applies to untracked files. (We use --exclude only to speed up the `$ git ls-files` command.)
-        if (ignoreMatchers.some((m) => m(filePath)))
-            continue;
-        // JavaScript file?
-        if (!isScriptFile(filePath))
-            continue;
-        // Deleted?
-        if (filesDeleted.includes(filePath))
-            continue;
-        files.push(filePath);
-    }
-    return files;
-}
-// Same as gitLsFiles() but using tinyglobby
-async function tinyglobby(userRootDir, ignorePatterns) {
-    const pattern = `**/+*.${scriptFileExtensionPattern}`;
-    const options = {
-        ignore: ignorePatterns,
-        cwd: userRootDir,
-        dot: false,
-    };
-    const files = await glob(pattern, options);
-    // Make build deterministic, in order to get a stable generated hash for dist/client/assets/entries/entry-client-routing.${hash}.js
-    // https://github.com/vikejs/vike/pull/1750
-    files.sort();
-    if (debug.isActivated) {
-        debug('[glob] pattern:', pattern);
-        debug('[glob] options:', options);
-        debug('[glob] result:', files);
-    }
-    return files;
-}
-// Whether Git is installed and whether we can use it
-async function isGitNotUsable(userRootDir) {
-    // Check Git version
-    {
-        const res = await runCmd2('git --version', userRootDir);
-        if ('err' in res)
-            return true;
-        let { stdout, stderr } = res;
-        assert(stderr === '');
-        const prefix = 'git version ';
-        assert(stdout.startsWith(prefix));
-        const gitVersion = stdout.slice(prefix.length);
-        //  - Works with Git 2.43.1 but also (most certainly) with earlier versions.
-        //    - We didn't bother test which is the earliest version that works.
-        //  - Git 2.32.0 doesn't seem to work: https://github.com/vikejs/vike/discussions/1549
-        //    - Maybe it's because of StackBlitz: looking at the release notes, Git 2.32.0 should be working.
-        if (!isVersionMatch(gitVersion, ['2.43.1']))
-            return true;
-    }
-    // Is userRootDir inside a Git repository?
-    {
-        const res = await runCmd2('git rev-parse --is-inside-work-tree', userRootDir);
-        if ('err' in res)
-            return true;
-        let { stdout, stderr } = res;
-        assert(stderr === '');
-        assert(stdout === 'true');
-        return false;
-    }
-}
-async function runCmd1(cmd, cwd) {
-    const { stdout } = await execA(cmd, {
-        cwd,
-        // https://github.com/vikejs/vike/issues/1982
-        maxBuffer: Infinity,
-    });
-    /* Not always true: https://github.com/vikejs/vike/issues/1440#issuecomment-1892831303
-    assert(res.stderr === '')
-    */
-    return stdout.toString().split('\n').filter(Boolean);
-}
-async function runCmd2(cmd, cwd) {
-    let res;
-    try {
-        res = await execA(cmd, { cwd });
-    }
-    catch (err) {
-        return { err };
-    }
-    let { stdout, stderr } = res;
-    stdout = stdout.toString().trim();
-    stderr = stderr.toString().trim();
-    return { stdout, stderr };
-}
-function getUserSettings() {
-    const userSettings = getEnvVarObject('VIKE_CRAWL') ?? {};
-    const wrongUsage = (settingName, settingType) => `Setting ${pc.cyan(settingName)} in VIKE_CRAWL should be a ${pc.cyan(settingType)}`;
-    assertUsage(hasProp(userSettings, 'git', 'boolean') || hasProp(userSettings, 'git', 'undefined'), wrongUsage('git', 'boolean'));
-    assertUsage(hasProp(userSettings, 'ignore', 'string[]') ||
-        hasProp(userSettings, 'ignore', 'string') ||
-        hasProp(userSettings, 'ignore', 'undefined'), wrongUsage('git', 'string or an array of strings'));
-    assertUsage(hasProp(userSettings, 'ignoreBuiltIn', 'boolean') || hasProp(userSettings, 'ignoreBuiltIn', 'undefined'), wrongUsage('ignoreBuiltIn', 'boolean'));
-    const settingNames = ['git', 'ignore', 'ignoreBuiltIn'];
-    Object.keys(userSettings).forEach((name) => {
-        assertUsage(settingNames.includes(name), `Unknown setting ${pc.bold(pc.red(name))} in VIKE_CRAWL`);
-    });
-    return userSettings;
-}
-function isPlusFile(filePath) {
-    assertPosixPath(filePath);
-    if (isTemporaryBuildFile(filePath))
-        return false;
-    const fileName = filePath.split('/').pop();
-    return fileName.startsWith('+');
-}
-function getPlusFileValueConfigName(filePath) {
-    if (!isPlusFile(filePath))
-        return null;
-    const fileName = path.posix.basename(filePath);
-    // assertNoUnexpectedPlusSign(filePath, fileName)
-    const basename = fileName.split('.')[0];
-    assert(basename.startsWith('+'));
-    const configName = basename.slice(1);
-    assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
-    return configName;
-}
-/* https://github.com/vikejs/vike/issues/1407
-function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
-  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`
-  )
-}
-*/
-function getIgnore(userSettings) {
-    const ignorePatternsSetByUser = [userSettings.ignore].flat().filter(isNotNullish);
-    const { ignoreBuiltIn } = userSettings;
-    const ignorePatterns = [...(ignoreBuiltIn === false ? [] : ignorePatternsBuiltIn), ...ignorePatternsSetByUser];
-    const ignoreMatchers = ignorePatterns.map((p) => picomatch(p, {
-        // We must pass the same settings than tinyglobby
-        // https://github.com/SuperchupuDev/tinyglobby/blob/fcfb08a36c3b4d48d5488c21000c95a956d9797c/src/index.ts#L191-L194
-        dot: false,
-        nocase: false,
-    }));
-    return { ignorePatterns, ignoreMatchers };
-}