@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/biome-client.js

@@ -0,0 +1,221 @@
+import { createSubsystemLogger } from "./extension-log.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isFileKind } from "./file-kinds.js";
+import { getGlobalDmLensDir } from "./file-utils.js";
+import { findGlobalBinary } from "./package-manager.js";
+import { safeSpawnAsync } from "./safe-spawn.js";
+import { probeToolAsync } from "./tool-probe.js";
+import { createSingleFlight } from "./single-flight.js";
+import { biomeConfigArgs } from "./tool-policy.js";
+import { resolveToolCwd } from "./tool-cwd.js";
+import { resolveManagedToolClient } from "./dispatch/runners/utils/runner-helpers.js";
+import { classifyProbeFailure, describeInstallAttempt, createAvailabilityLatch, logAvailabilityDecision, startHostStallSampler } from "./dispatch/runners/utils/availability-policy.js";
+const PROBE_TIMEOUT_MS = 1e4;
+
+export class BiomeClient {
+  availabilityLatch = createAvailabilityLatch();
+  lastProbeCause = null;
+  lastProbeElapsedMs = 0;
+  lastProbeHostStallMs = 0;
+  lastProbeEvidence;
+  localBinaryByCwd = new Map;
+  autoInstalledBinaryPath = null;
+  ensureFlight = createSingleFlight();
+  log;
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("biome") : () => {};
+  }
+  async getBiomeBinary(cwd) {
+    const resolveCwd = cwd ?? process.cwd();
+    const cached = this.localBinaryByCwd.get(resolveCwd);
+    if (cached)
+      return { cmd: cached, args: [] };
+    const isWin = process.platform === "win32";
+    const piLensBin = path.join(getGlobalDmLensDir(), "tools", "node_modules", ".bin");
+    const candidates = isWin ? [
+      path.join(resolveCwd, "node_modules", ".bin", "biome.cmd"),
+      path.join(resolveCwd, "node_modules", ".bin", "biome")
+    ] : [path.join(resolveCwd, "node_modules", ".bin", "biome")];
+    for (const p of candidates) {
+      if (fs.existsSync(p)) {
+        this.localBinaryByCwd.set(resolveCwd, p);
+        return { cmd: p, args: [] };
+      }
+    }
+    if (this.autoInstalledBinaryPath) {
+      return { cmd: this.autoInstalledBinaryPath, args: [] };
+    }
+    const managedCandidates = isWin ? [path.join(piLensBin, "biome.cmd"), path.join(piLensBin, "biome")] : [path.join(piLensBin, "biome")];
+    for (const p of managedCandidates) {
+      if (fs.existsSync(p)) {
+        this.localBinaryByCwd.set(resolveCwd, p);
+        return { cmd: p, args: [] };
+      }
+    }
+    const global = await findGlobalBinary("biome");
+    if (global) {
+      this.localBinaryByCwd.set(resolveCwd, global);
+      return { cmd: global, args: [] };
+    }
+    return { cmd: "npx", args: ["@biomejs/biome"] };
+  }
+  async spawnBiomeAsync(args, timeout = 15000, cwd) {
+    const { cmd, args: prefix } = await this.getBiomeBinary(cwd);
+    return safeSpawnAsync(cmd, [...prefix, ...args], { timeout, cwd });
+  }
+  async ensureAvailable() {
+    const memo = this.availabilityLatch.read();
+    if (memo !== null)
+      return memo;
+    return this.ensureFlight.run("biome", () => this.doEnsureAvailable());
+  }
+  async probeBiome() {
+    const sampler = startHostStallSampler();
+    const startedAt = Date.now();
+    let result;
+    let hostStallMs;
+    try {
+      const { cmd, args: prefix } = await this.getBiomeBinary();
+      result = await probeToolAsync(cmd, [...prefix, "--version"], {
+        timeout: PROBE_TIMEOUT_MS
+      });
+    } finally {
+      hostStallMs = sampler.stop();
+    }
+    const elapsedMs = Date.now() - startedAt;
+    if (!result.error && result.status === 0) {
+      this.lastProbeCause = "ok";
+      logAvailabilityDecision({
+        tool: "biome",
+        verdict: "available",
+        outcome: "success",
+        cause: "ok",
+        elapsedMs,
+        latched: true,
+        hostStallMs,
+        budgetMs: PROBE_TIMEOUT_MS,
+        classifiedBy: "probe"
+      });
+      return { outcome: "success", value: true };
+    }
+    const { outcome, cause, evidence } = classifyProbeFailure(result, {
+      hostStallMs,
+      unclassifiedFailureOutcome: "missing"
+    });
+    const failureOutcome = outcome === "success" ? "non-installable" : outcome;
+    this.lastProbeCause = cause;
+    this.lastProbeElapsedMs = elapsedMs;
+    this.lastProbeHostStallMs = hostStallMs;
+    this.lastProbeEvidence = evidence;
+    return { outcome: failureOutcome };
+  }
+  async doEnsureAvailable() {
+    const resolved = await resolveManagedToolClient({
+      toolId: "biome",
+      cwd: process.cwd(),
+      probe: () => this.probeBiome(),
+      acceptInstalled: (installedPath) => {
+        this.autoInstalledBinaryPath = installedPath;
+        return true;
+      }
+    });
+    if (resolved.outcome === "success") {
+      this.availabilityLatch.noteAvailable();
+      if (this.lastProbeCause !== null && this.lastProbeCause !== "ok") {
+        logAvailabilityDecision({
+          tool: "biome",
+          verdict: "available",
+          outcome: "success",
+          cause: "ok",
+          elapsedMs: this.lastProbeElapsedMs,
+          latched: true,
+          hostStallMs: this.lastProbeHostStallMs,
+          budgetMs: PROBE_TIMEOUT_MS,
+          classifiedBy: "caller",
+          evidence: {
+            install: "succeeded",
+            binary: "biome",
+            source: "managed-dir"
+          }
+        });
+      }
+      return true;
+    }
+    const cause = this.lastProbeCause ?? "not-found";
+    const retryAfterMs = this.availabilityLatch.noteUnavailable(resolved.outcome, cause);
+    let installEvidence;
+    if (resolved.outcome === "missing") {
+      const { getInstallAttempt } = await import("./installer/index.js");
+      installEvidence = describeInstallAttempt(getInstallAttempt("biome"));
+    }
+    const evidence = { ...this.lastProbeEvidence, ...installEvidence };
+    logAvailabilityDecision({
+      tool: "biome",
+      verdict: "unavailable",
+      outcome: resolved.outcome,
+      cause,
+      elapsedMs: this.lastProbeElapsedMs,
+      latched: resolved.outcome !== "transient",
+      hostStallMs: this.lastProbeHostStallMs,
+      ...retryAfterMs > 0 && { retryAfterMs },
+      budgetMs: PROBE_TIMEOUT_MS,
+      classifiedBy: this.lastProbeCause === null || resolved.outcome === "non-installable" ? "caller" : "probe",
+      ...Object.keys(evidence).length > 0 && { evidence }
+    });
+    if (resolved.outcome === "transient") {
+      this.log("biome availability probe timed out; will retry (not installing)");
+    }
+    return false;
+  }
+  isSupportedFile(filePath) {
+    return isFileKind(filePath, ["jsts", "json", "css"]);
+  }
+  async fixFileAsync(filePath, cwd) {
+    if (!await this.ensureAvailable()) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: "Biome not available"
+      };
+    }
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: "File not found"
+      };
+    }
+    try {
+      const before = await fs.promises.readFile(absolutePath, "utf-8");
+      const configCwd = resolveToolCwd("runner", "biome", absolutePath, {
+        ...cwd !== undefined && { cwd }
+      }).cwd;
+      const result = await this.spawnBiomeAsync(["lint", "--write", ...biomeConfigArgs(configCwd), absolutePath], 15000, configCwd);
+      if (result.error) {
+        return {
+          success: false,
+          changed: false,
+          fixed: 0,
+          error: result.error.message
+        };
+      }
+      const after = await fs.promises.readFile(absolutePath, "utf-8");
+      const changed = before !== after;
+      if (changed) {
+        this.log(`Fixed issue(s) in ${path.basename(filePath)}`);
+      }
+      return { success: true, changed, fixed: changed ? 1 : 0 };
+    } catch (err) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+}

