@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,221 +0,0 @@
-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

@@ -1,385 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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;
-}