@softarc/native-federation 4.3.2 → 4.4.1

package/dist/lib/domain/config/federation-config.contract.d.ts

@@ -1,16 +1,40 @@
 import type { PreparedSkipList, SkipList } from './skip-list.contract.js';
 import type { PathToImport } from '../utils/mapped-path.contract.js';
-import type { NormalizedSharedExternalsConfig, SharedExternalsConfig } from './external-config.contract.js';
+import type { ExternalConfig, NormalizedSharedExternalsConfig, SharedExternalsConfig } from './external-config.contract.js';
 export type ExposeEntry = {
     file: string;
     element?: string;
 };
+export type SharedMappingEntry = string | [string[], ExternalConfig];
+/** Selection pattern -> config, kept in declaration order: first match wins. */
+export type SharedMappingConfigs = Record<string, ExternalConfig>;
+/**
+ * Only the subset of `ExternalConfig` a mapping can act on — mappings all share the
+ * single `mapping-or-exposed` bundle, so `build`/`platform`/`chunks`/`packageInfo`
+ * have nothing to select. `requiredVersion` and `version` stay optional because their
+ * defaults are read from the mapped lib's package.json at build time.
+ *
+ * `includeSecondaries` collapses to a boolean exactly as it does for a shared external:
+ * it means "exempt from `ignoreUnusedDeps` pruning". `resolveGlob` is lifted out of it
+ * because a mapping has no secondary entry points for it to apply to.
+ */
+export interface NormalizedMappingConfig {
+    singleton: boolean;
+    strictVersion: boolean;
+    requiredVersion?: string;
+    version?: string;
+    shareScope?: string;
+    pool?: string;
+    includeSecondaries?: boolean;
+    resolveGlob?: boolean;
+}
+export type NormalizedSharedMappingConfigs = Record<string, NormalizedMappingConfig>;
 export interface FederationConfig {
     name?: string;
     exposes?: Record<string, string | ExposeEntry>;
     shared?: SharedExternalsConfig;
     platform?: 'browser' | 'node';
-    sharedMappings?: Array<string>;
+    sharedMappings?: Array<SharedMappingEntry>;
     chunks?: boolean;
     skip?: SkipList;
     externals?: string[];
@@ -30,6 +54,7 @@ export interface NormalizedFederationConfig {
     exposes: Record<string, ExposeEntry>;
     shared: NormalizedSharedExternalsConfig;
     sharedMappings: PathToImport;
+    sharedMappingsConfig: NormalizedSharedMappingConfigs;
     skip: PreparedSkipList;
     chunks: boolean;
     externals: string[];

package/dist/lib/domain/utils/file-watcher.contract.d.ts

@@ -2,6 +2,18 @@ export interface NfFileWatcherOptions {
     onChange?: (path: string) => void;
     pollIntervalMs?: number;
     debounceMs?: number;
+    /** Drop events whose mtime is unchanged since the last one seen for that path.
+     *  macOS FSEvents re-delivers 'changed' for recently edited files roughly every
+     *  30s; with a watch list of a few thousand sources that replay alone keeps a
+     *  rebuild loop awake forever. Default: true. */
+    dedupeReplays?: boolean;
+    /** Grace period after a path's recorded mtime during which an event whose mtime
+     *  and byte length both match still passes, covering a second save inside one
+     *  mtime tick. The 2000 default is twice the coarsest mtime granularity in play
+     *  (1s on gRPC-FUSE/NFS/WSL2 drvfs/HFS+); raise it for a filesystem coarser than
+     *  that, or for a network mount whose server clock runs behind the client.
+     *  See AGENTS.md "Replay dedupe". Default: 2000. */
+    replayGraceMs?: number;
 }
 interface AddPathsOptions {
     poll?: boolean;

package/dist/lib/domain/utils/io-port.contract.d.ts

@@ -5,6 +5,8 @@ export interface Digest {
 }
 export interface StatInfo {
     mtimeMs: number;
+    /** Byte length; 0 for directories. */
+    size: number;
     isSymbolicLink: boolean;
 }
 export interface FileReaderPort {
@@ -29,6 +31,7 @@ export interface FileWriterPort {
 export interface GlobPort {
     globFiles(pattern: string, opts: {
         cwd: string;
+        ignore?: string[];
     }): string[];
 }
 export interface HashPort {
@@ -45,9 +48,9 @@ interface WatchOptions {
 }
 export interface WatchPort {
     /**
-     * For a recursive directory watch `onEvent` receives the changed entry's
-     * filename relative to `path`; for a file it receives the path itself (or
-     * null when the platform omits it).
+     * `onEvent` receives the changed entry's filename relative to `path` (null when
+     * the platform omits it). Watching a file reports that file's own basename, so a
+     * caller that registered a file can ignore the argument.
      */
     watch(path: string, opts: WatchOptions, onEvent: (filename: string | null) => void): WatchHandle;
 }

package/dist/lib/utils/file-watcher.d.ts

@@ -1,7 +1,18 @@
 import type { WatchPort, FileReaderPort } from '../domain/utils/io-port.contract.js';
 import type { NfFileWatcher, NfFileWatcherOptions } from '../domain/utils/file-watcher.contract.js';
 export declare function createNfWatcher(options?: NfFileWatcherOptions): NfFileWatcher;
-export declare function createNfWatcherCore(io: WatchPort & FileReaderPort, options?: NfFileWatcherOptions): NfFileWatcher;
-export declare function syncNfFileWatcher(watcher: NfFileWatcher, bundlerCache: {
-    keys(): IterableIterator<string>;
-}, linkedDirs?: readonly string[]): void;
+export declare function createNfWatcherCore(io: WatchPort & FileReaderPort, options?: NfFileWatcherOptions, now?: () => number): NfFileWatcher;
+/** A bundler cache keyed by input path, or the input paths themselves. */
+export type WatchSources = Iterable<string> | {
+    keys(): Iterable<string>;
+};
+/**
+ * Subscribe the watcher to the inputs the last build compiled.
+ *
+ * Passing a bundler cache only works when it is keyed by input path. A cache that
+ * records its inputs elsewhere yields an empty watch set and, silently, a dev server
+ * that serves stale bundles until restart — Angular's `SourceFileCache` extends `Map`
+ * but keeps its inputs in `typeScriptFileCache`/`referencedFiles`, which is
+ * angular-adapter#94. Adapters over such a cache must expand it and pass the paths.
+ */
+export declare function syncNfFileWatcher(watcher: NfFileWatcher, sources: WatchSources, linkedDirs?: readonly string[]): void;

package/dist/lib/utils/file-watcher.js

@@ -1,29 +1,82 @@
-import { join } from "path";
+import { dirname, join } from "path";
 import { nodeIo } from "./io/node-io-adapter.js";
 import { logger } from "./logger.js";
-import { toPosix } from "./path-patterns.js";
+import { isUnderDir, toPosix } from "./path-patterns.js";
 function createNfWatcher(options = {}) {
   return createNfWatcherCore(nodeIo, options);
 }
-function createNfWatcherCore(io, options = {}) {
+function createNfWatcherCore(io, options = {}, now = Date.now) {
   const { onChange } = options;
   const pollIntervalMs = options.pollIntervalMs ?? 300;
   const debounceMs = options.debounceMs ?? 0;
+  const dedupeReplays = options.dedupeReplays ?? true;
+  const replayGraceMs = options.replayGraceMs ?? 2e3;
   const watchers = /* @__PURE__ */ new Map();
   const dirtyPaths = /* @__PURE__ */ new Set();
-  const deliver = (path) => {
+  const lastSeen = /* @__PURE__ */ new Map();
+  const trackedFiles = /* @__PURE__ */ new Set();
+  const fileDirWatchers = /* @__PURE__ */ new Map();
+  const dirKey = (p) => {
+    const posix = toPosix(p);
+    return posix.length > 1 ? posix.replace(/\/+$/, "") : posix;
+  };
+  const covers = (path, poll) => {
+    for (const [dir, watch] of watchers) {
+      if ((watch.poll || !poll) && isUnderDir(path, dir)) return true;
+    }
+    return false;
+  };
+  const supersede = (dir, poll) => {
+    for (const map of [watchers, fileDirWatchers]) {
+      for (const [key, watch] of map) {
+        if (watch.poll && !poll) continue;
+        if (map === watchers && key === dir) continue;
+        if (!isUnderDir(key, dir)) continue;
+        watch.handle.close();
+        map.delete(key);
+      }
+    }
+  };
+  const identityOf = (path) => {
+    let stat = io.stat(path);
+    if (stat?.isSymbolicLink) stat = io.stat(io.realpath(path));
+    return stat ? { mtimeMs: stat.mtimeMs, size: stat.size } : null;
+  };
+  const isReplay = (path, at) => {
+    const current = identityOf(path);
+    if (!current) {
+      lastSeen.delete(path);
+      return false;
+    }
+    const previous = lastSeen.get(path);
+    lastSeen.set(path, current);
+    if (!previous || previous.mtimeMs !== current.mtimeMs || previous.size !== current.size) {
+      return false;
+    }
+    return at - current.mtimeMs >= replayGraceMs;
+  };
+  let watchFailures = 0;
+  const watchFailed = (path) => {
+    if (++watchFailures > 1) return logger.debug(`Could not watch path '${path}'.`);
+    logger.warn(
+      `Could not watch '${path}'. Changes there will not trigger a rebuild; run with verbose logging to see any further watch failures.`
+    );
+  };
+  const deliver = (path, at) => {
+    if (dedupeReplays && isReplay(path, at)) return;
+    dirtyPaths.add(path);
     if (onChange) onChange(path);
-    else dirtyPaths.add(path);
   };
-  const pending = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
   let flushTimer;
   const flush = () => {
-    for (const p of pending) deliver(p);
+    for (const [p, at] of pending) deliver(p, at);
     pending.clear();
   };
   const notify = (path) => {
-    if (debounceMs <= 0) return deliver(path);
-    pending.add(path);
+    const at = now();
+    if (debounceMs <= 0) return deliver(path, at);
+    if (!pending.has(path)) pending.set(path, at);
     if (flushTimer) clearTimeout(flushTimer);
     flushTimer = setTimeout(flush, debounceMs);
     flushTimer.unref?.();
@@ -31,16 +84,47 @@ function createNfWatcherCore(io, options = {}) {
   return {
     addPaths(paths, opts) {
       const list = typeof paths === "string" ? [paths] : [...paths];
-      const poll = opts?.poll ? { intervalMs: pollIntervalMs } : void 0;
+      const shouldPoll = !!opts?.poll;
+      const poll = shouldPoll ? { intervalMs: pollIntervalMs } : void 0;
       for (const p of list) {
-        if (watchers.has(p)) continue;
+        if (io.isDirectory(p)) {
+          const dir2 = dirKey(p);
+          if (watchers.has(dir2) || covers(dir2, shouldPoll)) continue;
+          try {
+            watchers.set(dir2, {
+              handle: io.watch(p, { recursive: true, poll }, (filename) => {
+                if (filename) notify(toPosix(join(p, filename)));
+              }),
+              poll: shouldPoll
+            });
+          } catch {
+            watchFailed(p);
+            continue;
+          }
+          supersede(dir2, shouldPoll);
+          continue;
+        }
+        const key = toPosix(p);
+        if (trackedFiles.has(key)) continue;
+        trackedFiles.add(key);
+        if (dedupeReplays && !lastSeen.has(key)) {
+          const identity = identityOf(key);
+          if (identity) lastSeen.set(key, identity);
+        }
+        if (covers(key, shouldPoll)) continue;
+        const dir = dirKey(dirname(p));
+        if (fileDirWatchers.has(dir)) continue;
         try {
-          const handle = io.isDirectory(p) ? io.watch(p, { recursive: true, poll }, (filename) => {
-            if (filename) notify(toPosix(join(p, filename)));
-          }) : io.watch(p, { recursive: false, poll }, () => notify(toPosix(p)));
-          watchers.set(p, handle);
+          fileDirWatchers.set(dir, {
+            handle: io.watch(dir, { recursive: false, poll }, (filename) => {
+              if (!filename) return;
+              const changed = toPosix(join(dir, filename));
+              if (trackedFiles.has(changed)) notify(changed);
+            }),
+            poll: shouldPoll
+          });
         } catch {
-          logger.debug(`Could not watch path '${p}'.`);
+          watchFailed(dir);
         }
       }
     },
@@ -49,15 +133,24 @@ function createNfWatcherCore(io, options = {}) {
     mutate: (fn) => fn(dirtyPaths),
     async close() {
       if (flushTimer) clearTimeout(flushTimer);
-      for (const handle of watchers.values()) {
+      for (const { handle } of [...watchers.values(), ...fileDirWatchers.values()]) {
         handle.close();
       }
       watchers.clear();
+      fileDirWatchers.clear();
+      trackedFiles.clear();
+      lastSeen.clear();
+      watchFailures = 0;
     }
   };
 }
-function syncNfFileWatcher(watcher, bundlerCache, linkedDirs = []) {
-  const files = [...bundlerCache.keys()].filter((k) => !k.includes("node_modules"));
+function toPaths(sources) {
+  if (Array.isArray(sources)) return sources;
+  const cache = sources;
+  return typeof cache.keys === "function" ? cache.keys() : sources;
+}
+function syncNfFileWatcher(watcher, sources, linkedDirs = []) {
+  const files = [...toPaths(sources)].filter((k) => !k.includes("node_modules"));
   if (files.length) watcher.addPaths(files);
   if (linkedDirs.length) watcher.addPaths(linkedDirs, { poll: true });
 }

package/dist/lib/utils/io/node-io-adapter.js

@@ -43,7 +43,7 @@ const nodeIo = {
   stat(path2) {
     try {
       const s = fs.lstatSync(path2);
-      return { mtimeMs: s.mtimeMs, isSymbolicLink: s.isSymbolicLink() };
+      return { mtimeMs: s.mtimeMs, size: s.size, isSymbolicLink: s.isSymbolicLink() };
     } catch {
       return null;
     }
@@ -61,7 +61,12 @@ const nodeIo = {
     fs.unlinkSync(path2);
   },
   globFiles(pattern, opts) {
-    return fg.sync(pattern, { cwd: opts.cwd, onlyFiles: true, deep: Infinity });
+    return fg.sync(pattern, {
+      cwd: opts.cwd,
+      ignore: opts.ignore,
+      onlyFiles: true,
+      deep: Infinity
+    });
   },
   hash(algorithm, data) {
     const sum = crypto.createHash(algorithm).update(data);
@@ -72,11 +77,11 @@ const nodeIo = {
   },
   watch(watchPath, opts, onEvent) {
     if (opts.poll) return pollWatch(watchPath, opts.recursive, opts.poll.intervalMs, onEvent);
-    const watcher = opts.recursive ? fs.watch(
+    const watcher = fs.watch(
       watchPath,
-      { recursive: true },
+      { recursive: opts.recursive },
       (_event, filename) => onEvent(filename ? filename.toString() : null)
-    ) : fs.watch(watchPath, () => onEvent(watchPath));
+    );
     return { close: () => watcher.close() };
   }
 };

package/dist/lib/utils/package/entry-point-resolver.js

@@ -44,7 +44,7 @@ function resolvePackageInfo(repo, packageName, directory) {
   const version = mainPkgJson["version"];
   const esm = mainPkgJson["type"] === "module";
   if (!version) {
-    logger.warn("No version found for " + packageName);
+    logger.debug("No version found for " + packageName + " in " + directory);
     return null;
   }
   const pathToSecondary = path.relative(mainPkgName, packageName);
@@ -67,10 +67,7 @@ function resolvePackageInfo(repo, packageName, directory) {
     const result = strategy(ctx);
     if (result) return result;
   }
-  logger.warn("No entry point found for " + packageName);
-  logger.warn(
-    "If you don't need this package, skip it in your federation.config.js or consider moving it into depDependencies in your package.json"
-  );
+  logger.debug("No entry point found for " + packageName + " in " + directory);
   return null;
 }
 export {

package/dist/lib/utils/package/package-info.d.ts

@@ -2,6 +2,19 @@ import type { PackageInfo, PackageJsonRepository, VersionMap } from '../../domai
 export { sharedPackageJsonRepository } from '../io/package-json-repository.js';
 export type { PackageInfo, VersionMap, ExportCondition, ExportEntry, } from '../../domain/utils/package-json.contract.js';
 export { isESMExport } from './esm-detection.js';
+export declare function tryGetPackageInfo(packageName: string, workspaceRoot: string, repo?: PackageJsonRepository): PackageInfo | null;
+/**
+ * Resolve a package that is expected to be resolvable, warning once if it is not.
+ * Only use this where a failure is genuinely actionable, i.e. for packages the user
+ * asked to share.
+ */
 export declare function getPackageInfo(packageName: string, workspaceRoot: string, repo?: PackageJsonRepository): PackageInfo | null;
+/**
+ * Installed version per key, from each key's package root. Resolution is deduped by root:
+ * `findDepPackageJson` trims to the root anyway, and that root package.json is also where
+ * `resolvePackageInfo` reads the `version` it records as `PackageInfo.version`, so a secondary
+ * yields the same string as its main entry point. Unresolvable keys map to ''.
+ */
+export declare function installedVersions(packageNames: string[], workspaceRoot: string, repo?: PackageJsonRepository): Record<string, string>;
 export declare function getVersionMaps(project: string, workspace: string, repo?: PackageJsonRepository): VersionMap[];
 export declare function findDepPackageJson(packageName: string, projectRoot: string, repo?: PackageJsonRepository): string | null;

package/dist/lib/utils/package/package-info.js

@@ -1,11 +1,11 @@
 import { logger } from "../logger.js";
 import { normalize } from "../normalize.js";
-import { sharedPackageJsonRepository } from "../io/package-json-repository.js";
+import { getPkgFolder, sharedPackageJsonRepository } from "../io/package-json-repository.js";
 import { resolvePackageInfo } from "./entry-point-resolver.js";
 import { getVersionMaps as getVersionMapsFromRepo } from "./version-maps.js";
 import { sharedPackageJsonRepository as sharedPackageJsonRepository2 } from "../io/package-json-repository.js";
 import { isESMExport } from "./esm-detection.js";
-function getPackageInfo(packageName, workspaceRoot, repo = sharedPackageJsonRepository) {
+function tryGetPackageInfo(packageName, workspaceRoot, repo = sharedPackageJsonRepository) {
   workspaceRoot = normalize(workspaceRoot, true);
   for (const info of repo.getPackageJsonFiles(workspaceRoot, workspaceRoot)) {
     const cand = resolvePackageInfo(repo, packageName, info.directory);
@@ -13,9 +13,33 @@ function getPackageInfo(packageName, workspaceRoot, repo = sharedPackageJsonRepo
       return cand;
     }
   }
-  logger.warn("No meta data found for shared lib " + packageName);
   return null;
 }
+function getPackageInfo(packageName, workspaceRoot, repo = sharedPackageJsonRepository) {
+  const info = tryGetPackageInfo(packageName, workspaceRoot, repo);
+  if (!info) {
+    logger.warn("No meta data found for shared lib " + packageName);
+    logger.warn(
+      "If you don't need this package, skip it in your federation.config.js or consider moving it into depDependencies in your package.json"
+    );
+  }
+  return info;
+}
+function installedVersions(packageNames, workspaceRoot, repo = sharedPackageJsonRepository) {
+  workspaceRoot = normalize(workspaceRoot, true);
+  const byRoot = /* @__PURE__ */ new Map();
+  const result = {};
+  for (const packageName of packageNames) {
+    const root = getPkgFolder(packageName);
+    if (!byRoot.has(root)) {
+      const pkgJsonPath = repo.findDepPackageJson(root, workspaceRoot);
+      const version = pkgJsonPath ? repo.readJson(pkgJsonPath)["version"] : "";
+      byRoot.set(root, version ?? "");
+    }
+    result[packageName] = byRoot.get(root);
+  }
+  return result;
+}
 function getVersionMaps(project, workspace, repo = sharedPackageJsonRepository) {
   return getVersionMapsFromRepo(repo, project, workspace);
 }
@@ -26,6 +50,8 @@ export {
   findDepPackageJson,
   getPackageInfo,
   getVersionMaps,
+  installedVersions,
   isESMExport,
-  sharedPackageJsonRepository2 as sharedPackageJsonRepository
+  sharedPackageJsonRepository2 as sharedPackageJsonRepository,
+  tryGetPackageInfo
 };

package/dist/lib/utils/package/resolve-wildcard-keys.js

@@ -1,10 +1,16 @@
-import { captureWildcard, parseWildcard, substituteWildcard, toPosix } from "../path-patterns.js";
+import {
+  captureWildcard,
+  parseWildcard,
+  substituteWildcard,
+  toGlobPattern,
+  toPosix
+} from "../path-patterns.js";
 function resolvePackageJsonExportsWildcardCore(io, keyPattern, valuePattern, cwd) {
   const pattern = parseWildcard(valuePattern.replace(/^\.?\/+/, ""));
   if (!pattern.hasWildcard) {
     return [];
   }
-  const files = io.globFiles(pattern.prefix + "**/*" + pattern.suffix, { cwd });
+  const files = io.globFiles(toGlobPattern(pattern), { cwd, ignore: ["**/node_modules/**"] });
   const keys = [];
   for (const file of files) {
     const relPath = toPosix(file).replace(/^\.\//, "");

package/dist/lib/utils/path-patterns.d.ts

@@ -1,4 +1,11 @@
 export declare const toPosix: (p: string) => string;
+/**
+ * True when `file` is `dir` itself or lives under it. Both sides are normalized, so a
+ * caller cannot splice in `path.sep` and get a predicate that is silently always-false
+ * on Windows -- `linkedSharedDirs` and the file watcher both emit posix paths.
+ */
+export declare function isUnderDir(file: string, dir: string): boolean;
+export declare const isUnderAnyDir: (file: string, dirs: readonly string[]) => boolean;
 export interface WildcardPattern {
     prefix: string;
     suffix: string;
@@ -12,3 +19,10 @@ export declare function matchesWildcard(value: string, pattern: string): boolean
  */
 export declare function captureWildcard(value: string, pattern: WildcardPattern): string | null;
 export declare function substituteWildcard(template: string, captured: string): string;
+/**
+ * A glob that is a superset of the pattern, for callers that re-check the match themselves
+ * (`captureWildcard`, `matchMapping`). `**` only acts as a globstar on a segment of its own,
+ * so a prefix stopping mid-segment (`libs/ui-`) has to be widened back to its directory --
+ * `libs/ui-**` reads as `libs/ui-*` and silently matches nothing one level down.
+ */
+export declare function toGlobPattern({ prefix, suffix }: WildcardPattern): string;

package/dist/lib/utils/path-patterns.js

@@ -1,4 +1,10 @@
 const toPosix = (p) => p.replace(/\\/g, "/");
+function isUnderDir(file, dir) {
+  const f = toPosix(file);
+  const d = toPosix(dir).replace(/\/+$/, "");
+  return f === d || f.startsWith(d + "/");
+}
+const isUnderAnyDir = (file, dirs) => dirs.some((d) => isUnderDir(file, d));
 function parseWildcard(pattern) {
   const i = pattern.indexOf("*");
   if (i === -1) return { prefix: pattern, suffix: "", hasWildcard: false };
@@ -19,10 +25,16 @@ function captureWildcard(value, pattern) {
 function substituteWildcard(template, captured) {
   return template.replace("*", captured);
 }
+function toGlobPattern({ prefix, suffix }) {
+  return prefix.slice(0, prefix.lastIndexOf("/") + 1) + "**/*" + suffix;
+}
 export {
   captureWildcard,
+  isUnderAnyDir,
+  isUnderDir,
   matchesWildcard,
   parseWildcard,
   substituteWildcard,
+  toGlobPattern,
   toPosix
 };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@softarc/native-federation",
-  "version": "4.3.2",
+  "version": "4.4.1",
   "type": "module",
   "license": "MIT",
-  "packageManager": "pnpm@11.11.0",
+  "packageManager": "pnpm@11.18.0",
   "scripts": {
     "build": "node esbuild.config.mjs && tsc -p tsconfig.build.json",
     "lint": "eslint src",
@@ -13,7 +13,7 @@
   },
   "dependencies": {
     "@softarc/sheriff-core": "^0.19.6",
-    "chalk": "^5.6.2",
+    "chalk": "^6.0.0",
     "esbuild": "^0.28.0",
     "fast-glob": "^3.3.3",
     "json5": "^2.2.3"
@@ -27,12 +27,12 @@
     "globals": "^17.3.0",
     "jiti": "^2.6.1",
     "jsdom": "^29.0.0",
-    "knip": "^6.20.0",
+    "knip": "^6.26.0",
     "prettier": "^3.9.4",
     "tslib": "^2.3.0",
     "typescript": "~6.0.0",
     "typescript-eslint": "^8.61.0",
-    "vite": "^8.1.3",
+    "vite": "^8.2.0",
     "vitest": "^4.0.0"
   },
   "exports": {