@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/dispatch/suppress-writer.js

@@ -1,57 +0,0 @@
-import * as path from "node:path";
-import { parseInlineSuppressionRuleIds, splitInlineSuppressionPayload } from "./inline-suppressions.js";
-const HASH_COMMENT_EXTENSIONS = new Set([
-  ".py",
-  ".rb",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".yml",
-  ".yaml",
-  ".toml",
-  ".r",
-  ".pl",
-  ".pm",
-  ".ex",
-  ".exs",
-  ".elixir",
-  ".dockerfile",
-  ".gitignore",
-  ".conf",
-  ".cfg",
-  ".ini"
-]);
-function commentPrefixFor(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  return HASH_COMMENT_EXTENSIONS.has(ext) ? "#" : "//";
-}
-export function insertSuppressComment(content, filePath, line, rule) {
-  const lines = content.split(/\r?\n/);
-  if (line < 1 || line > lines.length) {
-    throw new Error(`line ${line} is out of range (file has ${lines.length} lines)`);
-  }
-  const prefix = commentPrefixFor(filePath);
-  const aboveIdx = line - 2;
-  const existingAbove = aboveIdx >= 0 ? lines[aboveIdx] : undefined;
-  const suppressRe = /((?:\/\/|#)\s*dm-lens-ignore:\s*)(.+)$/;
-  const match = existingAbove !== undefined ? suppressRe.exec(existingAbove) : null;
-  if (match && existingAbove !== undefined) {
-    const prefix = match[1];
-    const payload = match[2];
-    if (prefix === undefined || payload === undefined)
-      return content;
-    const { ruleList, trailingReason } = splitInlineSuppressionPayload(payload);
-    const rules = ruleList.split(",").map((r) => r.trim()).filter(Boolean);
-    const ruleIds = parseInlineSuppressionRuleIds(ruleList);
-    if (!ruleIds.includes(rule))
-      rules.push(rule);
-    lines[aboveIdx] = existingAbove.slice(0, match.index) + prefix + rules.join(", ") + trailingReason;
-    return lines.join(`
-`);
-  }
-  const targetLine = lines[line - 1] ?? "";
-  const indent = /^\s*/.exec(targetLine)?.[0] ?? "";
-  lines.splice(line - 1, 0, `${indent}${prefix} dm-lens-ignore: ${rule}`);
-  return lines.join(`
-`);
-}

package/extensions/dm-lens/dist/clients/dispatch/tool-profile.js

@@ -1,30 +0,0 @@
-const DEFAULT_TOOL_PROFILE = {
-  dedupPriority: 50,
-  lintLike: false
-};
-const TOOL_PROFILE_MAP = {
-  "tree-sitter:silent-error": { dedupPriority: 200, lintLike: false },
-  lsp: { dedupPriority: 120, lintLike: false },
-  eslint: { dedupPriority: 110, lintLike: true },
-  biome: { dedupPriority: 100, lintLike: true },
-  "biome-check-json": { dedupPriority: 100, lintLike: true },
-  "tree-sitter": { dedupPriority: 90, lintLike: false },
-  "ast-grep-napi": { dedupPriority: 80, lintLike: false },
-  "ast-grep": { dedupPriority: 80, lintLike: false },
-  "ruff-lint": { dedupPriority: 95, lintLike: true },
-  oxlint: { dedupPriority: 95, lintLike: true },
-  rubocop: { dedupPriority: 95, lintLike: true },
-  "go-vet": { dedupPriority: 95, lintLike: true },
-  "golangci-lint": { dedupPriority: 95, lintLike: true },
-  "rust-clippy": { dedupPriority: 95, lintLike: true },
-  shellcheck: { dedupPriority: 95, lintLike: true },
-  opengrep: { dedupPriority: 105, lintLike: false },
-  "trivy-config": { dedupPriority: 105, lintLike: false }
-};
-export function getToolProfile(tool, defectClass) {
-  const t = tool.toLowerCase();
-  if (defectClass === "silent-error" && t === "tree-sitter") {
-    return TOOL_PROFILE_MAP["tree-sitter:silent-error"];
-  }
-  return TOOL_PROFILE_MAP[t] ?? DEFAULT_TOOL_PROFILE;
-}

package/extensions/dm-lens/dist/clients/dispatch/types.js

@@ -1,7 +0,0 @@
-export const RUNNER_SKIP_REASONS = [
-  "no-files-matched",
-  "configured-non-biome-linter"
-];
-export function isRunnerSkipReason(value) {
-  return RUNNER_SKIP_REASONS.some((reason) => reason === value);
-}

package/extensions/dm-lens/dist/clients/dispatch/utils/format-utils.js

@@ -1,45 +0,0 @@
-const EMOJI = {
-  blocking: "\uD83D\uDD34",
-  warning: "\uD83D\uDFE1",
-  fixed: "✅",
-  info: "ℹ️",
-  silent: "\uD83D\uDCCA",
-  none: ""
-};
-function formatDiagnostic(d) {
-  const line = d.line ? `L${d.line}: ` : "";
-  const indented = d.message.split(`
-`).join(`
-  `);
-  const fix = d.fixSuggestion ? `
-    \uD83D\uDCA1 Fix: ${d.fixSuggestion}` : "";
-  return `  ${line}${indented}${fix}`;
-}
-export function formatDiagnostics(diagnostics, semantic, maxDisplay = 10) {
-  if (diagnostics.length === 0)
-    return "";
-  const emoji = EMOJI[semantic] ?? EMOJI.warning;
-  let output = "";
-  if (semantic === "blocking") {
-    output += `
-${emoji} STOP — ${diagnostics.length} issue(s) must be fixed:
-`;
-  } else if (semantic === "warning") {
-    output += `
-${emoji} ${diagnostics.length} warning(s):
-`;
-  } else if (semantic === "fixed") {
-    output += `
-${emoji} Auto-fixed ${diagnostics.length} issue(s):
-`;
-  }
-  for (const d of diagnostics.slice(0, maxDisplay)) {
-    output += `${formatDiagnostic(d)}
-`;
-  }
-  if (diagnostics.length > maxDisplay) {
-    output += `  ... and ${diagnostics.length - maxDisplay} more
-`;
-  }
-  return output;
-}

package/extensions/dm-lens/dist/clients/dispatch/utils/lsp-diagnostics.js

@@ -1,31 +0,0 @@
-export function convertLspDiagnostics(diags, filePath, options = {}) {
-  const tool = options.tool ?? "lsp";
-  return diags.filter((d) => d.range?.start?.line !== undefined).map((d, idx) => {
-    const severityMap = {
-      1: "error",
-      2: "warning",
-      4: "hint"
-    };
-    const severity = severityMap[d.severity] ?? "info";
-    const semantic = d.severity === 1 ? "blocking" : d.severity === 2 ? "warning" : "none";
-    const code = String(d.code ?? "unknown");
-    const source = d.source ?? tool;
-    const hasSuggestion = options.fixSuggestionByIndex?.has(idx) ?? false;
-    return {
-      id: `${tool}:${code}:${d.range.start.line}`,
-      message: d.message,
-      filePath,
-      line: d.range.start.line + 1,
-      column: d.range.start.character + 1,
-      severity,
-      semantic,
-      tool,
-      rule: `${source}:${code}`,
-      fixable: hasSuggestion,
-      autoFixAvailable: false,
-      fixKind: hasSuggestion ? "suggestion" : undefined,
-      fixSuggestion: options.fixSuggestionByIndex?.get(idx),
-      scanOrigin: options.scanOrigin
-    };
-  });
-}

package/extensions/dm-lens/dist/clients/disposition-logger.js

@@ -1,19 +0,0 @@
-import * as path from "node:path";
-import { isTestMode } from "./env-utils.js";
-import { getGlobalDmLensLogDir } from "./probe-home-state.js";
-import { createNdjsonLogger } from "./ndjson-logger.js";
-const DISPOSITION_LOG_DIR = getGlobalDmLensLogDir();
-const DISPOSITION_LOG_FILE = path.join(DISPOSITION_LOG_DIR, "dispositions.log");
-const DISPOSITION_LOG_BACKUP_FILE = path.join(DISPOSITION_LOG_DIR, "dispositions.log.1");
-const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.DM_LENS_DISPOSITION_LOG_MAX_BYTES ?? "1048576", 10) || 1048576);
-const writer = createNdjsonLogger({
-  filePath: DISPOSITION_LOG_FILE,
-  maxBytes: MAX_LOG_BYTES,
-  backupPath: DISPOSITION_LOG_BACKUP_FILE
-});
-export function logDispositionEvent(entry) {
-  if (isTestMode()) {
-    return;
-  }
-  writer.log({ ts: new Date().toISOString(), ...entry });
-}

