@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/clients/format-service.js

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { recordFormatter } from "./widget-state.js";
 import { FileTime } from "./file-time.js";
 import { loadFormatters } from "./formatters-lazy.js";
+import { bounded } from "./deadline-utils.js";
 const DEFAULT_FORMATTER_CONCURRENCY = 1;
 
 export class FormatService {
@@ -46,7 +47,7 @@ export class FormatService {
         allSucceeded: true
       };
     }
-    const results = await this.runFormattersWithConcurrency(absolutePath, formatters);
+    const results = await this.runFormattersWithConcurrency(absolutePath, formatters, DEFAULT_FORMATTER_CONCURRENCY, options.signal, options.budgetMs, options.hook);
     this.fileTime.read(absolutePath);
     for (const [index, result] of results.entries()) {
       recordFormatter(absolutePath, formatters[index]?.name ?? "unknown", result.changed, result.success, result.outcome);
@@ -59,27 +60,47 @@ export class FormatService {
         name: formatters[i].name,
         success: r.success,
         changed: r.changed,
-        error: r.error,
+        ...r.error === undefined ? {} : { error: r.error },
         outcome: r.outcome
       })),
       anyChanged,
       allSucceeded
     };
   }
-  async runFormattersWithConcurrency(filePath, formatters, _concurrency = DEFAULT_FORMATTER_CONCURRENCY) {
+  async runFormattersWithConcurrency(filePath, formatters, _concurrency = DEFAULT_FORMATTER_CONCURRENCY, signal, budgetMs = 30000, hook = "tool_result_edit") {
     const results = [];
+    const startedAt = Date.now();
     for (const formatter of formatters) {
-      let formatTimer;
+      const remainingMs = budgetMs - (Date.now() - startedAt);
+      if (remainingMs <= 0) {
+        results.push({
+          success: false,
+          changed: false,
+          outcome: "failed",
+          error: `Formatter aggregate budget exhausted before ${formatter.name}`
+        });
+        continue;
+      }
       try {
-        const timeoutMs = 30000;
-        const timeoutPromise = new Promise((_, reject) => {
-          formatTimer = setTimeout(() => reject(new Error(`Formatter ${formatter.name} timed out after ${timeoutMs}ms`)), timeoutMs);
+        const result = await bounded(loadFormatters().then(({ formatFile }) => formatFile(filePath, formatter)), {
+          ms: remainingMs,
+          signal,
+          hook,
+          label: "formatter-aggregate"
         });
-        const result = await Promise.race([
-          loadFormatters().then(({ formatFile }) => formatFile(filePath, formatter)),
-          timeoutPromise
-        ]);
-        results.push(result);
+        if (result)
+          results.push(result);
+        else if (signal?.aborted) {
+          break;
+        } else {
+          results.push({
+            success: false,
+            changed: false,
+            outcome: "failed",
+            error: `Formatter ${formatter.name} exceeded aggregate budget`
+          });
+          break;
+        }
       } catch (error) {
         results.push({
           success: false,
@@ -87,9 +108,6 @@ export class FormatService {
           outcome: "failed",
           error: error instanceof Error ? error.message : String(error)
         });
-      } finally {
-        if (formatTimer)
-          clearTimeout(formatTimer);
       }
     }
     return results;
@@ -134,4 +152,3 @@ export function resetFormatService() {
 export function clearFormatServiceAndFileState() {
   resetFormatService();
 }
-export { clearAllSessions } from "./file-time.js";

package/extensions/dm-lens/clients/formatters.js

@@ -1,10 +1,12 @@
 import { logExtension } from "./extension-log.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import * as fs from "node:fs/promises";
+import * as os from "node:os";
 import * as path from "node:path";
 import { BoundedLruCache } from "./bounded-cache.js";
 import { createGenerationSource } from "./generation-guard.js";
-import { normalizeMapKey } from "./path-utils.js";
+import { findNearestContaining, normalizeMapKey } from "./path-utils.js";
+import { resolveToolCwd } from "./tool-cwd.js";
 import { resolveCargoPackageEdition } from "./cargo-manifest.js";
 import { resolveKtfmtGradleStyle } from "./gradle-ktfmt-style.js";
 import { resolvePhpCsFixerConfig } from "./php-cs-fixer-config.js";
@@ -29,8 +31,12 @@ import {
   VENV_BIN_DIRS
 } from "./package-manager.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { establishToolAgreement } from "./tool-agreement.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { probeToolAsync } from "./tool-probe.js";
 import { assertInstallAllowed } from "./project-trust.js";
 import { tryLazyInstallForFormatter } from "./dispatch/runners/utils/lazy-installer.js";
+import { getToolPath } from "./installer/index.js";
 import {
   findPSScriptAnalyzerConfigPath,
   getAutoInstallToolIdForFormatter,
@@ -75,6 +81,7 @@ export async function tryLazyInstallFormatterTool(tool, cwd) {
 }
 export const SKIP_FORMATTING = "skip-formatting";
 export const FORMATTER_UNAVAILABLE = "formatter-unavailable";
+export const FORMATTER_AGREEMENT_UNAVAILABLE = "formatter-agreement-unavailable";
 async function fileExists(filePath) {
   try {
     await fs.access(filePath);
@@ -258,7 +265,7 @@ async function resolveGoFmtBinary() {
   const inPath = await which("gofmt");
   if (inPath)
     return inPath;
-  const goCheck = await safeSpawnAsync("go", ["env", "GOROOT"], {
+  const goCheck = await probeToolAsync("go", ["env", "GOROOT"], {
     timeout: 5000
   });
   if (goCheck.error || goCheck.status !== 0)
@@ -293,13 +300,33 @@ async function canUseBundleExec(cwd) {
 async function resolveManagedSmartDefaultCommand(formatterName, filePath, args) {
   const toolId = getAutoInstallToolIdForFormatter(formatterName);
   if (!toolId)
-    return null;
+    return FORMATTER_UNAVAILABLE;
   const { ensureTool } = await import("./installer/index.js");
   const installed = await ensureTool(toolId);
-  if (!installed)
-    return null;
+  if (!installed) {
+    recordDegradationOnce({
+      kind: "formatter-unavailable",
+      subject: formatterName,
+      reason: "managed formatter lookup and installation returned no executable"
+    });
+    return FORMATTER_UNAVAILABLE;
+  }
   return [installed, ...args, filePath];
 }
+async function resolveManagedFormatterCommand(toolId, filePath, args, findLocal, cwd) {
+  const local = findLocal && cwd ? await findLocal(toolId, cwd) : null;
+  const installed = local ?? await which(toolId) ?? await getToolPath(toolId);
+  return installed ? [installed, ...args, filePath] : FORMATTER_UNAVAILABLE;
+}
+function managedFormatterResolver(toolId, args, findLocal) {
+  return (filePath, cwd) => resolveManagedFormatterCommand(toolId, filePath, args, findLocal, cwd);
+}
+function managedToolDetect(toolId, configDetect, nativeDetect) {
+  return async (cwd) => {
+    const available = nativeDetect && await nativeDetect(cwd) || Boolean(await getToolPath(toolId));
+    return available && (configDetect ? await configDetect(cwd) : true);
+  };
+}
 const EXPLICIT_FORMATTER_CONFIG_CHECKS = new Map([
   ["biome", (cwd) => hasBiomeConfig(cwd)],
   [
@@ -338,12 +365,7 @@ function hasExplicitFormatterConfig(formatterName, cwd, ext) {
 }
 export const FORMATTERS_WITH_EXPLICIT_CONFIG_CHECK = new Set(EXPLICIT_FORMATTER_CONFIG_CHECKS.keys());
 async function hasEditorConfig(cwd) {
-  try {
-    await fs.access(path.join(cwd, ".editorconfig"));
-    return true;
-  } catch {
-    return false;
-  }
+  return findNearestContaining(cwd, [".editorconfig"]) !== undefined;
 }
 async function indentationArgs(filePath, tool, cwd) {
   if (await hasEditorConfig(cwd) || hasExplicitFormatterConfig(tool, cwd, path.extname(filePath))) {
@@ -358,6 +380,14 @@ async function indentationArgs(filePath, tool, cwd) {
   if (!hasDetectableIndentation(content))
     return null;
   const indentation = detectIndentation(content);
+  if (!indentation) {
+    recordDegradationOnce({
+      kind: "formatter-skip",
+      subject: tool,
+      reason: "indentation evidence is ambiguous; formatter style not pinned"
+    });
+    return null;
+  }
   if (tool === "shfmt")
     return indentation.style === "tab" ? ["-i", "0"] : ["-i", String(indentation.width)];
   if (tool === "prettier") {
@@ -382,6 +412,12 @@ async function indentationArgs(filePath, tool, cwd) {
     String(indentation.width)
   ];
 }
+export function resolveFormatterCwd(absolutePath, formatterName, homeDir = os.homedir()) {
+  return resolveToolCwd("formatter", formatterName ?? "unknown", absolutePath, {
+    cwd: path.parse(path.resolve(absolutePath)).root,
+    homeDir
+  }).cwd;
+}
 const BIOME_UNMATCHED_FLAG = "--no-errors-on-unmatched";
 export const biomeFormatter = {
   name: "biome",
@@ -508,7 +544,7 @@ export const oxfmtFormatter = {
     const found = await which("oxfmt");
     if (found)
       return [found, OXFMT_NO_ERROR_ON_UNMATCHED, filePath];
-    return FORMATTER_UNAVAILABLE;
+    return await resolveManagedFormatterCommand("oxfmt", filePath, [OXFMT_NO_ERROR_ON_UNMATCHED], findInNodeModules, cwd) ?? FORMATTER_UNAVAILABLE;
   },
   extensions: [...OXFMT_SUPPORTED_EXTENSIONS],
   async detect(cwd) {
@@ -539,21 +575,14 @@ export const ruffFormatter = {
   async detect(cwd) {
     if (hasRuffConfig(cwd))
       return true;
-    const { getToolPath } = await import("./installer/index.js");
-    const installed = await getToolPath("ruff");
-    return Boolean(installed);
+    return Boolean(await getToolPath("ruff"));
   }
 };
 export const blackFormatter = {
   name: "black",
   command: ["black", "$FILE"],
   extensions: [".py", ".pyi"],
-  async resolveCommand(filePath, cwd) {
-    const venv = await findInVenv("black", cwd);
-    if (venv)
-      return [venv, filePath];
-    return null;
-  },
+  resolveCommand: managedFormatterResolver("black", [], findInVenv),
   async detect(cwd) {
     return hasBlackConfig(cwd);
   }
@@ -642,12 +671,7 @@ export const shfmtFormatter = {
       ...styleArgs
     ]);
   },
-  async detect(_cwd) {
-    if (await which("shfmt") !== null)
-      return true;
-    const { getToolPath } = await import("./installer/index.js");
-    return Boolean(await getToolPath("shfmt"));
-  }
+  detect: managedToolDetect("shfmt", undefined, async () => await which("shfmt") !== null)
 };
 export const nixfmtFormatter = {
   name: "nixfmt",
@@ -703,12 +727,7 @@ export const ktlintFormatter = {
       return [inPath, "-F", filePath];
     return resolveManagedSmartDefaultCommand("ktlint", filePath, ["-F"]);
   },
-  async detect(_cwd) {
-    if (await which("ktlint") !== null)
-      return true;
-    const { getToolPath } = await import("./installer/index.js");
-    return Boolean(await getToolPath("ktlint"));
-  }
+  detect: managedToolDetect("ktlint", undefined, async () => await which("ktlint") !== null)
 };
 export const ktfmtFormatter = {
   name: "ktfmt",
@@ -777,6 +796,18 @@ export const gleamFormatter = {
     return false;
   }
 };
+export const typstyleFormatter = {
+  name: "typstyle",
+  command: ["typstyle", "-i", "$FILE"],
+  extensions: [".typ", ".typc"],
+  async resolveCommand(filePath) {
+    const inPath = await which("typstyle");
+    if (inPath)
+      return [inPath, "-i", filePath];
+    return resolveManagedSmartDefaultCommand("typstyle", filePath, ["-i"]);
+  },
+  detect: managedToolDetect("typstyle", undefined, async () => await which("typstyle") !== null)
+};
 export const terraformFormatter = {
   name: "terraform",
   command: ["terraform", "fmt", "$FILE"],
@@ -801,19 +832,15 @@ export const phpCsFixerFormatter = {
   async resolveCommand(filePath, cwd) {
     const configPath = resolvePhpCsFixerConfig(filePath);
     const binary = await findInVendorBin("php-cs-fixer", cwd) ?? await which("php-cs-fixer");
-    if (!binary)
+    const managed = await resolveManagedFormatterCommand("php-cs-fixer", filePath, [], findInVendorBin, cwd);
+    if (managed === FORMATTER_UNAVAILABLE)
+      return FORMATTER_UNAVAILABLE;
+    const resolved = binary ?? managed[0];
+    if (!resolved)
       return FORMATTER_UNAVAILABLE;
-    return configPath ? [binary, "fix", "--config", configPath, filePath] : [binary, "fix", filePath];
+    return configPath ? [resolved, "fix", "--config", configPath, filePath] : [resolved, "fix", filePath];
   },
-  async detect(cwd) {
-    const vendorBin = await findInVendorBin("php-cs-fixer", cwd);
-    const globalBin = await which("php-cs-fixer");
-    if (!vendorBin && !globalBin)
-      return false;
-    const configs = [".php-cs-fixer.php", ".php-cs-fixer.dist.php"];
-    const found = await findUp(configs, cwd);
-    return found.length > 0;
-  }
+  detect: managedToolDetect("php-cs-fixer", async (cwd) => (await findUp([".php-cs-fixer.php", ".php-cs-fixer.dist.php"], cwd)).length > 0, async (cwd) => Boolean(await findInVendorBin("php-cs-fixer", cwd) || await which("php-cs-fixer")))
 };
 export const csharpierFormatter = {
   name: "csharpier",
@@ -824,9 +851,7 @@ export const csharpierFormatter = {
       return ["csharpier", "format", filePath];
     }
     if (await which("dotnet") !== null) {
-      const legacy = await safeSpawnAsync("dotnet", ["csharpier", "--version"], {
-        timeout: 5000
-      });
+      const legacy = await probeToolAsync("dotnet", ["csharpier", "--version"], { timeout: 5000 });
       if (!legacy.error && legacy.status === 0) {
         return ["dotnet", "csharpier", filePath];
       }
@@ -838,7 +863,7 @@ export const csharpierFormatter = {
       return true;
     if (await which("dotnet") === null)
       return false;
-    const result = await safeSpawnAsync("dotnet", ["csharpier", "--version"], {
+    const result = await probeToolAsync("dotnet", ["csharpier", "--version"], {
       timeout: 5000
     });
     return !result.error && result.status === 0;
@@ -864,18 +889,8 @@ export const styluaFormatter = {
   name: "stylua",
   command: ["stylua", "$FILE"],
   extensions: [".lua"],
-  async resolveCommand(filePath, cwd) {
-    const local = findLocalBinUpwards("stylua", cwd);
-    return local ? [local, filePath] : null;
-  },
-  async detect(cwd) {
-    const local = findLocalBinUpwards("stylua", cwd);
-    if (!local && await which("stylua") === null)
-      return false;
-    const configs = ["stylua.toml", ".stylua.toml"];
-    const found = await findUp(configs, cwd);
-    return found.length > 0;
-  }
+  resolveCommand: managedFormatterResolver("stylua", [], findLocalBinUpwards),
+  detect: managedToolDetect("stylua", async (cwd) => (await findUp(["stylua.toml", ".stylua.toml"], cwd)).length > 0, async (cwd) => Boolean(findLocalBinUpwards("stylua", cwd) || await which("stylua")))
 };
 export const ormoluFormatter = {
   name: "ormolu",
@@ -895,42 +910,28 @@ export const taploFormatter = {
       return [inPath, "fmt", filePath];
     return resolveManagedSmartDefaultCommand("taplo", filePath, ["fmt"]);
   },
-  async detect(_cwd) {
-    if (await which("taplo") !== null)
-      return true;
-    const { getToolPath } = await import("./installer/index.js");
-    return Boolean(await getToolPath("taplo"));
-  }
+  detect: managedToolDetect("taplo", undefined, async () => await which("taplo") !== null)
 };
 export const googleJavaFormatFormatter = {
   name: "google-java-format",
   command: ["google-java-format", "--replace", "$FILE"],
   extensions: [".java"],
-  async detect(cwd) {
-    if (await which("google-java-format") === null)
-      return false;
-    return hasGoogleJavaFormatConfig(cwd);
-  }
+  resolveCommand: managedFormatterResolver("google-java-format", ["--replace"]),
+  detect: managedToolDetect("google-java-format", hasGoogleJavaFormatConfig, async () => await which("google-java-format") !== null)
 };
 export const cljfmtFormatter = {
   name: "cljfmt",
   command: ["cljfmt", "fix", "$FILE"],
   extensions: [".clj", ".cljc", ".cljs"],
-  async detect(cwd) {
-    if (await which("cljfmt") === null)
-      return false;
-    return hasCljfmtConfig(cwd);
-  }
+  resolveCommand: managedFormatterResolver("cljfmt", ["fix"]),
+  detect: managedToolDetect("cljfmt", hasCljfmtConfig, async () => await which("cljfmt") !== null)
 };
 export const cmakeFormatFormatter = {
   name: "cmake-format",
   command: ["cmake-format", "-i", "$FILE"],
   extensions: [".cmake"],
-  async detect(cwd) {
-    if (await which("cmake-format") === null)
-      return false;
-    return hasCmakeFormatConfig(cwd);
-  }
+  resolveCommand: managedFormatterResolver("cmake-format", ["-i"]),
+  detect: managedToolDetect("cmake-format", hasCmakeFormatConfig, async () => await which("cmake-format") !== null)
 };
 export const cueFormatter = {
   name: "cue",
@@ -973,7 +974,7 @@ export const psscriptanalyzerFormatFormatter = {
     const pwsh = await which("pwsh") ?? await which("powershell");
     if (!pwsh)
       return false;
-    const result = await safeSpawnAsync(pwsh, [
+    const result = await probeToolAsync(pwsh, [
       "-NoProfile",
       "-Command",
       "Get-Module -ListAvailable PSScriptAnalyzer | Select-Object -First 1 -ExpandProperty Name"
@@ -1010,6 +1011,7 @@ export const ALL_FORMATTERS = [
   rubocopFormatter,
   standardrbFormatter,
   gleamFormatter,
+  typstyleFormatter,
   taploFormatter,
   googleJavaFormatFormatter,
   cljfmtFormatter,
@@ -1019,7 +1021,7 @@ export const ALL_FORMATTERS = [
 ];
 const FILENAME_FORMATTER_BASENAMES = new Set(ALL_FORMATTERS.flatMap((f) => f.filenames ?? []));
 const detectionCache = new BoundedLruCache(32);
-const formatterSignatureFlights = new Map;
+const formatterSignatureFlights = new BoundedLruCache(32);
 const formatterCacheGeneration = createGenerationSource("formatter-cache");
 const FORMATTER_CONFIG_FILES = [
   "package.json",
@@ -1268,28 +1270,54 @@ export function _getFormatterResetStateForTests() {
     whichLatchByCommand,
     whichTransientCommands,
     cooldownRecordedForRetryAtMs,
-    detectionCache
+    detectionCache,
+    formatterSignatureFlights
   };
 }
 export function clearFormatterRuntimeState() {
   clearFormatterCache();
 }
 const BOX_DRAWING_GLOBAL = /[\u2500-\u257F]/g;
-const HAS_BOX_DRAWING = /[\u2500-\u257F]/;
+const DECORATION_RULE = /^[\u2500-\u257F\s]*$/;
+const DECORATION_HEADING = /^\S+[ \t]+[\u2500-\u257F][\u2500-\u257F\s]*$/;
 export function firstDiagnosticLine(text) {
   for (const raw of (text ?? "").split(`
 `)) {
     const line = stripAnsi(raw).trimEnd();
-    const stripped = line.replace(BOX_DRAWING_GLOBAL, "").trim();
-    if (!stripped)
-      continue;
-    if (HAS_BOX_DRAWING.test(line) && stripped.length <= 24)
+    if (isDecorativeLine(line))
       continue;
-    return stripped.slice(0, 300);
+    return line.replace(BOX_DRAWING_GLOBAL, "").trim().slice(0, 300);
   }
   return;
 }
+function isDecorativeLine(line) {
+  return DECORATION_RULE.test(line) || DECORATION_HEADING.test(line);
+}
+const FORMATTER_ERROR_TAIL_LINES = 20;
+export function diagnosticTail(text, maxLines = FORMATTER_ERROR_TAIL_LINES) {
+  const lines = [];
+  for (const raw of (text ?? "").split(`
+`)) {
+    const line = stripAnsi(raw).trimEnd();
+    if (isDecorativeLine(line))
+      continue;
+    lines.push(line.slice(0, 300));
+  }
+  if (lines.length === 0)
+    return;
+  return lines.slice(-maxLines).join(`
+`);
+}
 async function resolveFormatterCommand(formatter, absolutePath, cwd) {
+  const agreement = establishToolAgreement(formatter.name, cwd);
+  if (agreement.decision === "decline") {
+    recordDegradationOnce({
+      kind: "formatter-agreement-unavailable",
+      subject: agreement.subject,
+      reason: agreement.reason
+    });
+    return FORMATTER_AGREEMENT_UNAVAILABLE;
+  }
   const resolved = formatter.resolveCommand ? await formatter.resolveCommand(absolutePath, cwd) : null;
   if (resolved === SKIP_FORMATTING)
     return SKIP_FORMATTING;
@@ -1307,6 +1335,7 @@ export async function formatFile(filePath, formatter) {
   try {
     const absolutePath = path.resolve(filePath);
     const cwd = path.dirname(absolutePath);
+    const formatterCwd = resolveToolCwd("formatter", formatter.name, absolutePath, { cwd: path.parse(absolutePath).root }).cwd;
     const contentBefore = await fs.readFile(absolutePath, "utf-8");
     const cmd = await resolveFormatterCommand(formatter, absolutePath, cwd);
     if (cmd === SKIP_FORMATTING) {
@@ -1320,9 +1349,17 @@ export async function formatFile(filePath, formatter) {
         error: `${formatter.name}: formatter executable not found`
       };
     }
+    if (cmd === FORMATTER_AGREEMENT_UNAVAILABLE) {
+      return {
+        success: true,
+        changed: false,
+        outcome: "unavailable",
+        error: `${formatter.name}: project tool agreement could not be established`
+      };
+    }
     const result = await safeSpawnAsync(cmd[0], cmd.slice(1), {
       timeout: 15000,
-      cwd
+      cwd: formatterCwd
     });
     if (result.spawnFailure?.kind === "tool-not-found") {
       return {
@@ -1338,7 +1375,7 @@ export async function formatFile(filePath, formatter) {
         success: false,
         changed: false,
         outcome: "failed",
-        error: result.error?.message || firstDiagnosticLine(result.stderr) || firstDiagnosticLine(result.stdout) || `${formatter.name} exited with status ${result.status}`
+        error: result.error?.message || diagnosticTail(result.stderr) || diagnosticTail(result.stdout) || `${formatter.name} exited with status ${result.status}`
       };
     }
     const contentAfter = await fs.readFile(absolutePath, "utf-8");

package/extensions/dm-lens/clients/generated-artifacts.js

@@ -88,7 +88,7 @@ function hasGeneratedArtifactContent(content) {
   const header = content.slice(0, DEFAULT_HEADER_BYTES);
   return GENERATED_HEADER_PATTERNS.some((pattern) => pattern.test(header));
 }
-export const MACHINE_EMITTED_LINE_SHAPE_MIN_CONTENT = 2048;
+const MACHINE_EMITTED_LINE_SHAPE_MIN_CONTENT = 2048;
 export const MACHINE_EMITTED_LINE_SHAPE_MEAN_THRESHOLD = 2500;
 export function classifyMachineEmittedLineShape(content) {
   const contentLength = content.length;
@@ -201,7 +201,7 @@ export function classifyGeneratedOrArtifactDetailed(filePath, options = {}) {
   }
   return weakNameMatch ? { verdict: "generated", evidence: "name-only" } : { verdict: "clean" };
 }
-export function classifyGeneratedOrArtifact(filePath, options = {}) {
+function classifyGeneratedOrArtifact(filePath, options = {}) {
   return classifyGeneratedOrArtifactDetailed(filePath, options).verdict;
 }
 export function isGeneratedOrArtifact(filePath, options = {}) {

package/extensions/dm-lens/clients/generation-guard.js

@@ -89,6 +89,10 @@ export function createGenerationMap(name, options = {}) {
       invalidations += 1;
       stamps.delete(normalize(key));
     },
+    clear() {
+      invalidations += 1;
+      stamps.clear();
+    },
     size() {
       return stamps.size;
     }