package/extensions/dm-lens/dist/clients/blocker-freshness.js

@@ -0,0 +1,385 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { bounded } from "./deadline-utils.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { HOOK_WALL_BUDGET_MS } from "./hook-budgets.js";
+import { normalizeEphemeralMapKey } from "./path-utils.js";
+import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
+import { resolveImportToFiles } from "./review-graph/import-resolvers.js";
+import { getSharedTreeSitterClient, resolveTreeSitterLanguage } from "./tree-sitter-shared.js";
+import { TreeSitterSymbolExtractor } from "./tree-sitter-symbol-extractor.js";
+export const DEPENDENCY_DRIFT_MAX_DELIVERIES = 3;
+const SELF_DRIFT_HASH_BUDGET_BYTES = 8 * 1024 * 1024;
+const MAX_DRIFT_CHECK_IMPORTS = 128;
+const extractorCache = new Map;
+function getExtractor(languageId) {
+  let cached = extractorCache.get(languageId);
+  if (!cached) {
+    cached = (async () => {
+      const client = getSharedTreeSitterClient();
+      if (!client)
+        return null;
+      const extractor = new TreeSitterSymbolExtractor(languageId, client);
+      const ok = await extractor.init();
+      return ok ? extractor : null;
+    })().catch(() => null);
+    extractorCache.set(languageId, cached);
+  }
+  return cached;
+}
+const importResolutionMemo = new Map;
+let importResolutionMemoTurnIndex;
+function noteImportResolutionMemoTurn(turnIndex) {
+  if (turnIndex === undefined)
+    return;
+  if (importResolutionMemoTurnIndex !== turnIndex) {
+    importResolutionMemo.clear();
+    importResolutionMemoTurnIndex = turnIndex;
+  }
+}
+async function resolveForwardImportsMemoized(cwd, filePath, resolveForwardImports) {
+  const sig = await statSignature(filePath);
+  if (sig === undefined) {
+    try {
+      return await resolveForwardImports(cwd, filePath);
+    } catch {
+      return [];
+    }
+  }
+  const cached = importResolutionMemo.get(filePath);
+  if (cached && cached.mtimeMs === sig.mtimeMs && cached.size === sig.size)
+    return cached.imports;
+  let imports;
+  try {
+    imports = await resolveForwardImports(cwd, filePath);
+  } catch {
+    imports = [];
+  }
+  importResolutionMemo.set(filePath, {
+    mtimeMs: sig.mtimeMs,
+    size: sig.size,
+    imports
+  });
+  return imports;
+}
+export async function extractForwardImportPaths(cwd, filePath) {
+  const languageId = resolveTreeSitterLanguage(filePath);
+  if (!languageId)
+    return [];
+  const client = getSharedTreeSitterClient();
+  if (!client)
+    return [];
+  const extractor = await getExtractor(languageId);
+  if (!extractor)
+    return [];
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const outcome = await client.withParsedTree(filePath, languageId, content, (tree) => extractor.extract(tree, filePath, content).imports);
+  if (!outcome.parsed)
+    return [];
+  const resolved = new Set;
+  for (const ref of outcome.value) {
+    for (const target of resolveImportToFiles(cwd, filePath, languageId, ref.source)) {
+      resolved.add(target);
+    }
+  }
+  return [...resolved];
+}
+async function statSignature(filePath) {
+  try {
+    const stat = await fs.promises.stat(filePath);
+    return { mtimeMs: stat.mtimeMs, size: stat.size };
+  } catch {
+    return;
+  }
+}
+async function statMtimeMs(filePath) {
+  try {
+    const stat = await fs.promises.stat(filePath);
+    return stat.mtimeMs;
+  } catch {
+    return;
+  }
+}
+async function detectSelfDrift(args) {
+  const boundOptions = (label) => ({
+    ms: HOOK_WALL_BUDGET_MS.turn_end,
+    signal: args.signal,
+    hook: "turn_end",
+    label
+  });
+  const stat = await bounded(fs.promises.stat(args.filePath), boundOptions("selfDriftStat"));
+  if (stat === undefined)
+    return { verdict: "unverifiable", unverifiableReason: "stat-unavailable" };
+  if (args.recordedSize === undefined)
+    return { verdict: "unverifiable", unverifiableReason: "missing-baseline" };
+  if (stat.size !== args.recordedSize)
+    return { verdict: "drift" };
+  const freshness = freshnessFromMtime({
+    mtimeMs: stat.mtimeMs,
+    referenceMs: args.recordedAtMs
+  });
+  if (!args.forceContent && freshness.verdict !== "stale")
+    return { verdict: "unchanged" };
+  if (args.recordedHash === undefined)
+    return { verdict: "unverifiable", unverifiableReason: "missing-baseline" };
+  if (stat.size > args.budget.bytesLeft) {
+    args.budget.exhausted = true;
+    return {
+      verdict: "unverifiable",
+      unverifiableReason: "hash-budget-exhausted"
+    };
+  }
+  const content = await bounded(fs.promises.readFile(args.filePath), boundOptions("selfDriftHash"));
+  if (content === undefined)
+    return { verdict: "unverifiable", unverifiableReason: "hash-unavailable" };
+  args.budget.bytesLeft -= content.byteLength;
+  const hash = createHash("sha256").update(content).digest("hex");
+  return { verdict: hash === args.recordedHash ? "unchanged" : "drift" };
+}
+export async function collectForwardImportMtimes(cwd, filePath, resolveForwardImports = extractForwardImportPaths, turnIndex) {
+  noteImportResolutionMemoTurn(turnIndex);
+  let imports = [];
+  try {
+    imports = await resolveForwardImportsMemoized(cwd, filePath, resolveForwardImports);
+  } catch {
+    imports = [];
+  }
+  const truncated = imports.length > MAX_DRIFT_CHECK_IMPORTS;
+  const out = [];
+  for (const dep of imports.slice(0, MAX_DRIFT_CHECK_IMPORTS)) {
+    const mtimeMs = await statMtimeMs(dep);
+    if (mtimeMs !== undefined)
+      out.push({ path: dep, mtimeMs });
+  }
+  return { mtimes: out, truncated };
+}
+export { MTIME_DRIFT_TOLERANCE_MS } from "./freshness.js";
+import { freshnessFromMtime } from "./freshness.js";
+async function detectDrift(cwd, filePath, recordedAtMs, resolveForwardImports, turnIndex, skipOwnFile = false) {
+  const drifted = [];
+  if (!skipOwnFile) {
+    const ownFreshness = freshnessFromMtime({
+      mtimeMs: await statMtimeMs(filePath),
+      referenceMs: recordedAtMs
+    });
+    if (ownFreshness.verdict === "stale")
+      drifted.push(filePath);
+  }
+  const { mtimes, truncated } = await collectForwardImportMtimes(cwd, filePath, resolveForwardImports, turnIndex);
+  for (const { path: depPath, mtimeMs } of mtimes) {
+    const verdict = freshnessFromMtime({
+      mtimeMs,
+      referenceMs: recordedAtMs
+    });
+    if (verdict.verdict === "stale")
+      drifted.push(depPath);
+  }
+  return { drifted, truncated };
+}
+function isEligibleForDriftCheck(entry) {
+  if (entry.stale)
+    return false;
+  if (entry.recordedAtMs === undefined)
+    return false;
+  return entry.sources !== undefined && entry.sources.length > 0;
+}
+function isAllLspSourced(sources) {
+  return sources !== undefined && sources.length > 0 && sources.every((source) => source === "lsp");
+}
+function canSubsumeLspWidgetRow(entry) {
+  return isEligibleForDriftCheck(entry) && isAllLspSourced(entry.sources);
+}
+export async function sweepInlineBlockerFreshness(runtime, cwd, options) {
+  const counts = {
+    total: 0,
+    kept: 0,
+    revalidated: 0,
+    alreadyStale: 0,
+    truncatedImports: 0,
+    selfHealed: 0,
+    selfUnverifiable: 0,
+    hashBudgetExhausted: 0
+  };
+  const resolveForwardImports = options?.resolveForwardImports ?? extractForwardImportPaths;
+  let turnIndex;
+  try {
+    turnIndex = runtime.turnIndex;
+  } catch {
+    turnIndex = undefined;
+  }
+  let inlineEntries;
+  try {
+    inlineEntries = runtime.getInlineBlockersSnapshot();
+  } catch {
+    return counts;
+  }
+  const population = inlineEntries.map((entry) => ({
+    filePath: entry.filePath,
+    stale: entry.stale ?? false,
+    recordedAtMs: entry.recordedAtMs,
+    sources: entry.sources,
+    staleReason: entry.staleReason,
+    recordedSize: entry.recordedSize,
+    recordedHash: entry.recordedHash,
+    demote: () => runtime.markInlineBlockerStale(entry.filePath, "dependency-drift"),
+    setSelfDrift: (isSelfDrift) => runtime.setInlineBlockerSelfDriftStale(entry.filePath, isSelfDrift)
+  }));
+  const inlineByKey = new Map;
+  for (const entry of population) {
+    inlineByKey.set(normalizeEphemeralMapKey(entry.filePath), entry);
+  }
+  for (const extra of options?.additionalEntries ?? []) {
+    const key = normalizeEphemeralMapKey(extra.filePath);
+    const inlineEntry = inlineByKey.get(key);
+    if (inlineEntry && canSubsumeLspWidgetRow(inlineEntry)) {
+      const demoteInline = inlineEntry.demote;
+      const demoteWidget = extra.demote;
+      inlineEntry.demote = () => {
+        const inlineChanged = demoteInline();
+        const widgetChanged = demoteWidget();
+        return inlineChanged || widgetChanged;
+      };
+      continue;
+    }
+    population.push({
+      filePath: extra.filePath,
+      stale: false,
+      recordedAtMs: extra.recordedAtMs,
+      sources: ["lsp"],
+      demote: extra.demote,
+      staleReason: undefined,
+      recordedSize: undefined,
+      recordedHash: undefined
+    });
+  }
+  counts.total = population.length;
+  const hashBudget = {
+    bytesLeft: SELF_DRIFT_HASH_BUDGET_BYTES,
+    exhausted: false
+  };
+  for (const entry of population) {
+    try {
+      const selfDriftDemoted = entry.stale && entry.staleReason === "self-drift";
+      if (entry.stale && !selfDriftDemoted) {
+        counts.alreadyStale += 1;
+        continue;
+      }
+      if (entry.recordedAtMs === undefined) {
+        counts.kept += 1;
+        continue;
+      }
+      const recordedSources = entry.sources !== undefined && entry.sources.length > 0 ? entry.sources : undefined;
+      if (recordedSources === undefined) {
+        counts.kept += 1;
+        continue;
+      }
+      const setSelfDrift = entry.setSelfDrift;
+      const isLspSourced = isAllLspSourced(recordedSources);
+      let ownVerdict;
+      if (setSelfDrift) {
+        const hashBudgetWasExhausted = hashBudget.exhausted;
+        const selfDrift = await bounded(detectSelfDrift({
+          filePath: entry.filePath,
+          recordedAtMs: entry.recordedAtMs,
+          recordedSize: entry.recordedSize,
+          recordedHash: entry.recordedHash,
+          forceContent: isLspSourced && entry.recordedSize !== undefined && entry.recordedHash !== undefined,
+          signal: options?.signal,
+          budget: hashBudget
+        }), {
+          ms: HOOK_WALL_BUDGET_MS.turn_end,
+          signal: options?.signal,
+          hook: "turn_end",
+          label: "detectSelfDrift"
+        }) ?? {
+          verdict: "unverifiable",
+          unverifiableReason: "bound-expired"
+        };
+        ownVerdict = selfDrift.verdict;
+        if (ownVerdict === "unverifiable") {
+          counts.selfUnverifiable += 1;
+          const reason = selfDrift.unverifiableReason ?? (hashBudgetWasExhausted || hashBudget.exhausted ? "hash-budget-exhausted" : "hash-unavailable");
+          recordDegradationOnce({
+            kind: "self-drift-unverifiable",
+            subject: `inline-blocker:${toRunnerDisplayPath(cwd, entry.filePath)}#${reason}`,
+            reason: `the self-drift check was unverifiable: ${reason}`
+          });
+          if (reason === "hash-budget-exhausted") {
+            recordDegradationOnce({
+              kind: "self-drift-hash-budget-exhausted",
+              subject: `inline-blocker:${toRunnerDisplayPath(cwd, entry.filePath)}`,
+              reason: "the aggregate self-drift hash budget was exhausted"
+            });
+          }
+        }
+      }
+      if (!isLspSourced) {
+        if (!setSelfDrift || ownVerdict === undefined) {
+          counts.kept += 1;
+          continue;
+        }
+        if (ownVerdict === "unverifiable") {
+          if (selfDriftDemoted)
+            counts.alreadyStale += 1;
+          else
+            counts.kept += 1;
+          continue;
+        }
+        const shouldDemote = ownVerdict === "drift";
+        const transitioned = setSelfDrift(shouldDemote);
+        if (shouldDemote) {
+          if (transitioned)
+            counts.revalidated += 1;
+          else
+            counts.alreadyStale += 1;
+        } else if (transitioned) {
+          counts.selfHealed += 1;
+        } else {
+          counts.kept += 1;
+        }
+        continue;
+      }
+      let contentDecidedOwnFile = false;
+      if (setSelfDrift !== undefined && ownVerdict !== undefined && entry.recordedSize !== undefined) {
+        if (ownVerdict === "drift") {
+          const transitioned = setSelfDrift(true);
+          if (transitioned)
+            counts.revalidated += 1;
+          else
+            counts.alreadyStale += 1;
+          continue;
+        }
+        if (ownVerdict === "unchanged") {
+          contentDecidedOwnFile = true;
+          const transitioned = setSelfDrift(false);
+          if (transitioned)
+            counts.selfHealed += 1;
+        } else {
+          if (selfDriftDemoted) {
+            counts.alreadyStale += 1;
+            continue;
+          }
+        }
+      }
+      const skipOwnFile = contentDecidedOwnFile;
+      const { drifted, truncated } = await detectDrift(cwd, entry.filePath, entry.recordedAtMs, resolveForwardImports, turnIndex, skipOwnFile);
+      if (truncated)
+        counts.truncatedImports += 1;
+      if (drifted.length > 0) {
+        entry.demote();
+        counts.revalidated += 1;
+      } else {
+        counts.kept += 1;
+      }
+    } catch {
+      counts.kept += 1;
+    }
+  }
+  counts.hashBudgetExhausted = hashBudget.exhausted ? 1 : 0;
+  return counts;
+}