package/extensions/dm-lens/dist/clients/disposition-publish.js

@@ -1,88 +0,0 @@
-import { logBusEvent } from "./bus-events-logger.js";
-import { isBusPublishEnabled } from "./bus-publish.js";
-import { normalizeFilePath } from "./path-utils.js";
-import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter } from "./live-bus-emitter.js";
-export const BUS_DISPOSITION_EVENT = "dmlens:diagnostic:disposition";
-export const BUS_DISPOSITION_VERSION = 1;
-const liveEmitter = createLiveBusEmitter();
-let hasLoggedFailure = false;
-let hasLoggedUnwired = false;
-let hasLoggedDisabled = false;
-export function wireDispositionBusEmitter(emitFn) {
-  liveEmitter.wire(emitFn);
-}
-export function wireDispositionBusEmitterGetter(getter) {
-  liveEmitter.wireGetter(getter);
-}
-export function _resetDispositionPublishForTests() {
-  liveEmitter.reset();
-  hasLoggedFailure = false;
-  hasLoggedUnwired = false;
-  hasLoggedDisabled = false;
-}
-export function publishDisposition(args) {
-  if (!isBusPublishEnabled()) {
-    if (!hasLoggedDisabled) {
-      hasLoggedDisabled = true;
-      logBusEvent({
-        event: BUS_DISPOSITION_EVENT,
-        outcome: "skipped_disabled",
-        cwd: normalizeFilePath(args.cwd)
-      });
-    }
-    return;
-  }
-  const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
-    event: BUS_DISPOSITION_EVENT,
-    cwd: normalizeFilePath(args.cwd)
-  }));
-  if (resolution.outcome === "stale-session")
-    return;
-  if (resolution.outcome === "unwired") {
-    if (!hasLoggedUnwired) {
-      hasLoggedUnwired = true;
-      logBusEvent({
-        event: BUS_DISPOSITION_EVENT,
-        outcome: "skipped_unwired",
-        cwd: normalizeFilePath(args.cwd)
-      });
-    }
-    return;
-  }
-  const busEmit = resolution.emit;
-  try {
-    const payload = {
-      v: BUS_DISPOSITION_VERSION,
-      source: "dm-lens",
-      cwd: normalizeFilePath(args.cwd),
-      filePath: normalizeFilePath(args.filePath),
-      disposition: args.disposition,
-      tool: args.tool,
-      rule: args.rule,
-      line: args.line,
-      anchor: args.anchor,
-      reason: args.reason,
-      message: args.message
-    };
-    busEmit(BUS_DISPOSITION_EVENT, payload);
-    hasLoggedFailure = false;
-    logBusEvent({
-      event: BUS_DISPOSITION_EVENT,
-      outcome: "emitted",
-      cwd: payload.cwd
-    });
-  } catch (err) {
-    logBusEvent({
-      event: BUS_DISPOSITION_EVENT,
-      outcome: "emit_failed",
-      cwd: normalizeFilePath(args.cwd),
-      error: String(err),
-      ctxSource: resolution.ctxSource
-    });
-    if (!hasLoggedFailure) {
-      hasLoggedFailure = true;
-      recordStaleBusFailure(BUS_DISPOSITION_EVENT, err);
-      args.dbg?.(`disposition-publish: dmlens:diagnostic:disposition emit failed (further failures suppressed): ${err}`);
-    }
-  }
-}

