vike 0.4.259 → 0.4.260-commit-2e7fb2a

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/optimizeDeps.js

@@ -3,6 +3,7 @@ export { resolveOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert } from '../../../../utils/assert.js';
 import { createDebug } from '../../../../utils/debug.js';
+import { deepEqual } from '../../../../utils/deepEqual.js';
 import { isArray } from '../../../../utils/isArray.js';
 import { isFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
 import { assertImportIsNpmPackage, getNpmPackageName } from '../../../../utils/parseNpmPackage.js';
@@ -24,8 +25,12 @@ const LATE_DISCOVERED = [
     // Workaround for https://github.com/vikejs/vike/issues/2823#issuecomment-3514325487
     '@compiled/react/runtime',
 ];
-// TO-DO/eventually: remove this.
-// Avoid following warning for older vike-photon versions:
+// TO-DO/eventually: remove this workaround using following plan:
+// 1. Remove `include: ["vike > @brillout/require-shim"]` from vike-photon
+//    https://github.com/vikejs/vike-photon/blob/e11edb617ae44da6c1748222c387b10bf3fa5495/packages/vike-photon/src/plugin/plugins/configPlugin.ts#L16-L17
+// 2. Release new vike-photon version
+// 2. Remove this workaround
+// Even though Vike doesn't use @brillout/require-shim anymore, it's still needed because vike-photon adds @brillout/require-shim to optimizeDeps.include which leads to this error:
 // ```
 // [11:32:49.768][/test/photon-vercel/.test-dev.test.ts][pnpm run dev][stderr] Failed to resolve dependency: vike > @brillout/require-shim, present in ssr 'optimizeDeps.include'
 // ```
@@ -70,9 +75,9 @@ const optimizeDeps = {
 // - Make server environments inherit from ssr.optimizeDeps (it isn't the case by default)
 async function resolveOptimizeDeps(config) {
     const vikeConfig = await getVikeConfigInternal();
-    const { _pageConfigs: pageConfigs } = vikeConfig;
+    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
     // Retrieve user's + files (i.e. Vike entries)
-    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
+    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs, pageConfigGlobal);
     // Add late discovered dependencies, if they exist
     LATE_DISCOVERED.forEach((dep) => {
         const userRootDir = config.root;
@@ -114,18 +119,19 @@ async function resolveOptimizeDeps(config) {
         env.optimizeDeps.entries = remove(env.optimizeDeps.entries ?? []);
     }
     // Debug
-    if (debug.isActivated)
-        debug('optimizeDeps', {
-            'config.optimizeDeps.entries': config.optimizeDeps.entries,
-            'config.optimizeDeps.include': config.optimizeDeps.include,
-            'config.optimizeDeps.exclude': config.optimizeDeps.exclude,
-            // @ts-ignore Vite doesn't seem to support ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
-            'config.ssr.optimizeDeps.entries': config.ssr.optimizeDeps.entries,
-            'config.ssr.optimizeDeps.include': config.ssr.optimizeDeps.include,
-            'config.ssr.optimizeDeps.exclude': config.ssr.optimizeDeps.exclude,
-        });
+    if (debug.isActivated) {
+        const envs = {};
+        for (const envName in config.environments) {
+            const env = config.environments[envName];
+            envs[`config.environments.${envName}.optimizeDeps.entries`] = env.optimizeDeps.entries;
+            envs[`config.environments.${envName}.optimizeDeps.include`] = env.optimizeDeps.include;
+            envs[`config.environments.${envName}.optimizeDeps.exclude`] = env.optimizeDeps.exclude;
+        }
+        debug('optimizeDeps', envs);
+        assertEnvsInSyncWithLegacy(config);
+    }
 }
-async function getPageDeps(config, pageConfigs) {
+async function getPageDeps(config, pageConfigs, pageConfigGlobal) {
     let entriesClient = [];
     let entriesServer = [];
     let includeClient = [];
@@ -158,6 +164,14 @@ async function getPageDeps(config, pageConfigs) {
             includeServer.push(e);
         }
     };
+    const addEntryOrInclude = (filePath, isForClientSide, definedAt) => {
+        if (filePath.filePathAbsoluteUserRootDir !== null) {
+            addEntry(filePath.filePathAbsoluteFilesystem, isForClientSide, definedAt);
+        }
+        else {
+            addInclude(filePath.importPathAbsolute, isForClientSide, definedAt);
+        }
+    };
     const isExcluded = (e, isForClientSide, definedAt) => {
         const exclude = isForClientSide ? config.optimizeDeps.exclude : config.ssr.optimizeDeps.exclude;
         if (!exclude)
@@ -173,7 +187,8 @@ async function getPageDeps(config, pageConfigs) {
     {
         ;
         [true, false].forEach((isForClientSide) => {
-            pageConfigs.forEach((pageConfig) => {
+            ;
+            [...pageConfigs, pageConfigGlobal].forEach((pageConfig) => {
                 Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
                     const runtimeEnv = {
                         isForClientSide,
@@ -188,16 +203,7 @@ async function getPageDeps(config, pageConfigs) {
                         const { definedAt } = configValueSource;
                         if (definedAt.definedBy)
                             return;
-                        if (definedAt.filePathAbsoluteUserRootDir !== null) {
-                            addEntry(
-                            // optimizeDeps.entries expects filesystem absolute paths
-                            definedAt.filePathAbsoluteFilesystem, isForClientSide, definedAt);
-                        }
-                        else {
-                            addInclude(
-                            // optimizeDeps.include expects npm packages
-                            definedAt.importPathAbsolute, isForClientSide, definedAt);
-                        }
+                        addEntryOrInclude(definedAt, isForClientSide, definedAt);
                     });
                 });
             });
@@ -214,13 +220,26 @@ async function getPageDeps(config, pageConfigs) {
         });
     }
     // Add virtual files.
-    // - This doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
-    //   - Should we make it work? E.g. by creating a temporary file at node_modules/.vike/virtualFiles.js
-    //   - Or should we remove it? And make sure getPageDeps() also works for aliased import paths
-    //     - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
+    // - Vite 8+ (Rolldown-based dep scanner) crawls virtual IDs natively — its scanner routes
+    //   through `environment.pluginContainer.resolveId()`, so Vike's resolveId/load handlers
+    //   run during the scan and the virtual file's transitive deps are seen.
+    // - Vite ≤7 (esbuild-based dep scanner) cannot crawl virtual IDs — those virtuals' deps
+    //   surface lazily and trigger "✨ new dependencies optimized" reload cycles. As a
+    //   workaround we could materialize each virtual to a real file under
+    //   `node_modules/.vike/optimizeDeps-virtuals/`; an implementation lives in the reverted
+    //   commit https://github.com/vikejs/vike/commit/b068009c3 (re-apply if Vite ≤7 support
+    //   matters).
     {
         const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
-        Object.values(clientEntries).forEach((e) => addEntry(e, true));
+        Object.values(clientEntries).forEach(({ entryTarget, entryFilePath }) => {
+            if (entryFilePath) {
+                addEntryOrInclude(entryFilePath, true);
+            }
+            else {
+                // Page-entry virtual IDs have no file path.
+                addEntry(entryTarget, true);
+            }
+        });
         if (hasClientRouting)
             addEntry(virtualFileIdGlobalEntryClientCR, true);
         if (hasServerRouting)
@@ -258,3 +277,20 @@ function remove(input) {
     list = list.filter((e) => !ALWAYS_REMOVE.includes(e));
     return list;
 }
+// Sanity-check that the legacy `config.optimizeDeps` and `config.ssr.optimizeDeps` slots
+// stay in sync with the corresponding environment values — so logging only the env values
+// (above) isn't hiding anything.
+function assertEnvsInSyncWithLegacy(config) {
+    const client = config.environments.client?.optimizeDeps;
+    assert(client);
+    assert(deepEqual(config.optimizeDeps.entries, client.entries));
+    assert(deepEqual(config.optimizeDeps.include, client.include));
+    assert(deepEqual(config.optimizeDeps.exclude, client.exclude));
+    const ssr = config.environments.ssr?.optimizeDeps;
+    assert(ssr);
+    /* Vite doesn't seem to support config.ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
+    assert(deepEqual(config.ssr.optimizeDeps.entries, ssr.entries))
+    */
+    assert(deepEqual(config.ssr.optimizeDeps.include, ssr.include));
+    assert(deepEqual(config.ssr.optimizeDeps.exclude, ssr.exclude));
+}

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/pluginStripPointerImportAttribute.js

@@ -1,4 +1,5 @@
 export { pluginStripPointerImportAttribute };
+import { getImportStatements } from '../shared/parseEsModule.js';
 import { getMagicString } from '../shared/getMagicString.js';
 import '../assertEnvVite.js';
 // Match `with { type: 'vike:pointer' }` (with optional whitespace variations)
@@ -14,18 +15,38 @@ function pluginStripPointerImportAttribute() {
                     },
                 },
                 handler(code, id) {
-                    runtimeAttrRE.lastIndex = 0;
-                    if (!runtimeAttrRE.test(code))
-                        return;
-                    const { magicString, getMagicStringResult } = getMagicString(code, id);
-                    runtimeAttrRE.lastIndex = 0;
-                    let match;
-                    while ((match = runtimeAttrRE.exec(code)) !== null) {
-                        magicString.remove(match.index, match.index + match[0].length);
-                    }
-                    return getMagicStringResult();
+                    return stripPointerImportAttributes(code, id);
                 },
             },
         },
     ];
 }
+async function stripPointerImportAttributes(code, id) {
+    // Fast path: skip parsing when there is nothing to strip
+    runtimeAttrRE.lastIndex = 0;
+    if (!runtimeAttrRE.test(code))
+        return;
+    // Restrict stripping to genuine `import` statements, so that we don't touch occurrences
+    // inside string literals/comments (e.g. documentation code examples).
+    // https://github.com/brillout/docpress/issues/167
+    let importStatements;
+    try {
+        importStatements = await getImportStatements(code);
+    }
+    catch {
+        // Not parsable as an ES module (e.g. a raw Markdown file) => leave it untouched
+        return;
+    }
+    const { magicString, getMagicStringResult } = getMagicString(code, id);
+    for (const { ss, se } of importStatements)
+        stripAttribute(magicString, code, ss, se);
+    return getMagicStringResult();
+}
+function stripAttribute(magicString, code, start, end) {
+    const region = code.slice(start, end);
+    runtimeAttrRE.lastIndex = 0;
+    let match;
+    while ((match = runtimeAttrRE.exec(region)) !== null) {
+        magicString.remove(start + match.index, start + match.index + match[0].length);
+    }
+}

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

@@ -1,5 +1,5 @@
 export { generateVirtualFilePageEntry };
-import { assert, getProjectError } from '../../../../utils/assert.js';
+import { assert, getDebugInfoStr, getProjectError } from '../../../../utils/assert.js';
 import { parseVirtualFileId, generateVirtualFileId } from '../../../../shared-server-node/virtualFileId.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { extractAssetsAddQuery } from '../../../../shared-server-node/extractAssetsQuery.js';
@@ -26,12 +26,10 @@ async function generateVirtualFilePageEntry(id, isDev) {
         assert(pageConfig);
     }
     else {
-        /* This assertion sometimes fail. It happens very seldom and I couldn't reproduce it (https://gist.github.com/brillout/9e212ce829f4d62a912ca163ffa8881a). I suspect some kind of HMR race condition. UPDATE: [December 2024] This just happened at test/@cloudflare_vite-plugin/ — it isn't blocking, reloading the page fixes the issue.
-        assert(pageConfig, { id, pageId })
-        /*/
-        if (!pageConfig)
-            throw getProjectError('Outdated request');
-        //*/
+        if (!pageConfig) {
+            // Happens very seldom and can't reproduce reliably. Some kind of HMR race condition? It still happens as of June 2026 with Cloudflare Workers in development — but it isn't blocking, reloading the page fixes the issue.
+            throw getProjectError(`Outdated request. Try again. ${getDebugInfoStr({ id, pageId })}`);
+        }
     }
     const code = getCode(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);

package/dist/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.d.ts

@@ -3,7 +3,7 @@ export { getConfigValueSourceRelevantAnyEnv };
 export { isRuntimeEnvMatch };
 export { isConfigSourceValueNull };
 export type { RuntimeEnv };
-import type { ConfigEnvInternal, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
+import type { ConfigEnv, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
 import '../../assertEnvVite.js';
 type RuntimeEnv = {
     isForClientSide: boolean;
@@ -15,5 +15,5 @@ type RuntimeEnv = {
 type PageConfigPartial = Pick<PageConfigBuildTime | PageConfigGlobalBuildTime, 'configValueSources' | 'configDefinitions'>;
 declare function getConfigValueSourcesRelevant(configName: string, runtimeEnv: RuntimeEnv, pageConfig: PageConfigPartial): ConfigValueSource[];
 declare function getConfigValueSourceRelevantAnyEnv(configName: string, pageConfig: PageConfigPartial): null | ConfigValueSource;
-declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtimeEnv: RuntimeEnv): boolean;
+declare function isRuntimeEnvMatch(configEnv: ConfigEnv, runtimeEnv: RuntimeEnv): boolean;
 declare function isConfigSourceValueNull(source: ConfigValueSource): boolean | null;

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/addSsrMiddleware.js

@@ -14,7 +14,7 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
         const pageContextInit = {
             urlOriginal: url,
             headersOriginal: headers,
-            _reqDev: req,
+            _nodeDev: { req, res },
         };
         Object.defineProperty(pageContextInit, 'userAgent', {
             get() {

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

@@ -5,6 +5,6 @@ declare function getMagicString(code: string, id: string): {
     magicString: MagicString;
     getMagicStringResult: () => {
         code: string;
-        map: import("magic-string").SourceMap;
+        map: any;
     } | undefined;
 };

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

@@ -9,6 +9,9 @@ function getMagicString(code, id) {
             return undefined;
         return {
             code: magicString.toString(),
+            // magic-string@1's SourceMap.sourcesContent is typed as (string | null)[], whereas Rollup's
+            // ExistingRawSourceMap expects string[]. We never pass `includeContent`, so sourcesContent is
+            // always undefined at runtime and this cast is safe.
             map: magicString.generateMap({ hires: true, source: id }),
         };
     };

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

@@ -0,0 +1,4 @@
+export { isVite8OrAbove };
+import type { ResolvedConfig, UserConfig } from 'vite';
+import '../assertEnvVite.js';
+declare function isVite8OrAbove(config: UserConfig | ResolvedConfig): boolean;

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

@@ -0,0 +1,9 @@
+export { isVite8OrAbove };
+import { assert } from '../../../utils/assert.js';
+import { isVersionMatch } from '../../../utils/assertVersion.js';
+import '../assertEnvVite.js';
+function isVite8OrAbove(config) {
+    const viteVersion = config._viteVersionResolved;
+    assert(viteVersion);
+    return isVersionMatch(viteVersion, ['8.0.0']);
+}

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

@@ -1,6 +1,7 @@
 export { isViteCli };
-export { getViteConfigForBuildFromCli };
-export { getViteCommandFromCli };
+export { getViteCliArgs };
+export { getViteBuildCliArgs };
+export { getViteCliCommand };
 import '../assertEnvVite.js';
 declare function isViteCli(): boolean;
 type ConfigFromCli = {
@@ -10,5 +11,9 @@ type ConfigFromCli = {
     build: Record<string, unknown>;
 };
 type ViteCommand = 'dev' | 'build' | 'optimize' | 'preview';
-declare function getViteCommandFromCli(): ViteCommand | null;
-declare function getViteConfigForBuildFromCli(): null | ConfigFromCli;
+declare function getViteCliCommand(): ViteCommand | null;
+declare function getViteBuildCliArgs(): null | ConfigFromCli;
+declare function getViteCliArgs(): null | {
+    root: string | undefined;
+    configFile: string | undefined;
+};

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

@@ -1,6 +1,7 @@
 export { isViteCli };
-export { getViteConfigForBuildFromCli };
-export { getViteCommandFromCli };
+export { getViteCliArgs };
+export { getViteBuildCliArgs };
+export { getViteCliCommand };
 import { assert } from '../../../utils/assert.js';
 import { isObject } from '../../../utils/isObject.js';
 import { isToolCli } from '../../../utils/isToolCli.js';
@@ -10,7 +11,7 @@ const desc = 'vike:vite-cli-simulation';
 function isViteCli() {
     return isToolCli('vite');
 }
-function getViteCommandFromCli() {
+function getViteCliCommand() {
     if (!isViteCli())
         return null;
     let command;
@@ -45,7 +46,7 @@ function getViteCommandFromCli() {
     assert(command);
     return command;
 }
-function getViteConfigForBuildFromCli() {
+function getViteBuildCliArgs() {
     if (!isViteCli())
         return null;
     // Copied & adapted from Vite
@@ -135,3 +136,22 @@ function getViteConfigForBuildFromCli() {
         return ret;
     }
 }
+function getViteCliArgs() {
+    if (!isViteCli())
+        return null;
+    const cli = cac(desc);
+    cli.option('-c, --config <file>', desc);
+    let result = null;
+    const setResult = (root, options) => {
+        assert(root === undefined || typeof root === 'string');
+        assert(isObject(options));
+        assert(options.config === undefined || typeof options.config === 'string');
+        result = { root, configFile: options.config };
+    };
+    cli.command('[root]', desc).alias('serve').alias('dev').action(setResult);
+    cli.command('build [root]', desc).action(setResult);
+    cli.command('optimize [root]', desc).action(setResult);
+    cli.command('preview [root]', desc).action(setResult);
+    cli.parse();
+    return result;
+}

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

@@ -29,7 +29,6 @@ import { getBetterError } from '../../../utils/getBetterError.js';
 import { getRequestId_withAsyncHook } from '../../../server/runtime/asyncHook.js';
 import { getRequestTag } from '../../../server/runtime/renderPageServer.js';
 import '../assertEnvVite.js';
-import { isDeno } from '../../../utils/isDeno.js';
 assertIsNotProductionRuntime();
 setLogRuntimeDev(logErrorServerDev, logRuntimeInfoDev);
 setAssertOnBeforeErr((err) => {
@@ -139,14 +138,16 @@ function logDev(msg, logType, tagSource, tagTool, doNotAddTags) {
 }
 function getTagSource(requestId = null) {
     const requestIdFromStore = getRequestId_withAsyncHook();
-    if (requestIdFromStore !== null &&
-        // Workaround for Deno bug: https://github.com/vikejs/vike/issues/3240
-        !isDeno()) {
+    if (requestIdFromStore !== null) {
         if (requestId === null) {
             requestId = requestIdFromStore;
         }
         else {
-            assert(requestId === requestIdFromStore);
+            /* Surprisingly, this assert can fail:
+             *  - https://github.com/vikejs/vike/issues/3240
+             *  - https://github.com/vikejs/vike/issues/3289
+            assert(requestId === requestIdFromStore)
+            */
         }
     }
     if (requestId === null)