@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/cjs/linters/eslint-rules/no-over-cap-wait-in-eval-in-obsidian.cjs

@@ -0,0 +1,670 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var no_over_cap_wait_in_eval_in_obsidian_exports = {};
+__export(no_over_cap_wait_in_eval_in_obsidian_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  noOverCapWaitInEvalInObsidian: () => noOverCapWaitInEvalInObsidian
+});
+module.exports = __toCommonJS(no_over_cap_wait_in_eval_in_obsidian_exports);
+var import_ts_estree_node = require('@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node');
+var import_obsidian_integration_testing = require('obsidian-integration-testing');
+var import_performance_eval_cap = require('../../test-runners/performance-eval-cap.cjs');
+const MESSAGE_ID = "noOverCapWaitInEvalInObsidian";
+const WAIT_UNTIL_DEFAULT_TIMEOUT_IN_MILLISECONDS = 5e3;
+const INPUT_PROPERTY_NAME = "input";
+const SLEEP_CALLEE_NAME = "sleep";
+const TIMEOUT_PROPERTY_NAME = "timeoutInMilliseconds";
+const WAIT_UNTIL_CALLEE_NAME = "waitUntil";
+const CLOCK_OBJECT_NAMES = /* @__PURE__ */ new Set(["Date", "performance"]);
+const NOW_METHOD_NAME = "now";
+const CLOSURE_NAMES_BY_CALLEE_NAME = /* @__PURE__ */ new Map([
+  ["evalInObsidian", ["callback"]],
+  ["pollInObsidian", ["poll", "start"]]
+]);
+const noOverCapWaitInEvalInObsidian = {
+  create(context) {
+    const options = context.options[0];
+    const defaultCapInMilliseconds = context.filename.endsWith(import_performance_eval_cap.DESKTOP_PERFORMANCE_TEST_FILE_SUFFIX) ? import_performance_eval_cap.PERFORMANCE_EVAL_CAP_IN_MILLISECONDS : import_obsidian_integration_testing.DEFAULT_EVAL_CAP_IN_MILLISECONDS;
+    const capInMilliseconds = options?.capInMilliseconds ?? defaultCapInMilliseconds;
+    const callGraph = {
+      callCountByCalleeNodeByCallerNode: /* @__PURE__ */ new Map(),
+      stateByClosureNode: /* @__PURE__ */ new Map(),
+      waitInMillisecondsByFunctionNode: /* @__PURE__ */ new Map()
+    };
+    function addCall(target, calleeNode, callCount) {
+      const state = readClosureState(target);
+      state.functionNodes.add(calleeNode);
+      const callCountByCalleeNode = callGraph.callCountByCalleeNodeByCallerNode.get(target.functionNode) ?? /* @__PURE__ */ new Map();
+      callGraph.callCountByCalleeNodeByCallerNode.set(target.functionNode, callCountByCalleeNode);
+      callCountByCalleeNode.set(calleeNode, (callCountByCalleeNode.get(calleeNode) ?? 0) + callCount);
+    }
+    function addWait(target, waitInMilliseconds) {
+      readClosureState(target);
+      const runningTotalInMilliseconds = callGraph.waitInMillisecondsByFunctionNode.get(target.functionNode) ?? 0;
+      callGraph.waitInMillisecondsByFunctionNode.set(target.functionNode, runningTotalInMilliseconds + waitInMilliseconds);
+    }
+    function chargeHelperCall(callNode, target) {
+      const helperNode = readCalledHelperNode(callNode, target.closure, context);
+      if (!helperNode) {
+        return;
+      }
+      addCall(target, helperNode, readLoopMultiplier(callNode, target, context));
+    }
+    function chargeLoopDeadline(node) {
+      const loopNode = (0, import_ts_estree_node.toTSESTreeNode)(node);
+      const target = findChargeTarget(loopNode);
+      if (!target) {
+        return;
+      }
+      const deadlineInMilliseconds = readLoopDeadlineInMilliseconds(loopNode, target.closure, context);
+      if (deadlineInMilliseconds === null) {
+        return;
+      }
+      addWait(target, deadlineInMilliseconds * readLoopMultiplier(loopNode, target, context));
+    }
+    function chargeWaitCall(callNode, target) {
+      const budgetExpression = readWaitBudgetExpression(callNode);
+      if (budgetExpression === void 0) {
+        return;
+      }
+      const waitInMilliseconds = budgetExpression === null ? WAIT_UNTIL_DEFAULT_TIMEOUT_IN_MILLISECONDS : resolveNumber(budgetExpression, target.closure, context);
+      if (waitInMilliseconds === null) {
+        return;
+      }
+      addWait(target, waitInMilliseconds * readLoopMultiplier(callNode, target, context));
+    }
+    function readClosureState(target) {
+      const state = callGraph.stateByClosureNode.get(target.closure.closureNode) ?? {
+        closureNode: target.closure.closureNode,
+        functionNodes: /* @__PURE__ */ new Set(),
+        reportNode: target.closure.reportNode
+      };
+      callGraph.stateByClosureNode.set(target.closure.closureNode, state);
+      state.functionNodes.add(target.functionNode);
+      return state;
+    }
+    return {
+      "CallExpression"(node) {
+        const callNode = (0, import_ts_estree_node.toTSESTreeNode)(node);
+        const target = findChargeTarget(callNode);
+        if (!target) {
+          return;
+        }
+        chargeWaitCall(callNode, target);
+        chargeHelperCall(callNode, target);
+      },
+      DoWhileStatement: chargeLoopDeadline,
+      ForStatement: chargeLoopDeadline,
+      "Program:exit"() {
+        for (const state of callGraph.stateByClosureNode.values()) {
+          const totalInMilliseconds = readClosureWaitInMilliseconds(state, callGraph);
+          if (totalInMilliseconds < capInMilliseconds) {
+            continue;
+          }
+          context.report({
+            data: {
+              capInMilliseconds: String(capInMilliseconds),
+              totalInMilliseconds: String(totalInMilliseconds)
+            },
+            messageId: MESSAGE_ID,
+            node: state.reportNode
+          });
+        }
+      },
+      WhileStatement: chargeLoopDeadline
+    };
+  },
+  meta: {
+    docs: {
+      description: "Disallow an in-Obsidian closure declaring more waiting than the transport's script-timeout cap allows"
+    },
+    messages: {
+      [MESSAGE_ID]: "This closure declares {{ totalInMilliseconds }} ms of waiting, at or over the transport's {{ capInMilliseconds }} ms cap, so it can only ever die as a bare `script timeout`: wait in Node instead, with a short DOM-reading `pollInObsidian` `poll`, an `until` evaluated in Node, and the long budget in `timeoutInMilliseconds`."
+    },
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        capInMilliseconds: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      type: "object"
+    }],
+    type: "problem"
+  }
+};
+function collectReachableFunctionNodes(functionNode, callGraph, reachableNodes) {
+  if (reachableNodes.has(functionNode)) {
+    return;
+  }
+  reachableNodes.add(functionNode);
+  for (const calleeNode of callGraph.callCountByCalleeNodeByCallerNode.get(functionNode)?.keys() ?? []) {
+    collectReachableFunctionNodes(calleeNode, callGraph, reachableNodes);
+  }
+}
+function findChargeTarget(node) {
+  let innermostFunctionNode;
+  let currentNode = node.parent;
+  while (currentNode) {
+    const closure = readEvalClosure(currentNode);
+    if (closure) {
+      return {
+        closure,
+        functionNode: innermostFunctionNode ?? closure.closureNode
+      };
+    }
+    if (!innermostFunctionNode && isFunctionNode(currentNode)) {
+      innermostFunctionNode = currentNode;
+    }
+    currentNode = currentNode.parent;
+  }
+  return null;
+}
+function findVariable(scope, name) {
+  let currentScope = scope;
+  while (currentScope) {
+    const variable = currentScope.variables.find((candidate) => candidate.name === name);
+    if (variable) {
+      return variable;
+    }
+    currentScope = currentScope.upper;
+  }
+  return null;
+}
+function isAssignmentExpression(node) {
+  return node.type === "AssignmentExpression";
+}
+function isBinaryExpression(node) {
+  return node.type === "BinaryExpression";
+}
+function isCallExpression(node) {
+  return node.type === "CallExpression";
+}
+function isClosureFunction(node) {
+  return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function isDeclaredInsideClosure(functionNode, closure) {
+  let currentNode = functionNode.parent;
+  while (currentNode) {
+    if (currentNode === closure.closureNode) {
+      return true;
+    }
+    currentNode = currentNode.parent;
+  }
+  return false;
+}
+function isForStatement(node) {
+  return node.type === "ForStatement";
+}
+function isFunctionNode(node) {
+  return isClosureFunction(node) || node.type === "FunctionDeclaration";
+}
+function isIdentifier(node) {
+  return node.type === "Identifier";
+}
+function isLogicalAndExpression(node) {
+  return node.type === "LogicalExpression" && node.operator === "&&";
+}
+function isLoopStatement(node) {
+  return node.type === "WhileStatement" || node.type === "DoWhileStatement" || isForStatement(node);
+}
+function isMemberExpression(node) {
+  return node.type === "MemberExpression";
+}
+function isNumericLiteral(node) {
+  return node.type === "Literal" && typeof node.value === "number";
+}
+function isObjectExpression(node) {
+  return node.type === "ObjectExpression";
+}
+function isObjectPattern(node) {
+  return node.type === "ObjectPattern";
+}
+function isProperty(node) {
+  return node.type === "Property";
+}
+function isUpdateExpression(node) {
+  return node.type === "UpdateExpression";
+}
+function isVariableDeclaration(node) {
+  return node.type === "VariableDeclaration";
+}
+function isVariableDeclarator(node) {
+  return node.type === "VariableDeclarator";
+}
+function readBoundExpression(node, closure, context) {
+  const variable = findVariable(context.sourceCode.getScope(node), node.name);
+  if (!variable) {
+    return null;
+  }
+  for (const definition of variable.defs) {
+    const definitionNode = (0, import_ts_estree_node.toTSESTreeNode)(definition.node);
+    if (isVariableDeclarator(definitionNode) && definitionNode.init) {
+      return definitionNode.init;
+    }
+    if (definitionNode === closure.closureNode) {
+      const inputKey = readParameterInputKey(closure.closureNode, node.name);
+      return inputKey === null ? null : readInputPropertyValue(closure.paramsNode, inputKey);
+    }
+  }
+  return null;
+}
+function readCalledHelperNode(callNode, closure, context) {
+  const calleeNode = callNode.callee;
+  if (!isIdentifier(calleeNode)) {
+    return null;
+  }
+  const variable = findVariable(context.sourceCode.getScope(calleeNode), calleeNode.name);
+  if (!variable) {
+    return null;
+  }
+  for (const definition of variable.defs) {
+    const functionNode = readDefinitionFunctionNode((0, import_ts_estree_node.toTSESTreeNode)(definition.node));
+    if (functionNode && isDeclaredInsideClosure(functionNode, closure)) {
+      return functionNode;
+    }
+  }
+  return null;
+}
+function readCallGraphWaitInMilliseconds(functionNode, callGraph, visitedNodes) {
+  if (visitedNodes.has(functionNode)) {
+    return 0;
+  }
+  visitedNodes.add(functionNode);
+  let totalInMilliseconds = callGraph.waitInMillisecondsByFunctionNode.get(functionNode) ?? 0;
+  for (const [calleeNode, callCount] of callGraph.callCountByCalleeNodeByCallerNode.get(functionNode) ?? []) {
+    totalInMilliseconds += callCount * readCallGraphWaitInMilliseconds(calleeNode, callGraph, visitedNodes);
+  }
+  visitedNodes.delete(functionNode);
+  return totalInMilliseconds;
+}
+function readClockName(node) {
+  if (!isCallExpression(node) || node.arguments.length > 0) {
+    return null;
+  }
+  const calleeNode = node.callee;
+  if (!isMemberExpression(calleeNode) || calleeNode.computed) {
+    return null;
+  }
+  const objectNode = calleeNode.object;
+  const propertyNode = calleeNode.property;
+  return !isIdentifier(objectNode) || !isIdentifier(propertyNode) || propertyNode.name !== NOW_METHOD_NAME || !CLOCK_OBJECT_NAMES.has(objectNode.name) ? null : objectNode.name;
+}
+function readClosureNames(callNode) {
+  return isIdentifier(callNode.callee) ? CLOSURE_NAMES_BY_CALLEE_NAME.get(callNode.callee.name) ?? null : null;
+}
+function readClosureWaitInMilliseconds(state, callGraph) {
+  const reachableNodes = /* @__PURE__ */ new Set();
+  collectReachableFunctionNodes(state.closureNode, callGraph, reachableNodes);
+  let totalInMilliseconds = readCallGraphWaitInMilliseconds(state.closureNode, callGraph, /* @__PURE__ */ new Set());
+  for (const functionNode of state.functionNodes) {
+    const ownWaitInMilliseconds = callGraph.waitInMillisecondsByFunctionNode.get(functionNode);
+    if (ownWaitInMilliseconds === void 0 || reachableNodes.has(functionNode)) {
+      continue;
+    }
+    totalInMilliseconds += ownWaitInMilliseconds;
+  }
+  return totalInMilliseconds;
+}
+function readConjuncts(node) {
+  return isLogicalAndExpression(node) ? [...readConjuncts(node.left), ...readConjuncts(node.right)] : [node];
+}
+function readDeadlineGuardInMilliseconds(node, closure, context) {
+  if (!isBinaryExpression(node)) {
+    return null;
+  }
+  const isClockOnLeft = node.operator === "<" || node.operator === "<=";
+  if (!isClockOnLeft && node.operator !== ">" && node.operator !== ">=") {
+    return null;
+  }
+  const clockName = readClockName(isClockOnLeft ? node.left : node.right);
+  const deadlineNode = isClockOnLeft ? node.right : node.left;
+  if (clockName === null || !isIdentifier(deadlineNode)) {
+    return null;
+  }
+  const boundNode = readBoundExpression(deadlineNode, closure, context);
+  return !boundNode || !isBinaryExpression(boundNode) || boundNode.operator !== "+" || readClockName(boundNode.left) !== clockName ? null : resolveNumber(boundNode.right, closure, context);
+}
+function readDefinitionFunctionNode(definitionNode) {
+  if (isFunctionNode(definitionNode)) {
+    return definitionNode;
+  }
+  if (!isVariableDeclarator(definitionNode) || !definitionNode.init) {
+    return null;
+  }
+  const initNode = definitionNode.init;
+  return isFunctionNode(initNode) ? initNode : null;
+}
+function readEvalClosure(node) {
+  if (!isClosureFunction(node)) {
+    return null;
+  }
+  const propertyNode = node.parent;
+  if (!isProperty(propertyNode)) {
+    return null;
+  }
+  const paramsNode = propertyNode.parent;
+  if (!isObjectExpression(paramsNode) || !isIdentifier(propertyNode.key)) {
+    return null;
+  }
+  const callNode = paramsNode.parent;
+  if (!isCallExpression(callNode) || callNode.arguments[0] !== paramsNode) {
+    return null;
+  }
+  const closureNames = readClosureNames(callNode);
+  return closureNames?.includes(propertyNode.key.name) ? {
+    closureNode: node,
+    paramsNode,
+    reportNode: propertyNode
+  } : null;
+}
+function readInputPropertyValue(paramsNode, keyName) {
+  const inputProperty = paramsNode.properties.find(
+    (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === INPUT_PROPERTY_NAME
+  );
+  const inputNode = inputProperty?.value;
+  if (!inputNode || !isObjectExpression(inputNode)) {
+    return null;
+  }
+  const valueProperty = inputNode.properties.find(
+    (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === keyName
+  );
+  return valueProperty?.value ?? null;
+}
+function readLoopDeadlineInMilliseconds(loopNode, closure, context) {
+  if (!loopNode.test) {
+    return null;
+  }
+  for (const conjunct of readConjuncts(loopNode.test)) {
+    const deadlineInMilliseconds = readDeadlineGuardInMilliseconds(conjunct, closure, context);
+    if (deadlineInMilliseconds !== null) {
+      return deadlineInMilliseconds;
+    }
+  }
+  return null;
+}
+function readLoopExclusiveBound(testNode, counterName, closure, context) {
+  for (const conjunct of readConjuncts(testNode)) {
+    if (!isBinaryExpression(conjunct) || conjunct.operator !== "<" && conjunct.operator !== "<=") {
+      continue;
+    }
+    const counterNode = conjunct.left;
+    if (!isIdentifier(counterNode) || counterNode.name !== counterName) {
+      continue;
+    }
+    const boundValue = resolveNumber(conjunct.right, closure, context);
+    if (boundValue === null) {
+      continue;
+    }
+    return conjunct.operator === "<" ? boundValue : boundValue + 1;
+  }
+  return null;
+}
+function readLoopIterationCount(loopNode, closure, context) {
+  if (!isForStatement(loopNode) || !loopNode.test || !loopNode.init || !isVariableDeclaration(loopNode.init)) {
+    return null;
+  }
+  const declaratorNodes = loopNode.init.declarations;
+  const declaratorNode = declaratorNodes.length === 1 ? declaratorNodes[0] : void 0;
+  if (!declaratorNode?.init || !isIdentifier(declaratorNode.id)) {
+    return null;
+  }
+  const startValue = resolveNumber(declaratorNode.init, closure, context);
+  const stepSize = readLoopStepSize(loopNode.update, declaratorNode.id, closure, context);
+  const boundValue = readLoopExclusiveBound(loopNode.test, declaratorNode.id.name, closure, context);
+  if (startValue === null || stepSize === null || stepSize <= 0 || boundValue === null) {
+    return null;
+  }
+  const span = boundValue - startValue;
+  return span > 0 ? Math.ceil(span / stepSize) : 0;
+}
+function readLoopMultiplier(node, target, context) {
+  const closure = target.closure;
+  let multiplier = 1;
+  let currentNode = node.parent;
+  while (currentNode && currentNode !== target.functionNode) {
+    if (isLoopStatement(currentNode) && readLoopDeadlineInMilliseconds(currentNode, closure, context) === null) {
+      const iterationCount = readLoopIterationCount(currentNode, closure, context);
+      if (iterationCount !== null) {
+        multiplier *= iterationCount;
+      }
+    }
+    currentNode = currentNode.parent;
+  }
+  return multiplier;
+}
+function readLoopStepSize(updateNode, counterNode, closure, context) {
+  if (!updateNode) {
+    return null;
+  }
+  if (isUpdateExpression(updateNode)) {
+    const argumentNode = updateNode.argument;
+    return updateNode.operator === "++" && isIdentifier(argumentNode) && argumentNode.name === counterNode.name ? 1 : null;
+  }
+  if (!isAssignmentExpression(updateNode) || updateNode.operator !== "+=") {
+    return null;
+  }
+  const targetNode = updateNode.left;
+  return !isIdentifier(targetNode) || targetNode.name !== counterNode.name ? null : resolveNumber(updateNode.right, closure, context);
+}
+function readParameterInputKey(closureNode, localName) {
+  for (const parameterNode of closureNode.params) {
+    if (!isObjectPattern(parameterNode)) {
+      continue;
+    }
+    for (const property of parameterNode.properties) {
+      if (!isProperty(property) || property.computed || !isIdentifier(property.key) || !isIdentifier(property.value)) {
+        continue;
+      }
+      if (property.value.name === localName) {
+        return property.key.name;
+      }
+    }
+  }
+  return null;
+}
+function readWaitBudgetExpression(callNode) {
+  if (!isIdentifier(callNode.callee)) {
+    return void 0;
+  }
+  const calleeName = callNode.callee.name;
+  if (calleeName === SLEEP_CALLEE_NAME) {
+    return callNode.arguments[0] ?? void 0;
+  }
+  if (calleeName !== WAIT_UNTIL_CALLEE_NAME) {
+    return void 0;
+  }
+  const paramsNode = callNode.arguments[0];
+  if (!paramsNode || !isObjectExpression(paramsNode)) {
+    return void 0;
+  }
+  const timeoutProperty = paramsNode.properties.find(
+    (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === TIMEOUT_PROPERTY_NAME
+  );
+  return timeoutProperty?.value ?? null;
+}
+function resolveNumber(node, closure, context) {
+  const visitedNodes = /* @__PURE__ */ new Set();
+  let currentNode = node;
+  while (!visitedNodes.has(currentNode)) {
+    visitedNodes.add(currentNode);
+    if (isNumericLiteral(currentNode)) {
+      return currentNode.value;
+    }
+    if (isBinaryExpression(currentNode) && currentNode.operator === "*") {
+      const leftValue = resolveNumber(currentNode.left, closure, context);
+      const rightValue = resolveNumber(currentNode.right, closure, context);
+      return leftValue === null || rightValue === null ? null : leftValue * rightValue;
+    }
+    if (!isIdentifier(currentNode)) {
+      return null;
+    }
+    const boundNode = readBoundExpression(currentNode, closure, context);
+    if (!boundNode) {
+      return null;
+    }
+    currentNode = boundNode;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ID,
+  noOverCapWaitInEvalInObsidian
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/no-over-cap-wait-in-eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: no-over-cap-wait-in-eval-in-obsidian\n *\n * Reports an `evalInObsidian` / `pollInObsidian` closure that declares more waiting\n * than the transport can ever honour.\n *\n * A single closure is evaluated through one transport call, and that call is capped at\n * roughly 30 seconds \u2014 Appium surfaces the cap as a bare `WebDriverError: script timeout`\n * naming only `AppiumTransport.evaluate`, CDP as a command timeout. Neither names the wait\n * that actually blew the budget, so the failure reads as a broken device rather than as a\n * closure asking for more time than exists. That misdiagnosis cost two days.\n *\n * The cap the rule assumes when `capInMilliseconds` is not configured is\n * `DEFAULT_EVAL_CAP_IN_MILLISECONDS`, imported from `obsidian-integration-testing` \u2014 the same constant\n * both of its transports enforce, so the rule cannot drift from the thing it is predicting. That import\n * is why the harness is a required peer of this library rather than an optional one: the shared ESLint\n * config loads this rule, so every consuming repo resolves it at lint time.\n *\n * ONE KIND OF FILE DEFAULTS HIGHER: a `*.desktop-performance.integration.test.ts` is measured against\n * `PERFORMANCE_EVAL_CAP_IN_MILLISECONDS` (600 000), the per-eval cap the shared vitest config gives the\n * `integration-tests:desktop-performance` project, imported from that same module rather than restated.\n * That raise is a deliberate BUDGET: a perf suite's measurement is one long in-page evaluation, and its\n * files run on no other project. Every other file keeps the single transport default, and that is the\n * convention rather than a gap: a repo that raises its own desktop `commandTimeoutInMilliseconds` is\n * setting a backstop, NOT a budget a closure may spend, so the rule does not read that raise and keeps\n * enforcing 30 000 against it. A cross-platform suite could not spend it anyway: Appium caps every\n * closure at 30 000 whatever a desktop raise says. An explicit `capInMilliseconds` still overrides both\n * defaults, for every file the rule is configured on.\n *\n * A closure declaring a 30 000 ms `waitUntil`, or two 20 000 ms ones, therefore cannot\n * succeed on any machine slow enough to need the time it asks for. The fix is to move the\n * waiting to Node: `pollInObsidian` runs a SHORT DOM-reading `poll` closure repeatedly,\n * evaluates `until` in Node, and carries the long budget in `timeoutInMilliseconds`, so no\n * single transport call is ever long.\n *\n * WHAT COUNTS toward a closure's budget, summed lexically: every `waitUntil` inside it \u2014\n * taking the helper's documented 5 000 ms default when `timeoutInMilliseconds` is omitted,\n * which is what makes several small sibling waits add up honestly \u2014 plus every `sleep(n)`\n * settle. Waits inside a helper declared within the closure count too; the enclosing\n * closure is found by walking outwards, so a nested function attributes to the closure it\n * runs inside -- once per CALL SITE, per the HELPERS paragraph below.\n *\n * WHAT DOES NOT. A budget that cannot be resolved to a number contributes nothing and is\n * never reported (owner, 2026-09-09). Scope analysis resolves the shapes that actually\n * occur \u2014 a literal, a `const` in any enclosing scope, and a destructured callback\n * parameter followed back through the call's own `input` object \u2014 and resolving through\n * scope rather than by regex is the whole reason this is a rule and not a script. But a\n * value arriving from a caller (`options.timeout ?? DEFAULT`, threaded through a\n * parameter) would need analysis across call boundaries, and reporting every such site would\n * make each legitimately parameterized helper red across thirty repos.\n *\n * LOOPS were once out of scope wholesale, on the reasoning that a `sleep` in a `while` has no\n * statically declared ceiling. That is true of `while (true)` and false of the loop these\n * suites actually write, which declares its ceiling as plainly as any literal timeout \u2014 and\n * leaving them all out hid 22 over-cap closures across six repos, one of them ten times over.\n * Two shapes are read now, both through the same scope walk a budget uses:\n *\n * - A DEADLINE loop \u2014 `const deadline = Date.now() + BUDGET`, guarded by `Date.now() < deadline` \u2014\n *   cannot run longer than `BUDGET` whatever its poll interval, so `BUDGET` is charged to the\n *   closure ONCE per loop, on top of the single iteration its inner waits are already charged\n *   (a poll that starts just under the deadline still runs to completion, so the sum of the two\n *   is the honest worst case rather than a double count). `performance.now()` counts as well as\n *   `Date.now()`: a `performance`-written deadline read as unbounded is why one 245 025 ms\n *   closure was absent from every roster produced before this.\n * - A COUNTING `for` \u2014 `for (let attempt = 0; attempt < ATTEMPTS; attempt++)` \u2014 multiplies every\n *   wait inside it by its iteration count, read from the loop's own start, bound and step.\n *\n * Either ceiling may be ONE CONJUNCT of a compound test (`while (count < expected && Date.now() < deadline)`,\n * `for (let attempt = 0; attempt < ATTEMPTS && !isOpen; attempt++)`), which is how both are actually\n * written: a progress condition beside the guard does not remove the ceiling the other conjunct declares.\n *\n * Anything else keeps the old per-iteration charge rather than a guess \u2014 `while (true)`, a `for\u2026of`,\n * a bound or deadline that does not resolve \u2014 which is what keeps a genuinely unbounded loop silent.\n *\n * A HELPER declared inside the closure is charged once per CALL SITE, which is how many times its waiting\n * actually runs. Its own waits are summed once and multiplied by the calls that reach it, each call\n * carrying the counting loops it is itself written inside \u2014 so a local `waitUntil(check)` of\n * `for (attempt < 40) await sleep(250)` called three times declares 30 000 ms rather than the 10 000 ms a\n * single attribution reported. Three bounds keep that honest:\n *\n * - A helper declared OUTSIDE the closure stays out of scope, for the same reason a budget arriving from\n *   a caller is: reading it needs analysis across call boundaries, and widening there would make every\n *   legitimately parameterized helper in every consuming repo red.\n * - RECURSION terminates by charging a re-entered helper nothing, so neither a self-call nor a mutually\n *   recursive pair is charged forever. A recursive call contributes the silence an unbounded loop does.\n * - A helper the closure never REACHES \u2014 dead, or called through something this rule cannot resolve, such\n *   as a bare reference handed to `forEach` \u2014 keeps the flat single charge it has always had. So no\n *   closure this rule reports today falls silent because a call site could not be read.\n *\n * What the per-call-site count does NOT fix is a BRANCHY helper: an `if` / `else` is summed lexically like\n * any two sibling waits, so both arms are charged at every call site. A helper whose two directions wait\n * differently is therefore better written as two helpers, which is what this repo's own\n * `src/obsidian/components/syntax-highlighting-component.obsidian.integration.test.ts` now does.\n *\n * Not every over-cap closure can become a `poll` / `until` pair, so the rule is meant to be\n * disabled \u2014 with a reason \u2014 at the sites that have one. `require-description` makes that\n * reason mandatory, which is the point: it turns an invisible assumption into a written one.\n *\n * A CLOSURE DELIBERATELY LEFT UNDER THE CAP SAYS SO, in a comment opening with the exact line\n *\n *     Under the transport's ~30s per-closure cap, not at it.\n *\n * and then saying, for that closure, what the budget is made of and why it stays. This rule is silent\n * on such a closure by construction \u2014 it is under the cap \u2014 so without the line there is no way to tell\n * a budget somebody read and kept from one nobody has looked at, and a sweep run with a lower\n * `capInMilliseconds` re-opens the same decisions every time. The line is the whole of the convention,\n * which is what lets such a sweep subtract the closures already read and drive the remainder to zero.\n *\n * Two placements, because a ceiling lives in two places. A comment INSIDE the closure, over that\n * closure's own ceiling constant, speaks for that closure alone; one at MODULE scope, over a constant\n * the whole file shares, speaks for every closure in the file. A closure with no ceiling constant at\n * all \u2014 several `waitUntil` calls taking the documented default \u2014 takes the in-closure form at the top\n * of its body.\n *\n * Saying it is NOT the same as clearing it. A budget under the cap is not a defect, and \"read, and left\n * as it is\" is a correct outcome: tightening a ceiling to bring a number down is how a suite starts\n * failing legitimately on a cold machine.\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type {\n  Rule,\n  Scope\n} from 'eslint';\n\nimport { toTSESTreeNode } from '@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node';\nimport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from 'obsidian-integration-testing';\n\nimport {\n  DESKTOP_PERFORMANCE_TEST_FILE_SUFFIX,\n  PERFORMANCE_EVAL_CAP_IN_MILLISECONDS\n} from '../../test-runners/performance-eval-cap.ts';\n\n/**\n * Message ID reported when an in-Obsidian closure declares more waiting than the transport's cap allows.\n */\nexport const MESSAGE_ID = 'noOverCapWaitInEvalInObsidian';\n\n/**\n * The budget a `waitUntil` takes when it omits `timeoutInMilliseconds`, per `WaitUntilParams`.\n */\nconst WAIT_UNTIL_DEFAULT_TIMEOUT_IN_MILLISECONDS = 5000;\n\nconst INPUT_PROPERTY_NAME = 'input';\nconst SLEEP_CALLEE_NAME = 'sleep';\nconst TIMEOUT_PROPERTY_NAME = 'timeoutInMilliseconds';\nconst WAIT_UNTIL_CALLEE_NAME = 'waitUntil';\n\n/**\n * The clocks a deadline may be taken from. Both occur in these suites, and a rule that knew only `Date`\n * read every `performance`-written deadline as unbounded.\n */\nconst CLOCK_OBJECT_NAMES = new Set(['Date', 'performance']);\n\nconst NOW_METHOD_NAME = 'now';\n\n/**\n * Which properties of each helper's parameter object hold a closure that runs INSIDE Obsidian, and is\n * therefore subject to the cap. `pollInObsidian`'s `until` is deliberately absent: it is evaluated in\n * Node, which is the entire point of converting to it.\n */\nconst CLOSURE_NAMES_BY_CALLEE_NAME = new Map<string, readonly string[]>([\n  ['evalInObsidian', ['callback']],\n  ['pollInObsidian', ['poll', 'start']]\n]);\n\n/**\n * Everything one file accumulated, keyed by the function each charge was written inside.\n *\n * A wait is charged to the innermost function it is written in rather than straight to the closure, and a\n * call to a helper the closure declares is recorded as an edge, so a closure's total is its own waiting\n * plus each helper's waiting multiplied by the calls that actually reach it.\n */\ninterface CallGraph {\n  /**\n   * How many times each function calls each helper declared inside the same closure.\n   */\n  readonly callCountByCalleeNodeByCallerNode: Map<HelperFunction, Map<HelperFunction, number>>;\n\n  /**\n   * The closures seen so far, by the function node each one is written as.\n   */\n  readonly stateByClosureNode: Map<ClosureFunction, ClosureState>;\n\n  /**\n   * The waiting written DIRECTLY inside each function, excluding whatever the helpers it calls declare.\n   */\n  readonly waitInMillisecondsByFunctionNode: Map<HelperFunction, number>;\n}\n\n/**\n * The rule's single option object.\n */\ninterface CapOptions {\n  /**\n   * The budget at or over which a closure is reported, in milliseconds.\n   */\n  readonly capInMilliseconds?: number;\n}\n\n/**\n * The function a charge is attributed to, together with the in-Obsidian closure it ultimately runs inside.\n */\ninterface ChargeTarget {\n  /**\n   * The closure the charge runs inside, carried so a budget threaded through its call still resolves.\n   */\n  readonly closure: EvalClosure;\n\n  /**\n   * The innermost function the charge is written in: the closure itself, or a helper declared within it.\n   */\n  readonly functionNode: HelperFunction;\n}\n\n/**\n * A function written as an object property, which is the only form either helper's closures take.\n */\ntype ClosureFunction = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;\n\n/**\n * One in-Obsidian closure's accumulated charges.\n */\ninterface ClosureState {\n  /**\n   * The closure's own function node, the root every reachable helper is counted from.\n   */\n  readonly closureNode: ClosureFunction;\n\n  /**\n   * Every function charged inside this closure: the closure itself, and each helper it declares.\n   */\n  readonly functionNodes: Set<HelperFunction>;\n\n  /**\n   * The property the closure is written as, reported on.\n   */\n  readonly reportNode: TSESTree.Node;\n}\n\n/**\n * An in-Obsidian closure, together with the call it belongs to (needed to resolve a budget threaded\n * through that call's `input`) and the node to report on.\n */\ninterface EvalClosure {\n  /**\n   * The closure's function node, which identifies the closure across sibling waits and carries the\n   * parameter pattern a budget threaded through `input` is destructured by.\n   */\n  readonly closureNode: ClosureFunction;\n\n  /**\n   * The helper's parameter object, carried so a budget threaded through `input` is read from the object\n   * the closure was already found in rather than re-derived from the call.\n   */\n  readonly paramsNode: TSESTree.ObjectExpression;\n\n  /**\n   * The property the closure is written as, reported on so the message points at `callback` / `poll`\n   * rather than at whichever wait happened to come first.\n   */\n  readonly reportNode: TSESTree.Node;\n}\n\n/**\n * A function waiting can be charged to: an in-Obsidian closure, or a helper declared inside one \u2014 which a\n * `function` declaration is as readily as an arrow or a function expression.\n */\ntype HelperFunction = ClosureFunction | TSESTree.FunctionDeclaration;\n\n/**\n * A loop whose own test can declare a ceiling. `for\u2026of` / `for\u2026in` are deliberately absent: neither\n * declares one statically, so both keep the per-iteration charge every unsized loop gets.\n */\ntype LoopStatement = TSESTree.DoWhileStatement | TSESTree.ForStatement | TSESTree.WhileStatement;\n\n/**\n * ESLint rule disallowing an in-Obsidian closure whose declared waiting exceeds the transport's script-timeout cap.\n */\nexport const noOverCapWaitInEvalInObsidian: Rule.RuleModule = {\n  create(context) {\n    const options = context.options[0] as CapOptions | undefined;\n    const defaultCapInMilliseconds = context.filename.endsWith(DESKTOP_PERFORMANCE_TEST_FILE_SUFFIX)\n      ? PERFORMANCE_EVAL_CAP_IN_MILLISECONDS\n      : DEFAULT_EVAL_CAP_IN_MILLISECONDS;\n    const capInMilliseconds = options?.capInMilliseconds ?? defaultCapInMilliseconds;\n    const callGraph: CallGraph = {\n      callCountByCalleeNodeByCallerNode: new Map<HelperFunction, Map<HelperFunction, number>>(),\n      stateByClosureNode: new Map<ClosureFunction, ClosureState>(),\n      waitInMillisecondsByFunctionNode: new Map<HelperFunction, number>()\n    };\n\n    /**\n     * Records that one function calls a helper declared inside the same closure.\n     *\n     * @param target - The function the call is written in.\n     * @param calleeNode - The helper being called.\n     * @param callCount - How many times the call runs, as the product of its enclosing counting loops.\n     */\n    function addCall(target: ChargeTarget, calleeNode: HelperFunction, callCount: number): void {\n      const state = readClosureState(target);\n      state.functionNodes.add(calleeNode);\n\n      const callCountByCalleeNode = callGraph.callCountByCalleeNodeByCallerNode.get(target.functionNode)\n        ?? new Map<HelperFunction, number>();\n      callGraph.callCountByCalleeNodeByCallerNode.set(target.functionNode, callCountByCalleeNode);\n      callCountByCalleeNode.set(calleeNode, (callCountByCalleeNode.get(calleeNode) ?? 0) + callCount);\n    }\n\n    /**\n     * Adds waiting to the running total of the function it was written in.\n     *\n     * @param target - The function to charge.\n     * @param waitInMilliseconds - The waiting to add.\n     */\n    function addWait(target: ChargeTarget, waitInMilliseconds: number): void {\n      readClosureState(target);\n      const runningTotalInMilliseconds = callGraph.waitInMillisecondsByFunctionNode.get(target.functionNode) ?? 0;\n      callGraph.waitInMillisecondsByFunctionNode.set(target.functionNode, runningTotalInMilliseconds + waitInMilliseconds);\n    }\n\n    /**\n     * Records a call to a helper the closure declares, so its waiting is counted once per call site.\n     *\n     * @param callNode - The call expression.\n     * @param target - The function the call is written in.\n     */\n    function chargeHelperCall(callNode: TSESTree.CallExpression, target: ChargeTarget): void {\n      const helperNode = readCalledHelperNode(callNode, target.closure, context);\n      if (!helperNode) {\n        return;\n      }\n\n      addCall(target, helperNode, readLoopMultiplier(callNode, target, context));\n    }\n\n    /**\n     * Charges a deadline-bounded loop its whole deadline, once.\n     *\n     * @param node - The loop statement.\n     */\n    function chargeLoopDeadline(node: Rule.Node): void {\n      const loopNode = toTSESTreeNode(node) as LoopStatement;\n\n      const target = findChargeTarget(loopNode);\n      if (!target) {\n        return;\n      }\n\n      const deadlineInMilliseconds = readLoopDeadlineInMilliseconds(loopNode, target.closure, context);\n      if (deadlineInMilliseconds === null) {\n        return;\n      }\n\n      addWait(target, deadlineInMilliseconds * readLoopMultiplier(loopNode, target, context));\n    }\n\n    /**\n     * Charges a wait call the budget it declares.\n     *\n     * @param callNode - The call expression.\n     * @param target - The function the call is written in.\n     */\n    function chargeWaitCall(callNode: TSESTree.CallExpression, target: ChargeTarget): void {\n      const budgetExpression = readWaitBudgetExpression(callNode);\n      if (budgetExpression === undefined) {\n        return;\n      }\n\n      const waitInMilliseconds = budgetExpression === null\n        ? WAIT_UNTIL_DEFAULT_TIMEOUT_IN_MILLISECONDS\n        : resolveNumber(budgetExpression, target.closure, context);\n      if (waitInMilliseconds === null) {\n        return;\n      }\n\n      addWait(target, waitInMilliseconds * readLoopMultiplier(callNode, target, context));\n    }\n\n    /**\n     * Registers the closure a charge belongs to, and the function the charge was written in.\n     *\n     * @param target - The function being charged.\n     * @returns That closure's accumulated state.\n     */\n    function readClosureState(target: ChargeTarget): ClosureState {\n      const state = callGraph.stateByClosureNode.get(target.closure.closureNode) ?? {\n        closureNode: target.closure.closureNode,\n        functionNodes: new Set<HelperFunction>(),\n        reportNode: target.closure.reportNode\n      };\n      callGraph.stateByClosureNode.set(target.closure.closureNode, state);\n      state.functionNodes.add(target.functionNode);\n      return state;\n    }\n\n    return {\n      'CallExpression'(node: Rule.Node): void {\n        const callNode = toTSESTreeNode(node) as TSESTree.CallExpression;\n\n        const target = findChargeTarget(callNode);\n        if (!target) {\n          return;\n        }\n\n        chargeWaitCall(callNode, target);\n        chargeHelperCall(callNode, target);\n      },\n      DoWhileStatement: chargeLoopDeadline,\n      ForStatement: chargeLoopDeadline,\n      'Program:exit'(): void {\n        for (const state of callGraph.stateByClosureNode.values()) {\n          const totalInMilliseconds = readClosureWaitInMilliseconds(state, callGraph);\n          if (totalInMilliseconds < capInMilliseconds) {\n            continue;\n          }\n\n          context.report({\n            data: {\n              capInMilliseconds: String(capInMilliseconds),\n              totalInMilliseconds: String(totalInMilliseconds)\n            },\n            messageId: MESSAGE_ID,\n            node: state.reportNode\n          });\n        }\n      },\n      WhileStatement: chargeLoopDeadline\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Disallow an in-Obsidian closure declaring more waiting than the transport\\'s script-timeout cap allows'\n    },\n    messages: {\n      [MESSAGE_ID]: 'This closure declares {{ totalInMilliseconds }} ms of waiting, at or over the transport\\'s {{ capInMilliseconds }} ms cap, so it can only ever die as a bare `script timeout`: wait in Node instead, with a short DOM-reading `pollInObsidian` `poll`, an `until` evaluated in Node, and the long budget in `timeoutInMilliseconds`.'\n    },\n    schema: [{\n      additionalProperties: false,\n      properties: {\n        capInMilliseconds: {\n          minimum: 1,\n          type: 'integer'\n        }\n      },\n      type: 'object'\n    }],\n    type: 'problem'\n  }\n};\n\n/**\n * Collects every helper reachable from a function by following the calls recorded for its closure.\n *\n * A helper NOT in the answer is one no call site can reach, which is what the flat fallback charge is\n * keyed off: it is either dead, or called through something this rule cannot read.\n *\n * @param functionNode - The function to start from.\n * @param callGraph - The file's accumulated charges.\n * @param reachableNodes - The set to collect into, which doubles as the visited set.\n */\nfunction collectReachableFunctionNodes(functionNode: HelperFunction, callGraph: CallGraph, reachableNodes: Set<HelperFunction>): void {\n  if (reachableNodes.has(functionNode)) {\n    return;\n  }\n\n  reachableNodes.add(functionNode);\n\n  for (const calleeNode of callGraph.callCountByCalleeNodeByCallerNode.get(functionNode)?.keys() ?? []) {\n    collectReachableFunctionNodes(calleeNode, callGraph, reachableNodes);\n  }\n}\n\n/**\n * Finds the function a node's waiting is charged to, walking outwards.\n *\n * The walk does not stop at the first enclosing function: a wait inside a helper declared within the\n * callback still runs inside the callback, so it keeps going until it reaches a function that IS one of\n * the helper's in-Obsidian closures. What it REMEMBERS on the way is the innermost function it passed, so\n * a helper's waiting is accumulated against the helper and charged to the closure once per call site.\n *\n * @param node - The node to start from.\n * @returns The charge target, or `null` when the node does not run inside an in-Obsidian closure.\n */\nfunction findChargeTarget(node: TSESTree.Node): ChargeTarget | null {\n  let innermostFunctionNode: HelperFunction | undefined;\n  let currentNode: TSESTree.Node | undefined = node.parent;\n\n  while (currentNode) {\n    const closure = readEvalClosure(currentNode);\n    if (closure) {\n      return {\n        closure,\n        functionNode: innermostFunctionNode ?? closure.closureNode\n      };\n    }\n\n    if (!innermostFunctionNode && isFunctionNode(currentNode)) {\n      innermostFunctionNode = currentNode;\n    }\n\n    currentNode = currentNode.parent;\n  }\n\n  return null;\n}\n\n/**\n * Finds a variable by name, walking outwards from the given scope.\n *\n * @param scope - The scope to start from.\n * @param name - The variable's name.\n * @returns The variable, or `null` when nothing in scope declares that name.\n */\nfunction findVariable(scope: Scope.Scope, name: string): null | Scope.Variable {\n  let currentScope: null | Scope.Scope = scope;\n\n  while (currentScope) {\n    const variable = currentScope.variables.find((candidate) => candidate.name === name);\n    if (variable) {\n      return variable;\n    }\n    currentScope = currentScope.upper;\n  }\n\n  return null;\n}\n\n/**\n * Checks whether a node is an assignment expression.\n *\n * @param node - The node to check.\n * @returns `true` if the node is an `AssignmentExpression`.\n */\nfunction isAssignmentExpression(node: TSESTree.Node): node is TSESTree.AssignmentExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'AssignmentExpression';\n}\n\n/**\n * Checks whether a node is a binary expression.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `BinaryExpression`.\n */\nfunction isBinaryExpression(node: TSESTree.Node): node is TSESTree.BinaryExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'BinaryExpression';\n}\n\n/**\n * Checks whether a node is a call expression.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `CallExpression`.\n */\nfunction isCallExpression(node: TSESTree.Node): node is TSESTree.CallExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'CallExpression';\n}\n\n/**\n * Checks whether a node is a function written as an object property's value.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `FunctionExpression` or an `ArrowFunctionExpression`.\n */\nfunction isClosureFunction(node: TSESTree.Node): node is ClosureFunction {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';\n}\n\n/**\n * Checks whether a function is declared somewhere inside an in-Obsidian closure.\n *\n * A helper declared OUTSIDE the closure answers `false`, which is what keeps this rule's analysis inside\n * one closure rather than following calls across boundaries it deliberately declines to read.\n *\n * @param functionNode - The function to check.\n * @param closure - The closure to check against.\n * @returns `true` when the function is declared lexically inside the closure.\n */\nfunction isDeclaredInsideClosure(functionNode: HelperFunction, closure: EvalClosure): boolean {\n  let currentNode: TSESTree.Node | undefined = functionNode.parent;\n\n  while (currentNode) {\n    if (currentNode === closure.closureNode) {\n      return true;\n    }\n    currentNode = currentNode.parent;\n  }\n\n  return false;\n}\n\n/**\n * Checks whether a node is a counting `for` statement.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `ForStatement`.\n */\nfunction isForStatement(node: TSESTree.Node): node is TSESTree.ForStatement {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'ForStatement';\n}\n\n/**\n * Checks whether a node is a function waiting can be charged to.\n *\n * A `function` declaration counts as well as the two expression forms, because that is how these suites\n * write a local retry helper.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `FunctionDeclaration`, a `FunctionExpression` or an `ArrowFunctionExpression`.\n */\nfunction isFunctionNode(node: TSESTree.Node): node is HelperFunction {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return isClosureFunction(node) || node.type === 'FunctionDeclaration';\n}\n\n/**\n * Checks whether a node is an identifier.\n *\n * @param node - The node to check.\n * @returns `true` if the node is an `Identifier`.\n */\nfunction isIdentifier(node: TSESTree.Node): node is TSESTree.Identifier {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'Identifier';\n}\n\n/**\n * Checks whether a node is an `&&` chain, whose conjuncts a ceiling may be declared in one of.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `LogicalExpression` with the `&&` operator.\n */\nfunction isLogicalAndExpression(node: TSESTree.Node): node is TSESTree.LogicalExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'LogicalExpression' && node.operator === '&&';\n}\n\n/**\n * Checks whether a node is a loop whose own test can declare a ceiling.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `WhileStatement`, a `DoWhileStatement` or a `ForStatement`.\n */\nfunction isLoopStatement(node: TSESTree.Node): node is LoopStatement {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'WhileStatement' || node.type === 'DoWhileStatement' || isForStatement(node);\n}\n\n/**\n * Checks whether a node is a member expression.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `MemberExpression`.\n */\nfunction isMemberExpression(node: TSESTree.Node): node is TSESTree.MemberExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'MemberExpression';\n}\n\n/**\n * Checks whether a node is a numeric literal.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `Literal` holding a number.\n */\nfunction isNumericLiteral(node: TSESTree.Node): node is TSESTree.NumberLiteral {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'Literal' && typeof node.value === 'number';\n}\n\n/**\n * Checks whether a node is an object literal.\n *\n * @param node - The node to check.\n * @returns `true` if the node is an `ObjectExpression`.\n */\nfunction isObjectExpression(node: TSESTree.Node): node is TSESTree.ObjectExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'ObjectExpression';\n}\n\n/**\n * Checks whether a node is an object destructuring pattern.\n *\n * @param node - The node to check.\n * @returns `true` if the node is an `ObjectPattern`.\n */\nfunction isObjectPattern(node: TSESTree.Node): node is TSESTree.ObjectPattern {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'ObjectPattern';\n}\n\n/**\n * Checks whether a node is an object-literal or object-pattern property.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `Property`.\n */\nfunction isProperty(node: TSESTree.Node): node is TSESTree.Property {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'Property';\n}\n\n/**\n * Checks whether a node is an update expression.\n *\n * @param node - The node to check.\n * @returns `true` if the node is an `UpdateExpression`.\n */\nfunction isUpdateExpression(node: TSESTree.Node): node is TSESTree.UpdateExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'UpdateExpression';\n}\n\n/**\n * Checks whether a node is a variable declaration.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `VariableDeclaration`.\n */\nfunction isVariableDeclaration(node: TSESTree.Node): node is TSESTree.VariableDeclaration {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'VariableDeclaration';\n}\n\n/**\n * Checks whether a node is a variable declarator.\n *\n * @param node - The node to check.\n * @returns `true` if the node is a `VariableDeclarator`.\n */\nfunction isVariableDeclarator(node: TSESTree.Node): node is TSESTree.VariableDeclarator {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.type === 'VariableDeclarator';\n}\n\n/**\n * Reads the expression an identifier is bound to.\n *\n * A `const` answers with its initializer; a destructured parameter of THIS closure answers with what the\n * call's own `input` supplies for the key it was destructured by, which is how a budget written once at\n * the call site reaches a closure that can close over nothing.\n *\n * @param node - The identifier to resolve.\n * @param closure - The closure the identifier was written inside.\n * @param context - The rule context, used to resolve the identifier through scope.\n * @returns The expression it is bound to, or `null` when nothing statically binds it.\n */\nfunction readBoundExpression(node: TSESTree.Identifier, closure: EvalClosure, context: Rule.RuleContext): null | TSESTree.Node {\n  const variable = findVariable(context.sourceCode.getScope(node), node.name);\n  if (!variable) {\n    return null;\n  }\n\n  for (const definition of variable.defs) {\n    const definitionNode = toTSESTreeNode(definition.node);\n\n    if (isVariableDeclarator(definitionNode) && definitionNode.init) {\n      return definitionNode.init;\n    }\n\n    if (definitionNode === closure.closureNode) {\n      const inputKey = readParameterInputKey(closure.closureNode, node.name);\n      return inputKey === null ? null : readInputPropertyValue(closure.paramsNode, inputKey);\n    }\n  }\n\n  return null;\n}\n\n/**\n * Reads the helper a call names, when that helper is declared inside the given closure.\n *\n * Both forms these suites write are resolved through the same scope walk a budget uses: a `function`\n * declaration, and a `const` bound to an arrow or a function expression.\n *\n * @param callNode - The call expression.\n * @param closure - The in-Obsidian closure the call runs inside.\n * @param context - The rule context, used to resolve the callee through scope.\n * @returns The helper's function node, or `null` when the callee is not a helper of this closure.\n */\nfunction readCalledHelperNode(callNode: TSESTree.CallExpression, closure: EvalClosure, context: Rule.RuleContext): HelperFunction | null {\n  const calleeNode = callNode.callee as TSESTree.Node;\n  if (!isIdentifier(calleeNode)) {\n    return null;\n  }\n\n  const variable = findVariable(context.sourceCode.getScope(calleeNode), calleeNode.name);\n  if (!variable) {\n    return null;\n  }\n\n  for (const definition of variable.defs) {\n    const functionNode = readDefinitionFunctionNode(toTSESTreeNode(definition.node));\n    if (functionNode && isDeclaredInsideClosure(functionNode, closure)) {\n      return functionNode;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Sums a function's own waiting plus that of every helper it calls, multiplied by the calls that reach it.\n *\n * A function already on the stack contributes NOTHING, which is what terminates direct and mutual\n * recursion \u2014 the same silence an unbounded loop gets, rather than a guess at how often it repeats. The\n * stack is unwound on the way out, so a helper reached down two different paths is counted on both.\n *\n * @param functionNode - The function to total.\n * @param callGraph - The file's accumulated charges.\n * @param visitedNodes - The functions currently being totalled, which is the recursion stack.\n * @returns The waiting, in milliseconds.\n */\nfunction readCallGraphWaitInMilliseconds(functionNode: HelperFunction, callGraph: CallGraph, visitedNodes: Set<HelperFunction>): number {\n  if (visitedNodes.has(functionNode)) {\n    return 0;\n  }\n\n  visitedNodes.add(functionNode);\n\n  let totalInMilliseconds = callGraph.waitInMillisecondsByFunctionNode.get(functionNode) ?? 0;\n  for (const [calleeNode, callCount] of callGraph.callCountByCalleeNodeByCallerNode.get(functionNode) ?? []) {\n    totalInMilliseconds += callCount * readCallGraphWaitInMilliseconds(calleeNode, callGraph, visitedNodes);\n  }\n\n  visitedNodes.delete(functionNode);\n  return totalInMilliseconds;\n}\n\n/**\n * Reads the clock a node reads the current time from, if that is what it does.\n *\n * @param node - The node to inspect.\n * @returns The clock object's name (`Date` or `performance`), or `null` when the node is not a clock reading.\n */\nfunction readClockName(node: TSESTree.Node): null | string {\n  if (!isCallExpression(node) || node.arguments.length > 0) {\n    return null;\n  }\n\n  const calleeNode = node.callee as TSESTree.Node;\n  if (!isMemberExpression(calleeNode) || calleeNode.computed) {\n    return null;\n  }\n\n  const objectNode = calleeNode.object as TSESTree.Node;\n  const propertyNode = calleeNode.property as TSESTree.Node;\n  return !isIdentifier(objectNode) || !isIdentifier(propertyNode) || propertyNode.name !== NOW_METHOD_NAME || !CLOCK_OBJECT_NAMES.has(objectNode.name) ? null : objectNode.name;\n}\n\n/**\n * Reads the closure property names a call's parameter object may carry, by the helper it calls.\n *\n * @param callNode - The call expression.\n * @returns The in-Obsidian closure property names, or `null` when the callee is not one of the helpers.\n */\nfunction readClosureNames(callNode: TSESTree.CallExpression): null | readonly string[] {\n  return isIdentifier(callNode.callee) ? CLOSURE_NAMES_BY_CALLEE_NAME.get(callNode.callee.name) ?? null : null;\n}\n\n/**\n * Reads one closure's whole declared waiting.\n *\n * Everything the closure can REACH is totalled through the call graph, once per call site. Everything it\n * cannot \u2014 a helper nothing calls, or one called through a reference this rule cannot follow \u2014 keeps the\n * flat single charge a lexical attribution always gave it, so no closure reported before this rule counted\n * call sites falls silent now that it does.\n *\n * @param state - The closure's accumulated charges.\n * @param callGraph - The file's accumulated charges.\n * @returns The waiting the closure declares, in milliseconds.\n */\nfunction readClosureWaitInMilliseconds(state: ClosureState, callGraph: CallGraph): number {\n  const reachableNodes = new Set<HelperFunction>();\n  collectReachableFunctionNodes(state.closureNode, callGraph, reachableNodes);\n\n  let totalInMilliseconds = readCallGraphWaitInMilliseconds(state.closureNode, callGraph, new Set<HelperFunction>());\n\n  for (const functionNode of state.functionNodes) {\n    const ownWaitInMilliseconds = callGraph.waitInMillisecondsByFunctionNode.get(functionNode);\n    if (ownWaitInMilliseconds === undefined || reachableNodes.has(functionNode)) {\n      continue;\n    }\n\n    totalInMilliseconds += ownWaitInMilliseconds;\n  }\n\n  return totalInMilliseconds;\n}\n\n/**\n * Flattens an `&&` chain into the conditions it is built from.\n *\n * A test that is not an `&&` chain answers with itself, so a caller never special-cases the simple form.\n *\n * @param node - The expression to flatten.\n * @returns Every conjunct, left to right.\n */\nfunction readConjuncts(node: TSESTree.Expression): TSESTree.Expression[] {\n  return isLogicalAndExpression(node) ? [...readConjuncts(node.left), ...readConjuncts(node.right)] : [node];\n}\n\n/**\n * Reads the ceiling a single `clock.now() < deadline` comparison declares.\n *\n * Both operand orders are read, since `deadline > clock.now()` is the same guard written the other way\n * round. The binding must take its time from the SAME clock as the guard: a comparison across the two\n * measures nothing, and declining it is the silence any unresolvable value already gets.\n *\n * @param node - The condition to inspect.\n * @param closure - The in-Obsidian closure the loop runs inside.\n * @param context - The rule context, used to resolve the deadline through scope.\n * @returns The ceiling in milliseconds, or `null` when the condition declares none.\n */\nfunction readDeadlineGuardInMilliseconds(node: TSESTree.Node, closure: EvalClosure, context: Rule.RuleContext): null | number {\n  if (!isBinaryExpression(node)) {\n    return null;\n  }\n\n  const isClockOnLeft = node.operator === '<' || node.operator === '<=';\n  if (!isClockOnLeft && node.operator !== '>' && node.operator !== '>=') {\n    return null;\n  }\n\n  const clockName = readClockName(isClockOnLeft ? node.left : node.right);\n  const deadlineNode = (isClockOnLeft ? node.right : node.left) as TSESTree.Node;\n  if (clockName === null || !isIdentifier(deadlineNode)) {\n    return null;\n  }\n\n  const boundNode = readBoundExpression(deadlineNode, closure, context);\n  return !boundNode || !isBinaryExpression(boundNode) || boundNode.operator !== '+' || (readClockName(boundNode.left) !== clockName) ? null : resolveNumber(boundNode.right, closure, context);\n}\n\n/**\n * Reads the function a scope definition declares, if it declares one.\n *\n * @param definitionNode - The node a variable's definition points at.\n * @returns The function it declares, or `null` when the name is bound to anything else.\n */\nfunction readDefinitionFunctionNode(definitionNode: TSESTree.Node): HelperFunction | null {\n  if (isFunctionNode(definitionNode)) {\n    return definitionNode;\n  }\n\n  if (!isVariableDeclarator(definitionNode) || !definitionNode.init) {\n    return null;\n  }\n\n  const initNode = definitionNode.init as TSESTree.Node;\n  return isFunctionNode(initNode) ? initNode : null;\n}\n\n/**\n * Reads the in-Obsidian closure a function node is, if it is one.\n *\n * A closure qualifies when it is the value of a `callback` / `poll` / `start` property of the object\n * literal passed as the helper's first argument \u2014 which covers both the method shorthand\n * (`async callback({ \u2026 }) { \u2026 }`) and an arrow (`callback: async ({ \u2026 }) => { \u2026 }`).\n *\n * @param node - The node to check.\n * @returns The closure, or `null` when the node is not an in-Obsidian closure.\n */\nfunction readEvalClosure(node: TSESTree.Node): EvalClosure | null {\n  if (!isClosureFunction(node)) {\n    return null;\n  }\n\n  const propertyNode = node.parent;\n  if (!isProperty(propertyNode)) {\n    return null;\n  }\n\n  /*\n   * The object check comes BEFORE the key check because a function can reach a property through its\n   * COMPUTED KEY as well as through its value -- `{ [() => 'a']: 1 }` is legal -- and a destructuring\n   * pattern can carry one too. Neither is a helper call's parameter object.\n   */\n  const paramsNode = propertyNode.parent;\n  if (!isObjectExpression(paramsNode) || !isIdentifier(propertyNode.key)) {\n    return null;\n  }\n\n  const callNode = paramsNode.parent;\n  if (!isCallExpression(callNode) || callNode.arguments[0] !== paramsNode) {\n    return null;\n  }\n\n  const closureNames = readClosureNames(callNode);\n  return closureNames?.includes(propertyNode.key.name)\n    ? {\n      closureNode: node,\n      paramsNode,\n      reportNode: propertyNode\n    }\n    : null;\n}\n\n/**\n * Reads the value a call's own `input` object supplies for one key.\n *\n * This is how a budget declared once at the call site reaches the closure, which cannot close over\n * anything: `input: { settleTimeoutInMilliseconds: SETTLE }` arrives destructured in the callback's\n * parameter object.\n *\n * @param paramsNode - The helper's parameter object.\n * @param keyName - The `input` property to read.\n * @returns The expression supplying that key, or `null` when the call's `input` does not declare it.\n */\nfunction readInputPropertyValue(paramsNode: TSESTree.ObjectExpression, keyName: string): null | TSESTree.Node {\n  const inputProperty = paramsNode.properties.find((property) =>\n    isProperty(property as TSESTree.Node)\n    && isIdentifier((property as TSESTree.Property).key as TSESTree.Node)\n    && ((property as TSESTree.Property).key as TSESTree.Identifier).name === INPUT_PROPERTY_NAME\n  ) as TSESTree.Property | undefined;\n\n  const inputNode = inputProperty?.value as TSESTree.Node | undefined;\n  if (!inputNode || !isObjectExpression(inputNode)) {\n    return null;\n  }\n\n  const valueProperty = inputNode.properties.find((property) =>\n    isProperty(property as TSESTree.Node)\n    && isIdentifier((property as TSESTree.Property).key as TSESTree.Node)\n    && ((property as TSESTree.Property).key as TSESTree.Identifier).name === keyName\n  ) as TSESTree.Property | undefined;\n\n  return (valueProperty?.value as TSESTree.Node | undefined) ?? null;\n}\n\n/**\n * Reads the whole-loop ceiling a clock deadline declares, in milliseconds.\n *\n * The guard is looked for among the test's `&&` conjuncts rather than as the whole test, because the\n * loops that carry one pair it with a progress condition \u2014 `while (count < expected && Date.now() < deadline)`\n * \u2014 and a compound test must not remove a ceiling one of its conjuncts plainly declares.\n *\n * @param loopNode - The loop to inspect.\n * @param closure - The in-Obsidian closure the loop runs inside.\n * @param context - The rule context, used to resolve the deadline through scope.\n * @returns The ceiling in milliseconds, or `null` when the loop declares none.\n */\nfunction readLoopDeadlineInMilliseconds(loopNode: LoopStatement, closure: EvalClosure, context: Rule.RuleContext): null | number {\n  if (!loopNode.test) {\n    return null;\n  }\n\n  for (const conjunct of readConjuncts(loopNode.test)) {\n    const deadlineInMilliseconds = readDeadlineGuardInMilliseconds(conjunct, closure, context);\n    if (deadlineInMilliseconds !== null) {\n      return deadlineInMilliseconds;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Reads the first value a loop's test will not let its counter reach.\n *\n * An inclusive bound answers one higher than it is written, so a caller works in one currency rather than\n * carrying the operator along with the number. The test is read as `&&` conjuncts for the same reason a\n * deadline guard is: `attempt < ATTEMPTS && !isOpen` still cannot run more than `ATTEMPTS` times.\n *\n * @param testNode - The loop's test.\n * @param counterName - The name of the counter the loop advances.\n * @param closure - The in-Obsidian closure the loop runs inside.\n * @param context - The rule context, used to resolve the bound through scope.\n * @returns The exclusive bound, or `null` when no conjunct bounds that counter by a resolvable number.\n */\nfunction readLoopExclusiveBound(\n  testNode: TSESTree.Expression,\n  counterName: string,\n  closure: EvalClosure,\n  context: Rule.RuleContext\n): null | number {\n  for (const conjunct of readConjuncts(testNode)) {\n    if (!isBinaryExpression(conjunct) || (conjunct.operator !== '<' && conjunct.operator !== '<=')) {\n      continue;\n    }\n\n    const counterNode = conjunct.left as TSESTree.Node;\n    if (!isIdentifier(counterNode) || counterNode.name !== counterName) {\n      continue;\n    }\n\n    const boundValue = resolveNumber(conjunct.right, closure, context);\n    if (boundValue === null) {\n      continue;\n    }\n\n    return conjunct.operator === '<' ? boundValue : boundValue + 1;\n  }\n\n  return null;\n}\n\n/**\n * Reads how many times a counting `for` runs.\n *\n * The bound is read from the same `&&` conjuncts a deadline is, for the same reason:\n * `attempt < ATTEMPTS && !isOpen` still cannot run more than `ATTEMPTS` times. The STEP is read rather\n * than presumed to be one, or a `for (let elapsed = 0; elapsed < BUDGET; elapsed += INTERVAL)` poll would\n * be counted `BUDGET` times.\n *\n * @param loopNode - The loop to inspect.\n * @param closure - The in-Obsidian closure the loop runs inside.\n * @param context - The rule context, used to resolve the start, bound and step through scope.\n * @returns The iteration count, or `null` when it is not statically knowable.\n */\nfunction readLoopIterationCount(loopNode: LoopStatement, closure: EvalClosure, context: Rule.RuleContext): null | number {\n  if (!isForStatement(loopNode) || !loopNode.test || !loopNode.init || !isVariableDeclaration(loopNode.init)) {\n    return null;\n  }\n\n  const declaratorNodes = loopNode.init.declarations;\n  const declaratorNode = declaratorNodes.length === 1 ? declaratorNodes[0] : undefined;\n  if (!declaratorNode?.init || !isIdentifier(declaratorNode.id)) {\n    return null;\n  }\n\n  const startValue = resolveNumber(declaratorNode.init, closure, context);\n  const stepSize = readLoopStepSize(loopNode.update, declaratorNode.id, closure, context);\n  const boundValue = readLoopExclusiveBound(loopNode.test, declaratorNode.id.name, closure, context);\n  if (startValue === null || stepSize === null || stepSize <= 0 || boundValue === null) {\n    return null;\n  }\n\n  const span = boundValue - startValue;\n  return span > 0 ? Math.ceil(span / stepSize) : 0;\n}\n\n/**\n * Reads how many times something written at a node actually runs, as the product of its enclosing loops.\n *\n * A loop that is not statically countable contributes a factor of ONE rather than disqualifying the sum:\n * that is the per-iteration charge this rule has always made, and it is what keeps an unbounded\n * `while (true)` silent instead of guessed at. A DEADLINE-bounded loop contributes one as well, because\n * its whole-loop ceiling is charged separately and multiplying too would count the same waiting twice.\n *\n * The walk stops at the function the node is CHARGED to, not at the closure, so the loops around a helper's\n * own waits and the loops around each call to that helper are counted once each rather than twice.\n *\n * @param node - The node to count the runs of.\n * @param target - The function the node is charged to.\n * @param context - The rule context, used to resolve loop bounds through scope.\n * @returns The multiplier, never less than one.\n */\nfunction readLoopMultiplier(node: TSESTree.Node, target: ChargeTarget, context: Rule.RuleContext): number {\n  const closure = target.closure;\n  let multiplier = 1;\n  let currentNode: TSESTree.Node | undefined = node.parent;\n\n  while (currentNode && currentNode !== target.functionNode) {\n    if (isLoopStatement(currentNode) && readLoopDeadlineInMilliseconds(currentNode, closure, context) === null) {\n      const iterationCount = readLoopIterationCount(currentNode, closure, context);\n      if (iterationCount !== null) {\n        multiplier *= iterationCount;\n      }\n    }\n    currentNode = currentNode.parent;\n  }\n\n  return multiplier;\n}\n\n/**\n * Reads how far a counting loop's variable advances each iteration.\n *\n * @param updateNode - The loop's update expression.\n * @param counterNode - The identifier the loop counts on.\n * @param closure - The in-Obsidian closure the loop runs inside.\n * @param context - The rule context, used to resolve a non-literal step through scope.\n * @returns The step, or `null` when the update is not a plain advance of the loop's own counter.\n */\nfunction readLoopStepSize(\n  updateNode: null | TSESTree.Expression,\n  counterNode: TSESTree.Identifier,\n  closure: EvalClosure,\n  context: Rule.RuleContext\n): null | number {\n  if (!updateNode) {\n    return null;\n  }\n\n  if (isUpdateExpression(updateNode)) {\n    const argumentNode = updateNode.argument as TSESTree.Node;\n    return updateNode.operator === '++' && isIdentifier(argumentNode) && argumentNode.name === counterNode.name ? 1 : null;\n  }\n\n  if (!isAssignmentExpression(updateNode) || updateNode.operator !== '+=') {\n    return null;\n  }\n\n  const targetNode = updateNode.left as TSESTree.Node;\n  return !isIdentifier(targetNode) || targetNode.name !== counterNode.name ? null : resolveNumber(updateNode.right, closure, context);\n}\n\n/**\n * Reads the `input` key a destructured closure parameter is bound from.\n *\n * The binding may be renamed (`timeoutInMilliseconds: timeout`), so the KEY is what the call's `input`\n * is looked up by, never the local name.\n *\n * @param closureNode - The closure whose parameters to read.\n * @param localName - The name the budget is bound to inside the closure.\n * @returns The `input` key, or `null` when the name is not bound by a plain destructured property.\n */\nfunction readParameterInputKey(closureNode: ClosureFunction, localName: string): null | string {\n  for (const parameterNode of closureNode.params) {\n    if (!isObjectPattern(parameterNode)) {\n      continue;\n    }\n\n    for (const property of parameterNode.properties) {\n      if (!isProperty(property) || property.computed || !isIdentifier(property.key) || !isIdentifier(property.value)) {\n        continue;\n      }\n\n      if (property.value.name === localName) {\n        return property.key.name;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Reads the expression carrying a wait call's declared budget.\n *\n * @param callNode - The call expression to inspect.\n * @returns The expression to resolve; `null` for a `waitUntil` that omits its timeout, which takes the\n * helper's default; or `undefined` when the call is not a wait at all.\n */\nfunction readWaitBudgetExpression(callNode: TSESTree.CallExpression): null | TSESTree.Node | undefined {\n  if (!isIdentifier(callNode.callee)) {\n    return undefined;\n  }\n\n  const calleeName = callNode.callee.name;\n\n  if (calleeName === SLEEP_CALLEE_NAME) {\n    return (callNode.arguments[0]) ?? undefined;\n  }\n\n  if (calleeName !== WAIT_UNTIL_CALLEE_NAME) {\n    return undefined;\n  }\n\n  const paramsNode = callNode.arguments[0] as TSESTree.Node | undefined;\n  if (!paramsNode || !isObjectExpression(paramsNode)) {\n    return undefined;\n  }\n\n  const timeoutProperty = paramsNode.properties.find((property) =>\n    isProperty(property as TSESTree.Node)\n    && isIdentifier((property as TSESTree.Property).key as TSESTree.Node)\n    && ((property as TSESTree.Property).key as TSESTree.Identifier).name === TIMEOUT_PROPERTY_NAME\n  ) as TSESTree.Property | undefined;\n\n  return (timeoutProperty?.value) ?? null;\n}\n\n/**\n * Resolves an expression to a number, through scope.\n *\n * Every number the rule reads comes through here \u2014 a wait's budget, a loop's deadline, and a counting\n * loop's start, bound and step \u2014 which is why it is named for what it resolves rather than for\n * milliseconds.\n *\n * Handles a numeric literal, a literal-only product (`60 * 1000`), an identifier bound to either in any\n * enclosing scope, and a destructured closure parameter followed back through the call's own `input`.\n * Anything else is unresolvable and answers `null`, which the caller treats as contributing nothing.\n *\n * Each identifier is resolved from ITS OWN scope rather than from the wait's, so a value supplied by the\n * call's `input` resolves at the call site \u2014 where it was written \u2014 and is not captured by a same-named\n * binding that happens to exist inside the closure.\n *\n * @param node - The expression to resolve.\n * @param closure - The closure the expression was written inside.\n * @param context - The rule context, used to resolve identifiers through scope.\n * @returns The number, or `null` when it cannot be resolved statically.\n */\nfunction resolveNumber(node: TSESTree.Node, closure: EvalClosure, context: Rule.RuleContext): null | number {\n  const visitedNodes = new Set<TSESTree.Node>();\n  let currentNode = node;\n\n  while (!visitedNodes.has(currentNode)) {\n    visitedNodes.add(currentNode);\n\n    if (isNumericLiteral(currentNode)) {\n      return currentNode.value;\n    }\n\n    if (isBinaryExpression(currentNode) && currentNode.operator === '*') {\n      const leftValue = resolveNumber(currentNode.left, closure, context);\n      const rightValue = resolveNumber(currentNode.right, closure, context);\n\n      return leftValue === null || rightValue === null ? null : leftValue * rightValue;\n    }\n\n    if (!isIdentifier(currentNode)) {\n      return null;\n    }\n\n    const boundNode = readBoundExpression(currentNode, closure, context);\n    if (!boundNode) {\n      return null;\n    }\n\n    currentNode = boundNode;\n  }\n\n  return null;\n}\n"],
  "mappings": "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",
  "names": []
}