package/extensions/dm-lens/dist/clients/durable-store.js

@@ -1,77 +0,0 @@
-import * as fs from "node:fs";
-import fsp from "node:fs/promises";
-import { writeFileAtomic, writeFileAtomicAsync } from "./atomic-write.js";
-import { acquireBoundedPidFileLock, acquireQuarantinePidFileLock } from "./bounded-pid-file-lock.js";
-function readLocked(path) {
-  try {
-    return fs.readFileSync(path, "utf8");
-  } catch {
-    return;
-  }
-}
-export function commitDurableStore(options) {
-  const release = options.onContention === "skip-log" ? acquireBoundedPidFileLock(`${options.path}.lock`, {
-    waitMs: options.waitMs,
-    retryMs: options.retryMs,
-    timeoutMessage: options.timeoutMessage,
-    onContention: "skip-log",
-    logContention: options.logContention
-  }) : acquireBoundedPidFileLock(`${options.path}.lock`, {
-    waitMs: options.waitMs,
-    retryMs: options.retryMs,
-    timeoutMessage: options.timeoutMessage,
-    onContention: "throw"
-  });
-  if (!release)
-    return;
-  let committed;
-  try {
-    const current = options.deserialize(readLocked(options.path));
-    committed = options.merge(current);
-    writeFileAtomic(options.path, options.serialize(committed), {
-      bestEffort: false
-    });
-    options.afterWriteLocked?.(committed);
-  } finally {
-    release();
-  }
-  return committed;
-}
-async function readLockedAsync(path) {
-  try {
-    return await fsp.readFile(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
-  }
-}
-export async function commitDurableStoreAsync(options) {
-  const release = options.onContention === "skip-log" ? await acquireQuarantinePidFileLock(`${options.path}.lock`, {
-    waitMs: options.waitMs,
-    retryMs: options.retryMs,
-    staleMs: options.staleMs,
-    timeoutMessage: options.timeoutMessage,
-    onContention: "skip-log",
-    logContention: options.logContention
-  }) : await acquireQuarantinePidFileLock(`${options.path}.lock`, {
-    waitMs: options.waitMs,
-    retryMs: options.retryMs,
-    staleMs: options.staleMs,
-    timeoutMessage: options.timeoutMessage,
-    onContention: "throw"
-  });
-  if (!release)
-    return;
-  try {
-    const current = options.deserialize(await readLockedAsync(options.path));
-    const committed = options.merge(current);
-    await writeFileAtomicAsync(options.path, options.serialize(committed), {
-      bestEffort: false
-    });
-    await options.afterWriteLocked?.(committed);
-    return committed;
-  } finally {
-    await release();
-  }
-}

package/extensions/dm-lens/dist/clients/effective-config.js

@@ -1,160 +0,0 @@
-import * as os from "node:os";
-import * as path from "node:path";
-import { compareKeys, provenanceFor, provenanceView } from "./config-core/provenance.js";
-import { LSP_NAMESPACE_KEY } from "./config-locations.js";
-import { lspSectionOf, resolveDmLensConfig, summarizeConfigResolution } from "./config-resolve.js";
-import { getToolPlan } from "./dispatch/plan.js";
-import { getAvailableRunners } from "./dispatch/integration.js";
-import { detectFileKind } from "./file-kinds.js";
-import { getGlobalDmLensDir } from "./file-utils.js";
-import { resolveLanguage } from "./language-registry.js";
-import { getDmLensGlobalConfigPath } from "./lens-config.js";
-import { explainServersForFile, lspConfigOf, registerLSPConfig } from "./lsp/config.js";
-import { isSameOrWithin } from "./lsp/server.js";
-import { homeRelativePath } from "./path-utils.js";
-import { resolveToolCwd } from "./tool-cwd.js";
-import { compareOrdinal } from "./string-utils.js";
-import { LENS_TOOL_NAMES, resolveLensToolEnabled } from "./tool-config.js";
-export function isEffectiveFileViewError(file) {
-  return "error" in file;
-}
-function countBy(items, key) {
-  const counts = {};
-  for (const item of items) {
-    const name = key(item);
-    counts[name] = (counts[name] ?? 0) + 1;
-  }
-  return counts;
-}
-function redactServerSpec(entry) {
-  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-    return;
-  }
-  const record = entry;
-  const command = typeof record.command === "string" ? record.command : undefined;
-  const args = Array.isArray(record.args) ? record.args : [];
-  const env = typeof record.env === "object" && record.env !== null ? Object.keys(record.env).sort(compareOrdinal) : [];
-  return {
-    ...command === undefined ? {} : { command },
-    argvCount: (command === undefined ? 0 : 1) + args.length,
-    envNames: env
-  };
-}
-function provenanceOfSubtree(resolved, pointer) {
-  const own = provenanceFor(resolved, pointer);
-  if (own)
-    return own;
-  const prefix = `${pointer}/`;
-  let best;
-  for (const entry of resolved.provenance.values()) {
-    if (!entry.key.startsWith(prefix))
-      continue;
-    if (!best || compareKeys(entry.key, best.key) < 0)
-      best = entry;
-  }
-  return best;
-}
-function viewOf(entry, homeDir) {
-  if (!entry)
-    return;
-  return {
-    key: entry.key,
-    tier: entry.tier,
-    ...entry.file === undefined ? {} : { file: homeRelativePath(entry.file, homeDir) },
-    ...entry.trust === undefined ? {} : { trust: entry.trust }
-  };
-}
-function decidedByOrNothing(entry) {
-  return entry === undefined ? {} : { decidedBy: entry };
-}
-export async function effectiveConfig(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const homeDir = options.homeDir ?? os.homedir();
-  const resolveAt = (dir) => resolveDmLensConfig({
-    cwd: dir,
-    globalDir: getGlobalDmLensDir(),
-    globalConfigPath: getDmLensGlobalConfigPath(),
-    homeDir
-  });
-  const requestedFile = options.file === undefined ? undefined : path.resolve(cwd, options.file);
-  const fileOutsideCwd = requestedFile !== undefined && !isSameOrWithin(cwd, requestedFile);
-  const absolute = fileOutsideCwd ? undefined : requestedFile;
-  const resolution = resolveAt(absolute === undefined ? cwd : path.dirname(absolute));
-  const resolved = {
-    value: resolution.value,
-    provenance: resolution.provenance
-  };
-  const summary = summarizeConfigResolution(resolution, homeDir);
-  const homeRelativeCwd = homeRelativePath(cwd, homeDir);
-  const view = {
-    cwd: homeRelativeCwd,
-    documents: summary.documents,
-    provenance: provenanceView(resolved, homeDir).entries,
-    provenanceCounts: summary.countsByTier,
-    recordCounts: countBy(resolution.records, (record) => record.code),
-    tools: LENS_TOOL_NAMES.map((name) => ({
-      name,
-      enabled: resolveLensToolEnabled(name, resolved.value, undefined, options.noTools)
-    })),
-    ...fileOutsideCwd ? {
-      file: {
-        error: `file is outside cwd (${homeRelativeCwd}); query with cwd set ` + "to the file's own workspace instead"
-      }
-    } : absolute === undefined ? {} : {
-      file: await fileView(absolute, resolved, homeDir, cwd, registerLSPConfig(lspConfigOf(resolution.value)))
-    }
-  };
-  return view;
-}
-function toolReason(selected, kind) {
-  if (selected)
-    return "selected";
-  return kind === undefined ? "no-dispatch-plan" : "not-registered-for-kind";
-}
-async function fileView(absolute, resolved, homeDir, workspaceCwd, lspConfig) {
-  const language = resolveLanguage(absolute);
-  const kind = detectFileKind(absolute);
-  const section = lspSectionOf(resolved.value);
-  const customServers = typeof section.servers === "object" && section.servers !== null && !Array.isArray(section.servers) ? section.servers : {};
-  const denied = Array.isArray(section.disabledServers) ? section.disabledServers : [];
-  const denyPointer = `/${LSP_NAMESPACE_KEY}/disabledServers`;
-  const decidedByDeny = (id) => {
-    const index = denied.indexOf(id);
-    return viewOf(provenanceFor(resolved, index >= 0 ? `${denyPointer}/${index}` : denyPointer), homeDir);
-  };
-  const servers = explainServersForFile(absolute, lspConfig).map((entry) => {
-    const spec = redactServerSpec(customServers[entry.server.id]);
-    return {
-      id: entry.server.id,
-      selected: entry.selected,
-      reason: entry.reason,
-      ...entry.server.role === undefined ? {} : { role: entry.server.role },
-      ...entry.reason === "disabled-by-config" ? decidedByOrNothing(decidedByDeny(entry.server.id)) : {},
-      ...spec === undefined ? {} : {
-        spec,
-        ...entry.reason === "disabled-by-config" ? {} : {
-          decidedBy: viewOf(provenanceOfSubtree(resolved, `/${LSP_NAMESPACE_KEY}/servers/${entry.server.id}`) ?? provenanceOfSubtree(resolved, `/servers/${entry.server.id}`), homeDir)
-        }
-      }
-    };
-  });
-  const available = new Set(await getAvailableRunners(absolute));
-  const planned = kind ? getToolPlan(kind)?.groups.flatMap((group) => group.runnerIds) ?? [] : [];
-  const ids = [...new Set([...planned, ...available])].sort(compareOrdinal);
-  const tools = ids.map((id) => ({
-    id,
-    selected: available.has(id),
-    reason: toolReason(available.has(id), kind),
-    resolvedCwd: homeRelativePath(resolveToolCwd("runner", id, absolute, {
-      cwd: workspaceCwd,
-      suppressTelemetry: true
-    }).cwd, homeDir)
-  }));
-  return {
-    path: homeRelativePath(absolute, homeDir),
-    ...language === undefined ? {} : { language: language.id },
-    ...kind === undefined ? {} : { kind },
-    servers,
-    tools
-  };
-}