package/extensions/dm-lens/dist/clients/blocker-past-eof.js

@@ -0,0 +1,49 @@
+import { demotePastEofDiagnostics, resyncDocumentOnPastEof } from "./diagnostic-line-freshness.js";
+export function sweepInlineBlockerPastEof(runtime, cwd, options) {
+  const counts = {
+    total: 0,
+    checked: 0,
+    demoted: 0,
+    deadLinesByPath: new Map
+  };
+  const resync = options?.resync ?? resyncDocumentOnPastEof;
+  let entries;
+  try {
+    entries = runtime.getInlineBlockersSnapshot();
+  } catch {
+    return counts;
+  }
+  counts.total = entries.length;
+  for (const entry of entries) {
+    try {
+      if (!entry.lines || entry.lines.length === 0)
+        continue;
+      if (entry.stale && entry.staleReason !== "past-eof")
+        continue;
+      counts.checked += 1;
+      const probes = entry.lines.map((line) => ({
+        line,
+        stale: entry.stale,
+        staleReason: entry.staleReason
+      }));
+      const { diagnostics } = demotePastEofDiagnostics({
+        store: "inline-blocker",
+        cwd,
+        filePath: entry.filePath,
+        diagnostics: probes,
+        lineCountCache: options?.lineCountCache,
+        resync
+      });
+      const isPastEof = diagnostics.some((d) => d.stale);
+      if (isPastEof) {
+        counts.deadLinesByPath.set(entry.filePath, diagnostics.filter((d) => d.stale).map((d) => d.line).filter((line) => typeof line === "number"));
+      }
+      const transitioned = runtime.setInlineBlockerPastEofStale(entry.filePath, isPastEof);
+      if (!transitioned)
+        continue;
+      if (isPastEof)
+        counts.demoted += 1;
+    } catch {}
+  }
+  return counts;
+}