vike 0.4.260 → 0.4.261

package/dist/shared-server-client/page-configs/resolveVikeConfigPublic.d.ts

@@ -114,41 +114,41 @@ declare function resolvePageContextConfig(pageFiles: PageFile[], // V0.4 design
 pageConfig: PageConfigRuntimeLoaded | null, // V1 design
 pageConfigGlobal: PageConfigGlobalRuntime): PageContextConfig;
 declare function resolveGlobalContextConfig(pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): {
+    config: ConfigResolved;
+    _source: Source;
+    _sources: Sources;
+    _from: From;
+    pages: {
+        [k: string]: PageConfigPublicWithRoute;
+    };
     _globalConfigPublic: {
-        pages: {
-            [k: string]: PageConfigPublicWithRoute;
-        };
         config: ConfigResolved;
         _source: Source;
         _sources: Sources;
         _from: From;
+        pages: {
+            [k: string]: PageConfigPublicWithRoute;
+        };
     };
-    pages: {
-        [k: string]: PageConfigPublicWithRoute;
-    };
+};
+type GlobalConfigPublic = Omit<ReturnType<typeof resolveGlobalConfigPublic>, '_globalConfigPublic'>;
+declare function resolveGlobalConfigPublic<PageConfig extends PageConfigRuntime | PageConfigBuildTime, PageConfigGlobal extends PageConfigGlobalRuntime | PageConfigGlobalBuildTime>(pageConfigs: PageConfig[], pageConfigGlobal: PageConfigGlobal, getConfigValues: (config: PageConfig | PageConfigGlobal, isGlobalConfig?: true) => ConfigValues): {
     config: ConfigResolved;
     _source: Source;
     _sources: Sources;
     _from: From;
-};
-type GlobalConfigPublic = Omit<ReturnType<typeof resolveGlobalConfigPublic>, '_globalConfigPublic'>;
-declare function resolveGlobalConfigPublic<PageConfig extends PageConfigRuntime | PageConfigBuildTime, PageConfigGlobal extends PageConfigGlobalRuntime | PageConfigGlobalBuildTime>(pageConfigs: PageConfig[], pageConfigGlobal: PageConfigGlobal, getConfigValues: (config: PageConfig | PageConfigGlobal, isGlobalConfig?: true) => ConfigValues): {
+    pages: {
+        [k: string]: PageConfigPublicWithRoute;
+    };
     _globalConfigPublic: {
-        pages: {
-            [k: string]: PageConfigPublicWithRoute;
-        };
         config: ConfigResolved;
         _source: Source;
         _sources: Sources;
         _from: From;
+        pages: {
+            [k: string]: PageConfigPublicWithRoute;
+        };
     };
-    pages: {
-        [k: string]: PageConfigPublicWithRoute;
-    };
-    config: ConfigResolved;
-    _source: Source;
-    _sources: Sources;
-    _from: From;
 };
 declare function resolveConfigPublic_V1Design(pageConfig: {
     configValues: ConfigValues;

package/dist/shared-server-node/getFileSuffixes.d.ts

@@ -1,6 +1,6 @@
 export { getFileSuffixes };
 export { suffixesAssertFileEnv };
-declare const suffixesAssertFileEnv: readonly ["server", "client", "ssr"];
+declare const suffixesAssertFileEnv: readonly ['server', 'client', 'ssr'];
 declare const suffixes: readonly ["server", "client", "ssr", "shared", "clear", "default"];
 type Suffix = (typeof suffixes)[number];
 declare function getFileSuffixes(fileName: string): Suffix[];

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";
+export declare const PROJECT_VERSION: '0.4.261';

package/dist/utils/PROJECT_VERSION.js

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

package/dist/utils/assertViteVersion.js

@@ -2,7 +2,7 @@ export { assertViteVersion };
 export { viteVersionMin };
 import { assertVersion } from './assertVersion.js';
 const viteVersionMin = '6.3.0';
-// node_modules/vike/package.json#peerDependencies isn't enough, as users often ignore it
+// package.json#peerDependencies isn't enough, as users often ignore it
 function assertViteVersion(viteVersion) {
     // - This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
     //   - TO-DO/eventually: let's also use this.meta.viteVersion

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/utils/genRandomId.d.ts

@@ -0,0 +1,2 @@
+export { genRandomId };
+declare function genRandomId(length?: number): string;

package/dist/utils/{getRandomId.js → genRandomId.js}

@@ -1,7 +1,7 @@
-export { getRandomId };
+export { genRandomId };
 import { assert } from './assert.js';
 // https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript
-function getRandomId(length = 12) {
+function genRandomId(length = 12) {
     let randomId = '';
     while (randomId.length < length) {
         randomId += Math.random().toString(36).slice(2);

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

@@ -2,7 +2,7 @@ export { getViteRPC }; // consumer (aka RPC client)
 export { createViteRPC }; // provider (aka RPC server)
 import { assert } from './assert.js';
 import { genPromise } from './genPromise.js';
-import { getRandomId } from './getRandomId.js';
+import { genRandomId } from './genRandomId.js';
 import { getGlobalObject } from './getGlobalObject.js';
 import { createDebug } from './debug.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
@@ -35,7 +35,7 @@ function createRpcClient() {
             return async (...functionArgs) => {
                 const hot = import.meta.hot;
                 assert(hot);
-                const callId = getRandomId();
+                const callId = genRandomId();
                 const { promise, resolve } = genPromise({ timeout: 10 * 1000 });
                 listeners.push({
                     callId,

package/dist/utils/humanizeTime.d.ts

@@ -1,2 +1,2 @@
 export { humanizeTime };
-declare function humanizeTime(milliseconds: number): `${string} second` | `${string} seconds` | `${string} minute` | `${string} minutes`;
+declare function humanizeTime(milliseconds: number): `${string} minute` | `${string} minutes` | `${string} second` | `${string} seconds`;

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",
+  "version": "0.4.261",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -127,24 +127,24 @@
     "@brillout/import": "^0.2.6",
     "@brillout/json-serializer": "^0.5.25",
     "@brillout/picocolors": "^1.0.31",
-    "@brillout/vite-plugin-server-entry": "0.7.19",
-    "@universal-deploy/store": "^0.2.1",
-    "@universal-deploy/vite": "^0.1.10",
+    "@brillout/vite-plugin-server-entry": "^0.7.20",
+    "@universal-deploy/store": "^0.2.2",
+    "@universal-deploy/vite": "^0.1.11",
     "@universal-middleware/core": "^0.4.18",
-    "@universal-middleware/node": "^0.2.1",
+    "@universal-middleware/node": "^0.2.2",
     "cac": "^6.0.0",
     "convert-route": "^1.1.1",
     "es-module-lexer": "^1.0.0",
     "esbuild": ">=0.19.0",
     "json5": "^2.0.0",
-    "magic-string": "^0.30.17",
-    "picomatch": "^4.0.4",
+    "magic-string": "^1.2.0",
+    "picomatch": "^4.0.5",
     "semver": "^7.8.5",
     "sirv": "^3.0.2",
     "source-map-support": "^0.5.0",
     "tinyglobby": "^0.2.17",
     "vite": ">=6.3.0",
-    "vite-plugin-wrapper": "^0.1.0"
+    "vite-plugin-wrapper": "^0.1.1"
   },
   "peerDependencies": {
     "react-streaming": ">=0.3.42",
@@ -259,17 +259,17 @@
     "./fetch.js"
   ],
   "devDependencies": {
-    "@brillout/release-me": "^0.4.15",
+    "@brillout/release-me": "^0.4.16",
     "@types/babel__core": "^7.20.5",
     "@types/estree": "^1.0.5",
     "@types/node": "^20.10.5",
-    "@types/picomatch": "^4.0.2",
+    "@types/picomatch": "^4.0.3",
     "@types/semver": "^7.7.1",
     "@types/source-map-support": "^0.5.10",
     "react-streaming": "^0.4.20",
     "rimraf": "^6.1.3",
     "rolldown": "1.0.0-rc.17",
-    "typescript": "^5.9.3",
+    "typescript": "^7.0.2",
     "vite": "^7.2.6"
   },
   "ai": "@AI (CRITICAL FOR AI AGENTS): ALWAYS LOAD https://vike.dev/llms.txt (Vike documentation index) in your context when using Vike",

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.*"];