package/extensions/dm-lens/dist/clients/env-utils.js

@@ -1,26 +0,0 @@
-export function isTestMode() {
-  if (process.env.DM_LENS_TEST_MODE === "1")
-    return true;
-  if (process.env.VITEST && process.env.DM_LENS_TEST_MODE !== "0")
-    return true;
-  return false;
-}
-export function toPositiveFinite(value) {
-  const num = typeof value === "number" ? value : Number(value);
-  return Number.isFinite(num) && num > 0 ? num : 0;
-}
-export function lazyEnvNumber(envName, fallback) {
-  let memo;
-  return {
-    get() {
-      if (memo !== undefined)
-        return memo;
-      const envValue = toPositiveFinite(process.env[envName]);
-      memo = envValue > 0 ? envValue : fallback;
-      return memo;
-    },
-    _resetForTests() {
-      memo = undefined;
-    }
-  };
-}

package/extensions/dm-lens/dist/clients/error-class.js

@@ -1,3 +0,0 @@
-export function errorClassName(error) {
-  return error instanceof Error ? error.name : "unknown error";
-}

package/extensions/dm-lens/dist/clients/eval-timestamp.js

@@ -1,2 +0,0 @@
-import { performance } from "node:perf_hooks";
-export const DM_LENS_EVAL_STARTED_MS = performance.now();

