@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/python-provenance.js

@@ -1,551 +0,0 @@
-const SUMMARY_BY_ROOT = new WeakMap;
-const TRAVERSAL_VISIT_CAP = 50000;
-const TRAVERSAL_DEPTH_CAP = 128;
-const EXPRESSION_DEPTH_CAP = 8;
-const BINDING_SCAN_DEPTH_CAP = 32;
-const ANCESTOR_DEPTH_CAP = 64;
-export const PYTHON_SQLALCHEMY_RECEIVER_NAMES = new Set([
-  "session",
-  "db_session",
-  "async_session",
-  "sync_session"
-]);
-export const PYTHON_SQLALCHEMY_STATEMENT_BUILDERS = new Set(["select", "insert", "update", "delete"]);
-const FROM_IMPORT_PROVENANCE = new Map([
-  ["sqlalchemy.orm:Session", "sqlalchemy-session"],
-  ["sqlalchemy.ext.asyncio:AsyncSession", "sqlalchemy-session"],
-  ["psycopg:sql", "psycopg-sql-module"],
-  ["psycopg2:sql", "psycopg-sql-module"],
-  ["psycopg.sql:SQL", "psycopg-sql-constructor"],
-  ["psycopg2.sql:SQL", "psycopg-sql-constructor"],
-  ["psycopg.sql:Identifier", "psycopg-identifier-constructor"],
-  ["psycopg2.sql:Identifier", "psycopg-identifier-constructor"]
-]);
-const PLAIN_PACKAGE_PROVENANCE = new Map([
-  ["sqlalchemy", "sqlalchemy-module"],
-  ["psycopg", "psycopg-package"],
-  ["psycopg2", "psycopg-package"]
-]);
-function nodeKey(node) {
-  return `${node.type}:${node.startIndex}:${node.endIndex}`;
-}
-function namedChildren(node) {
-  return (node.children ?? []).filter((child) => child.isNamed);
-}
-function calleeNode(call) {
-  if (call.type !== "call")
-    return;
-  return call.childForFieldName?.("function") ?? namedChildren(call)[0];
-}
-function directNamedChild(node, type) {
-  return namedChildren(node).find((child) => child.type === type);
-}
-const BINDING_TARGET_CONTAINER_TYPES = new Set([
-  "tuple",
-  "pattern_list",
-  "list",
-  "list_pattern",
-  "tuple_pattern",
-  "starred_expression",
-  "list_splat_pattern",
-  "dictionary_splat_pattern"
-]);
-const BINDING_TARGET_REFERENCE_TYPES = new Set(["attribute", "subscript"]);
-const BINDING_PATTERN_CONTAINER_TYPES = new Set([
-  "case_pattern",
-  "as_pattern",
-  "union_pattern",
-  "list_pattern",
-  "tuple_pattern",
-  "list_splat_pattern",
-  "dictionary_splat_pattern",
-  "class_pattern"
-]);
-const BINDING_PATTERN_REFERENCE_TYPES = new Set([
-  "attribute",
-  "qualified_pattern"
-]);
-function scanBindingNames(node, mode, scan, depth = 0) {
-  if (!node || depth > BINDING_SCAN_DEPTH_CAP) {
-    scan.unknown = true;
-    return;
-  }
-  const descend = (child, next) => scanBindingNames(child, next, scan, depth + 1);
-  if (node.type === "as_pattern_target") {
-    descend(namedChildren(node)[0], "target");
-    return;
-  }
-  if (mode === "as") {
-    for (const child of namedChildren(node))
-      descend(child, "as");
-    return;
-  }
-  if (node.type === "identifier") {
-    if (node.text !== "_")
-      scan.names.push(node.text);
-    return;
-  }
-  if (mode === "pattern") {
-    if (node.type === "dotted_name") {
-      if (!node.text.includes(".") && node.text !== "_") {
-        scan.names.push(node.text);
-      }
-      return;
-    }
-    if (BINDING_PATTERN_REFERENCE_TYPES.has(node.type))
-      return;
-    if (node.type === "keyword_pattern") {
-      const value = namedChildren(node).slice(1);
-      if (value.length !== 1)
-        scan.unknown = true;
-      else
-        descend(value[0], "pattern");
-      return;
-    }
-    if (BINDING_PATTERN_CONTAINER_TYPES.has(node.type)) {
-      for (const child of namedChildren(node))
-        descend(child, "pattern");
-      return;
-    }
-    scan.unknown = true;
-    return;
-  }
-  if (BINDING_TARGET_REFERENCE_TYPES.has(node.type))
-    return;
-  if (BINDING_TARGET_CONTAINER_TYPES.has(node.type)) {
-    for (const child of namedChildren(node))
-      descend(child, "target");
-    return;
-  }
-  scan.unknown = true;
-}
-function collectBindingNames(node, mode) {
-  const scan = { names: [], unknown: false };
-  scanBindingNames(node, mode, scan);
-  return scan;
-}
-function parseImportBinding(node, isFrom) {
-  if (node.type === "aliased_import") {
-    const children = namedChildren(node);
-    const source = children[0]?.text;
-    const local = children.at(-1);
-    return source && local?.type === "identifier" ? { source, local: local.text } : undefined;
-  }
-  if (node.type !== "dotted_name" && node.type !== "identifier") {
-    return;
-  }
-  if (isFrom)
-    return { source: node.text, local: node.text };
-  const local = node.text.split(".")[0];
-  return local ? { source: node.text, local } : undefined;
-}
-function directAnnotationName(parameter) {
-  if (parameter.type !== "typed_parameter" && parameter.type !== "typed_default_parameter") {
-    return;
-  }
-  const type = directNamedChild(parameter, "type");
-  const children = type ? namedChildren(type) : [];
-  return children.length === 1 && children[0]?.type === "identifier" ? children[0].text : undefined;
-}
-function parameterName(parameter) {
-  if (parameter.type === "identifier")
-    return parameter.text;
-  return directNamedChild(parameter, "identifier")?.text;
-}
-function markInvalid(state) {
-  state.invalid = true;
-}
-function addBinding(state, name, functionChain) {
-  state.bindingCounts.set(name, (state.bindingCounts.get(name) ?? 0) + 1);
-  for (const fn of functionChain) {
-    const key = nodeKey(fn);
-    const bindings = state.functionBindings.get(key) ?? new Map;
-    bindings.set(name, (bindings.get(name) ?? 0) + 1);
-    state.functionBindings.set(key, bindings);
-  }
-}
-function addTarget(state, target, functionChain) {
-  const extracted = collectBindingNames(target, "target");
-  if (extracted.unknown)
-    markInvalid(state);
-  for (const name of extracted.names)
-    addBinding(state, name, functionChain);
-}
-function recordFunctionParameters(node, state) {
-  const annotations = new Map;
-  const parameters = directNamedChild(node, "parameters");
-  for (const parameter of namedChildren(parameters ?? node)) {
-    const name = parameterName(parameter);
-    if (!name) {
-      if (parameter.type !== "list_splat_pattern")
-        markInvalid(state);
-      continue;
-    }
-    addBinding(state, name, state.functionChain);
-    const annotation = directAnnotationName(parameter);
-    if (annotation)
-      annotations.set(name, annotation);
-  }
-  state.functionAnnotations.set(nodeKey(node), annotations);
-}
-function recordFunctionDefinition(node, state) {
-  recordFunctionParameters(node, state);
-  recordDefinitionBinding(node, state);
-}
-function recordLambdaParameters(node, state) {
-  const parameters = directNamedChild(node, "lambda_parameters");
-  for (const parameter of namedChildren(parameters ?? node)) {
-    const name = parameterName(parameter);
-    if (name)
-      addBinding(state, name, state.functionChain);
-    else
-      markInvalid(state);
-  }
-}
-function recordImportBindings(node, state) {
-  const isFrom = node.type === "import_from_statement";
-  const children = namedChildren(node);
-  const moduleName = isFrom ? children[0]?.text : undefined;
-  if (node.text.includes("*") || isFrom && !moduleName)
-    markInvalid(state);
-  for (const part of isFrom ? children.slice(1) : children) {
-    const binding = parseImportBinding(part, isFrom);
-    if (!binding) {
-      markInvalid(state);
-      continue;
-    }
-    addBinding(state, binding.local, state.functionChain);
-    if (!state.moduleDirect)
-      continue;
-    const provenance = isFrom ? FROM_IMPORT_PROVENANCE.get(`${moduleName}:${binding.source}`) : PLAIN_PACKAGE_PROVENANCE.get(binding.source);
-    if (provenance) {
-      state.imports.set(binding.local, {
-        name: binding.local,
-        provenance,
-        endIndex: node.endIndex
-      });
-    }
-  }
-}
-function recordTargetBinding(node, state) {
-  addTarget(state, node.childForFieldName?.("left") ?? namedChildren(node)[0], state.functionChain);
-}
-function recordAssignmentValue(node, state) {
-  recordTargetBinding(node, state);
-  const target = node.childForFieldName?.("left") ?? namedChildren(node)[0];
-  const value = node.childForFieldName?.("right") ?? namedChildren(node).at(-1);
-  if (target?.type !== "identifier" || !value || value === target)
-    return;
-  state.assignments.set(target.text, value);
-}
-function recordAsPatternBinding(node, state) {
-  const extracted = collectBindingNames(node, "as");
-  if (extracted.unknown)
-    markInvalid(state);
-  for (const name of extracted.names)
-    addBinding(state, name, state.functionChain);
-}
-function recordDeleteTargets(node, state) {
-  for (const child of namedChildren(node)) {
-    addTarget(state, child, state.functionChain);
-  }
-}
-function recordCaseBindings(node, state) {
-  const extracted = collectBindingNames(directNamedChild(node, "case_pattern"), "pattern");
-  if (extracted.unknown)
-    markInvalid(state);
-  for (const name of extracted.names)
-    addBinding(state, name, state.functionChain);
-}
-function recordDeclarationBindings(node, state) {
-  for (const child of namedChildren(node)) {
-    addBinding(state, child.text, state.functionChain);
-  }
-}
-function recordDefinitionBinding(node, state) {
-  const name = directNamedChild(node, "identifier")?.text;
-  if (name)
-    addBinding(state, name, state.parentFunctionChain);
-  else
-    markInvalid(state);
-}
-function recordTypeAliasBinding(node, state) {
-  const name = directNamedChild(node, "type")?.children?.find((child) => child.type === "identifier")?.text;
-  if (name)
-    addBinding(state, name, state.functionChain);
-  else
-    markInvalid(state);
-}
-const DYNAMIC_NAMESPACE_BUILTINS = new Set([
-  "exec",
-  "eval",
-  "globals",
-  "locals",
-  "vars"
-]);
-function recordDynamicNamespaceHazard(node, state) {
-  const callee = calleeNode(node);
-  if (callee?.type === "identifier" && DYNAMIC_NAMESPACE_BUILTINS.has(callee.text)) {
-    markInvalid(state);
-  }
-}
-const SUMMARY_NODE_RECORDERS = Object.freeze({
-  function_definition: recordFunctionDefinition,
-  class_definition: recordDefinitionBinding,
-  lambda: recordLambdaParameters,
-  import_from_statement: recordImportBindings,
-  import_statement: recordImportBindings,
-  assignment: recordAssignmentValue,
-  augmented_assignment: recordTargetBinding,
-  named_expression: recordTargetBinding,
-  for_statement: recordTargetBinding,
-  for_in_clause: recordTargetBinding,
-  with_item: recordAsPatternBinding,
-  except_clause: recordAsPatternBinding,
-  except_group_clause: recordAsPatternBinding,
-  delete_statement: recordDeleteTargets,
-  case_clause: recordCaseBindings,
-  type_alias_statement: recordTypeAliasBinding,
-  global_statement: recordDeclarationBindings,
-  nonlocal_statement: recordDeclarationBindings,
-  call: recordDynamicNamespaceHazard
-});
-
-class Summary {
-  invalid;
-  imports;
-  bindingCounts;
-  assignments;
-  functions;
-  constructor(root) {
-    const state = {
-      imports: new Map,
-      bindingCounts: new Map,
-      assignments: new Map,
-      functionBindings: new Map,
-      functionAnnotations: new Map,
-      invalid: false,
-      visits: 0,
-      functionChain: [],
-      parentFunctionChain: [],
-      moduleDirect: false
-    };
-    const visit = (node, depth, moduleDirect, activeFunctions) => {
-      if (++state.visits > TRAVERSAL_VISIT_CAP || depth > TRAVERSAL_DEPTH_CAP) {
-        markInvalid(state);
-        return;
-      }
-      if (node.hasError || node.type === "ERROR" || node.type === "MISSING") {
-        markInvalid(state);
-        return;
-      }
-      const functionChain = node.type === "function_definition" ? [...activeFunctions, node] : activeFunctions;
-      state.functionChain = functionChain;
-      state.parentFunctionChain = activeFunctions;
-      state.moduleDirect = moduleDirect;
-      const recorder = SUMMARY_NODE_RECORDERS[node.type];
-      if (recorder)
-        recorder(node, state);
-      for (const child of node.children ?? []) {
-        visit(child, depth + 1, node === root, functionChain);
-      }
-    };
-    visit(root, 0, false, []);
-    this.invalid = state.invalid;
-    this.imports = state.imports;
-    this.bindingCounts = state.bindingCounts;
-    this.assignments = state.assignments;
-    this.functions = new Map([...state.functionAnnotations.entries()].map(([key, annotations]) => [
-      key,
-      {
-        parameterAnnotations: annotations,
-        bindingCounts: state.functionBindings.get(key) ?? new Map
-      }
-    ]));
-  }
-  provenanceFor(name, reference) {
-    const candidate = this.boundOnce(name) ? this.imports.get(name) : undefined;
-    return candidate && candidate.endIndex <= reference.startIndex ? candidate.provenance : null;
-  }
-  boundOnce(name) {
-    return !this.invalid && (this.bindingCounts.get(name) ?? 0) === 1;
-  }
-  singleAssignmentValue(name, reference) {
-    if (!this.boundOnce(name))
-      return null;
-    const value = this.assignments.get(name);
-    return value && value.endIndex <= reference.startIndex ? value : null;
-  }
-  isFunctionLocalName(reference) {
-    if (this.invalid || reference.type !== "identifier")
-      return true;
-    let current = reference.parent;
-    for (let depth = 0;current && depth < ANCESTOR_DEPTH_CAP; depth++) {
-      if (current.type === "function_definition") {
-        const summary = this.functions.get(nodeKey(current));
-        if (!summary)
-          return true;
-        if ((summary.bindingCounts.get(reference.text) ?? 0) > 0)
-          return true;
-      }
-      current = current.parent;
-    }
-    return false;
-  }
-  isSqlAlchemySessionReceiver(receiver) {
-    if (this.invalid || receiver.type !== "identifier")
-      return false;
-    let current = receiver.parent;
-    for (let depth = 0;current && depth < ANCESTOR_DEPTH_CAP; depth++) {
-      if (current.type === "function_definition") {
-        const summary = this.functions.get(nodeKey(current));
-        if (!summary)
-          return false;
-        const annotation = summary.parameterAnnotations.get(receiver.text);
-        return annotation !== undefined && (summary.bindingCounts.get(receiver.text) ?? 0) === 1 && this.provenanceFor(annotation, receiver) === "sqlalchemy-session";
-      }
-      current = current.parent;
-    }
-    return false;
-  }
-}
-function getPythonProvenanceSummary(root) {
-  const cached = SUMMARY_BY_ROOT.get(root);
-  if (cached)
-    return cached;
-  const summary = new Summary(root);
-  SUMMARY_BY_ROOT.set(root, summary);
-  return summary;
-}
-function expressionProvenance(node, summary, depth = 0) {
-  if (!node || depth > EXPRESSION_DEPTH_CAP)
-    return null;
-  if (node.type === "identifier")
-    return summary.provenanceFor(node.text, node);
-  if (node.type !== "attribute")
-    return null;
-  const object = node.childForFieldName?.("object") ?? namedChildren(node)[0];
-  const attribute = node.childForFieldName?.("attribute") ?? namedChildren(node).at(-1);
-  const provenance = expressionProvenance(object, summary, depth + 1);
-  if (provenance === "psycopg-package" && attribute?.text === "sql") {
-    return "psycopg-sql-module";
-  }
-  if (provenance === "psycopg-sql-module") {
-    if (attribute?.text === "SQL")
-      return "psycopg-sql-constructor";
-    if (attribute?.text === "Identifier")
-      return "psycopg-identifier-constructor";
-  }
-  return null;
-}
-export function isSafePsycopgIdentifierComposition(node, root) {
-  if (node?.type !== "call" || !root)
-    return false;
-  const summary = getPythonProvenanceSummary(root);
-  if (summary.invalid)
-    return false;
-  const formatCallee = node.childForFieldName?.("function") ?? namedChildren(node)[0];
-  if (formatCallee?.type !== "attribute")
-    return false;
-  const formatChildren = namedChildren(formatCallee);
-  const hasFormatMethod = formatChildren.some((child) => child.text === "format");
-  const sqlConstructor = formatChildren.find((child) => child.type === "call");
-  if (!hasFormatMethod || !sqlConstructor)
-    return false;
-  const constructorCallee = sqlConstructor.childForFieldName?.("function") ?? namedChildren(sqlConstructor)[0];
-  if (expressionProvenance(constructorCallee, summary) !== "psycopg-sql-constructor")
-    return false;
-  const templateArgs = namedChildren(directNamedChild(sqlConstructor, "argument_list") ?? sqlConstructor).filter((child) => child.type !== "comment");
-  if (templateArgs.length !== 1 || templateArgs[0]?.type !== "string" || namedChildren(templateArgs[0]).some((child) => child.type === "interpolation"))
-    return false;
-  const formatArgs = namedChildren(directNamedChild(node, "argument_list") ?? node).filter((child) => child.type !== "comment");
-  if (formatArgs.length === 0)
-    return false;
-  return formatArgs.every((argument) => {
-    if (argument.type !== "call")
-      return false;
-    const callee = argument.childForFieldName?.("function") ?? namedChildren(argument)[0];
-    return expressionProvenance(callee, summary) === "psycopg-identifier-constructor";
-  });
-}
-export function isProvenSqlAlchemySessionReceiver(receiver, root) {
-  return !!receiver && !!root && getPythonProvenanceSummary(root).isSqlAlchemySessionReceiver(receiver);
-}
-function isStaticStringLiteral(node) {
-  return node?.type === "string" && !namedChildren(node).some((child) => child.type === "interpolation");
-}
-function callArguments(call) {
-  return namedChildren(directNamedChild(call, "argument_list") ?? call).filter((child) => child.type !== "comment");
-}
-const COMPOSED_SQL_NODE_TYPES = new Set([
-  "string",
-  "concatenated_string",
-  "binary_operator"
-]);
-function carriesComposedSql(node, depth = 0) {
-  if (!node)
-    return false;
-  if (depth > EXPRESSION_DEPTH_CAP)
-    return true;
-  if (COMPOSED_SQL_NODE_TYPES.has(node.type))
-    return true;
-  if (node.type !== "call")
-    return false;
-  const callee = calleeNode(node);
-  if (callee?.type === "attribute") {
-    const object = callee.childForFieldName?.("object") ?? namedChildren(callee)[0];
-    if (carriesComposedSql(object, depth + 1))
-      return true;
-  }
-  return callArguments(node).some((argument) => carriesComposedSql(argument, depth + 1));
-}
-function builderCalleeName(call, summary) {
-  const callee = calleeNode(call);
-  if (callee?.type === "identifier")
-    return callee.text;
-  if (callee?.type !== "attribute")
-    return;
-  const object = callee.childForFieldName?.("object") ?? namedChildren(callee)[0];
-  if (expressionProvenance(object, summary) !== "sqlalchemy-module") {
-    return;
-  }
-  const attribute = callee.childForFieldName?.("attribute") ?? namedChildren(callee).at(-1);
-  return attribute?.type === "identifier" ? attribute.text : undefined;
-}
-function isStatementBuilderCall(node, summary) {
-  if (node?.type !== "call")
-    return false;
-  const name = builderCalleeName(node, summary);
-  if (!name)
-    return false;
-  const args = callArguments(node);
-  if (name === "text") {
-    return args.length === 1 && isStaticStringLiteral(args[0]);
-  }
-  if (!PYTHON_SQLALCHEMY_STATEMENT_BUILDERS.has(name))
-    return false;
-  return !args.some((argument) => carriesComposedSql(argument));
-}
-export function isSqlAlchemyStatementArgument(node, root) {
-  if (!node || !root)
-    return false;
-  const summary = getPythonProvenanceSummary(root);
-  if (isStatementBuilderCall(node, summary))
-    return true;
-  if (node.type !== "identifier")
-    return false;
-  const bound = summary.singleAssignmentValue(node.text, node);
-  return isStatementBuilderCall(bound ?? undefined, summary);
-}
-export function isSqlAlchemyEntityQueryArgument(node, root) {
-  if (!node || !root)
-    return false;
-  const summary = getPythonProvenanceSummary(root);
-  if (isStatementBuilderCall(node, summary))
-    return true;
-  if (carriesComposedSql(node))
-    return false;
-  if (node.type !== "identifier")
-    return true;
-  return !summary.isFunctionLocalName(node);
-}