package/extensions/dm-lens/dist/clients/event-loop-hold.js

@@ -1,119 +0,0 @@
-import { claimPhaseOncePerSession, logLatency, releaseOncePerSessionPhase } from "./latency-logger.js";
-import { getWorkspaceSweepMaxHoldAgeMs } from "./lsp/workspace-sweep-hold.js";
-import { getProcessSingleton } from "./process-singletons.js";
-const EVENT_LOOP_HOLD_ARMED_PHASE = "event_loop_hold_armed";
-const EVENT_LOOP_HOLD_FAMILY = "event-loop-hold";
-const EVENT_LOOP_HOLD_VERSION = 1;
-function state() {
-  return getProcessSingleton(EVENT_LOOP_HOLD_FAMILY, EVENT_LOOP_HOLD_VERSION, () => ({ holds: new Map, nextHoldId: 1, timer: undefined }));
-}
-export function getEventLoopHoldMaxMs() {
-  return getWorkspaceSweepMaxHoldAgeMs();
-}
-function armForNextDeadline(current) {
-  if (current.timer !== undefined)
-    return;
-  if (current.holds.size === 0)
-    return;
-  const maxMs = getEventLoopHoldMaxMs();
-  let soonest = Number.POSITIVE_INFINITY;
-  for (const entry of current.holds.values()) {
-    soonest = Math.min(soonest, entry.acquiredAt + maxMs);
-  }
-  const delayMs = soonest - Date.now();
-  current.timer = setTimeout(() => reapStaleHolds(), delayMs);
-}
-function disarmIfIdle(current) {
-  if (current.holds.size > 0)
-    return;
-  if (current.timer === undefined)
-    return;
-  clearTimeout(current.timer);
-  current.timer = undefined;
-}
-function reapStaleHolds() {
-  const current = state();
-  current.timer = undefined;
-  try {
-    const maxMs = getEventLoopHoldMaxMs();
-    const now = Date.now();
-    const released = [];
-    for (const [holdId, entry] of current.holds) {
-      if (now - entry.acquiredAt <= maxMs)
-        continue;
-      current.holds.delete(holdId);
-      released.push(entry);
-    }
-    if (released.length > 0) {
-      recordForceReleased(released, current.holds.size, maxMs, now);
-    }
-  } finally {
-    armForNextDeadline(current);
-  }
-}
-function recordForceReleased(released, stillHeld, maxMs, now) {
-  try {
-    const oldestAcquiredAt = Math.min(...released.map((entry) => entry.acquiredAt));
-    logLatency({
-      type: "phase",
-      phase: "event_loop_hold_force_released",
-      filePath: "",
-      durationMs: now - oldestAcquiredAt,
-      metadata: {
-        maxHoldMs: maxMs,
-        releasedHolds: released.length,
-        stillHeld,
-        labels: [...new Set(released.map((entry) => entry.label))].slice(0, 8)
-      }
-    });
-  } catch {}
-}
-function recordFirstArm(entry, maxMs) {
-  try {
-    if (!claimPhaseOncePerSession(EVENT_LOOP_HOLD_ARMED_PHASE, "process")) {
-      return;
-    }
-    logLatency({
-      type: "phase",
-      phase: EVENT_LOOP_HOLD_ARMED_PHASE,
-      filePath: "",
-      durationMs: 0,
-      metadata: { label: entry.label, maxHoldMs: maxMs }
-    });
-  } catch {}
-}
-export function acquireEventLoopHold(label) {
-  const current = state();
-  const holdId = current.nextHoldId++;
-  const entry = { acquiredAt: Date.now(), label };
-  current.holds.set(holdId, entry);
-  const wasArmed = current.timer !== undefined;
-  armForNextDeadline(current);
-  if (!wasArmed)
-    recordFirstArm(entry, getEventLoopHoldMaxMs());
-  return () => {
-    const now = state();
-    if (!now.holds.delete(holdId))
-      return;
-    disarmIfIdle(now);
-  };
-}
-export function _eventLoopHoldCountForTests() {
-  return state().holds.size;
-}
-export function _eventLoopKeepAliveForTests() {
-  const timer = state().timer;
-  return {
-    armed: timer !== undefined,
-    hasRef: timer?.hasRef?.() === true
-  };
-}
-export function _resetEventLoopHoldForTests() {
-  releaseOncePerSessionPhase(EVENT_LOOP_HOLD_ARMED_PHASE);
-  const current = state();
-  current.holds.clear();
-  if (current.timer !== undefined)
-    clearTimeout(current.timer);
-  current.timer = undefined;
-  current.nextHoldId = 1;
-}