package/extensions/dm-lens/dist/clients/quiet-window-config.js

@@ -1,16 +0,0 @@
-import { toPositiveFinite } from "./env-utils.js";
-let _enabledCache;
-export function isQuietWindowEnabled() {
-  if (_enabledCache !== undefined)
-    return _enabledCache;
-  _enabledCache = process.env.DM_LENS_QUIET_WINDOW !== "0";
-  return _enabledCache;
-}
-export function _resetQuietWindowEnabledForTests() {
-  _enabledCache = undefined;
-}
-const DEFAULT_QUIET_WINDOW_WAIT_MS = 15000;
-export function quietWindowWaitMs() {
-  const raw = toPositiveFinite(process.env.DM_LENS_QUIET_WINDOW_WAIT_MS);
-  return raw > 0 ? raw : DEFAULT_QUIET_WINDOW_WAIT_MS;
-}

package/extensions/dm-lens/dist/clients/quiet-window.js

@@ -1,126 +0,0 @@
-import { readInstanceRegistry, updateHeartbeat } from "./instance-registry.js";
-import { logLatency } from "./latency-logger.js";
-import { sampleProcesses } from "./resource-sampler.js";
-import { _resetQuietWindowEnabledForTests, isQuietWindowEnabled, quietWindowWaitMs } from "./quiet-window-config.js";
-const _tasks = [];
-export function registerQuietWindowTask(name, fn) {
-  _tasks.push({ name, fn });
-}
-export function _resetQuietWindowTasksForTests() {
-  _tasks.length = 0;
-}
-
-export { isQuietWindowEnabled, quietWindowWaitMs, _resetQuietWindowEnabledForTests };
-let _inProgress = false;
-export async function runQuietWindow(deps) {
-  const { dbg, cwd } = deps;
-  if (!isQuietWindowEnabled()) {
-    logLatency({
-      type: "phase",
-      filePath: cwd ?? "<dm-lens>",
-      phase: "quiet_window",
-      durationMs: 0,
-      metadata: { skipped: "disabled" }
-    });
-    return;
-  }
-  if (_inProgress) {
-    dbg("quiet_window: skipping — a previous run is still in progress");
-    logLatency({
-      type: "phase",
-      filePath: cwd ?? "<dm-lens>",
-      phase: "quiet_window",
-      durationMs: 0,
-      metadata: { skipped: "in-progress" }
-    });
-    return;
-  }
-  _inProgress = true;
-  const totalStart = Date.now();
-  const results = [];
-  try {
-    for (const task of _tasks) {
-      const taskStart = Date.now();
-      let ok = true;
-      try {
-        await task.fn({
-          runtime: deps.runtime,
-          cwd: deps.cwd,
-          sessionId: deps.sessionId,
-          ownerId: deps.ownerId
-        });
-      } catch (err) {
-        ok = false;
-        const detail = err instanceof Error ? err.stack ?? `${err.name}: ${err.message}` : String(err);
-        dbg(`quiet_window: task "${task.name}" failed: ${detail}`);
-      }
-      results.push({
-        name: task.name,
-        durationMs: Date.now() - taskStart,
-        ok
-      });
-    }
-  } finally {
-    _inProgress = false;
-    logLatency({
-      type: "phase",
-      filePath: cwd ?? "<dm-lens>",
-      phase: "quiet_window",
-      durationMs: Date.now() - totalStart,
-      metadata: { tasks: results }
-    });
-  }
-}
-let _builtinsRegistered = false;
-export function registerBuiltinQuietWindowTasks(getRuntime) {
-  if (_builtinsRegistered)
-    return;
-  _builtinsRegistered = true;
-  registerQuietWindowTask("cascade_carry_over_settle", async () => {
-    const runtime = getRuntime();
-    await runtime.settleCascadeRuns(quietWindowWaitMs());
-  });
-  registerQuietWindowTask("instance_registry_heartbeat", async () => {
-    await updateHeartbeat(await buildHeartbeatResourcePatchBounded());
-  });
-}
-const HEARTBEAT_SAMPLE_TIMEOUT_MS = 2000;
-async function buildHeartbeatResourcePatchBounded() {
-  let timer;
-  try {
-    return await Promise.race([
-      buildHeartbeatResourcePatch(),
-      new Promise((resolve) => {
-        timer = setTimeout(() => resolve({}), HEARTBEAT_SAMPLE_TIMEOUT_MS);
-      })
-    ]);
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-}
-async function buildHeartbeatResourcePatch() {
-  try {
-    const instances = await readInstanceRegistry();
-    const self = instances.find((instance) => instance.pid === process.pid);
-    const childPids = self?.lspChildren.map((child) => child.pid) ?? [];
-    const usage = await sampleProcesses([process.pid, ...childPids]);
-    if (usage === null)
-      return {};
-    const childUsage = {};
-    for (const pid of childPids) {
-      const sample = usage.get(pid);
-      if (sample)
-        childUsage[pid] = sample;
-    }
-    return {
-      cpuPercent: usage.get(process.pid)?.cpuPercent,
-      childUsage
-    };
-  } catch {
-    return {};
-  }
-}
-export function _resetBuiltinQuietWindowRegistrationForTests() {
-  _builtinsRegistered = false;
-}