@suss/adapter-typescript 0.37.0 → 0.37.1

package/dist/index.js

@@ -2,7 +2,8 @@
 import path15 from "path";
 import {
   Node as Node82,
-  Project as Project2
+  Project as Project2,
+  SyntaxKind as SyntaxKind31
 } from "ts-morph";
 import {
   BOUNDARY_ROLE,
@@ -37,7 +38,8 @@ import { force as force8, hostOf as hostOf2, literalOf as literalOf6, pathOf as
 
 // src/assembly.ts
 import {
-  Node as Node67
+  Node as Node67,
+  SyntaxKind as SyntaxKind27
 } from "ts-morph";
 import { firesOn, runsBefore, splitAtHandOffs } from "@suss/extractor";
 
@@ -47,11 +49,11 @@ import {
 } from "ts-morph";
 
 // src/predicates.ts
-import { Node as Node45, SyntaxKind as SyntaxKind12 } from "ts-morph";
+import { Node as Node45, SyntaxKind as SyntaxKind19 } from "ts-morph";
 import { replacePredicateRefs } from "@suss/behavioral-ir";
 
 // src/resolve/astResolve.ts
-import { Node as Node42, SyntaxKind as SyntaxKind11 } from "ts-morph";
+import { Node as Node42, SyntaxKind as SyntaxKind18 } from "ts-morph";
 
 // src/walk/nodeKeys.ts
 import { declarationKey } from "@suss/behavioral-ir";
@@ -138,7 +140,7 @@ function passesValueThrough(node) {
 }
 
 // src/resolve/functionBehind.ts
-import { Node as Node41, SyntaxKind as SyntaxKind10 } from "ts-morph";
+import { Node as Node41, SyntaxKind as SyntaxKind17 } from "ts-morph";
 import { normalizeCalleeText } from "@suss/behavioral-ir";
 
 // src/facts/store.ts
@@ -179,7 +181,8 @@ import path from "path";
 
 // src/discovery/shared.ts
 import {
-  Node as Node2
+  Node as Node2,
+  SyntaxKind
 } from "ts-morph";
 function unitNode(unit) {
   return unit.func ?? unit.announcedAt ?? null;
@@ -218,8 +221,15 @@ function exportIdentityOf(unit) {
   return "";
 }
 function isFunctionRoot(node) {
-  return Node2.isFunctionDeclaration(node) || Node2.isFunctionExpression(node) || Node2.isArrowFunction(node) || Node2.isMethodDeclaration(node) || Node2.isConstructorDeclaration(node);
-}
+  return FUNCTION_ROOT_KINDS.has(node.getKind());
+}
+var FUNCTION_ROOT_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind.FunctionDeclaration,
+  SyntaxKind.FunctionExpression,
+  SyntaxKind.ArrowFunction,
+  SyntaxKind.MethodDeclaration,
+  SyntaxKind.Constructor
+]);
 function declarationCarryingTheBody(declaration) {
   if (!Node2.isFunctionDeclaration(declaration) && !Node2.isMethodDeclaration(declaration) && !Node2.isConstructorDeclaration(declaration)) {
     return declaration;
@@ -300,6 +310,61 @@ function createPerFileCache() {
   };
 }
 
+// src/walk/rawDescent.ts
+import {
+  ts
+} from "ts-morph";
+function statementsOfKind(file, kind) {
+  const found = [];
+  for (const raw of file.compilerNode.statements) {
+    if (raw.kind === kind) {
+      found.push(wrapperOf(file, raw));
+    }
+  }
+  return found;
+}
+function forEachDescendantOfKinds(root, kinds, visit, skips = runsNothing) {
+  forEachDescendantWhere(root, (raw) => kinds.has(raw.kind), visit, skips);
+}
+function forEachDescendantWhere(root, accepts, visit, skips = runsNothing) {
+  const walk = (raw) => {
+    if (skips(raw)) {
+      return void 0;
+    }
+    if (accepts(raw) && visit(wrapperOf(root, raw)) === true) {
+      return void 0;
+    }
+    ts.forEachChild(raw, walk);
+    return void 0;
+  };
+  ts.forEachChild(root.compilerNode, walk);
+}
+function runsNothing(raw) {
+  return isTypeOnlySyntax(raw) || isAmbient(raw);
+}
+function skipsNothing() {
+  return false;
+}
+function isTypeOnlySyntax(raw) {
+  return raw.kind >= ts.SyntaxKind.FirstTypeNode && raw.kind <= ts.SyntaxKind.LastTypeNode || TYPE_DECLARATIONS.has(raw.kind);
+}
+var TYPE_DECLARATIONS = /* @__PURE__ */ new Set([
+  ts.SyntaxKind.TypeAliasDeclaration,
+  ts.SyntaxKind.InterfaceDeclaration,
+  ts.SyntaxKind.TypeParameter
+]);
+function isAmbient(raw) {
+  if (!ts.canHaveModifiers(raw)) {
+    return false;
+  }
+  return ts.getModifiers(raw)?.some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword) ?? false;
+}
+function wrapperOf(anchor, raw) {
+  return anchor._getNodeFromCompilerNode(
+    raw
+  );
+}
+
 // src/bootstrap/sourceFileLookup.ts
 function sourceFileFor(project, moduleKey) {
   if (!isPathKey(moduleKey)) {
@@ -403,17 +468,21 @@ function spanKey(span) {
 var functionIndexes = createPerFileCache();
 function indexFunctions(sf) {
   const index = /* @__PURE__ */ new Map();
-  sf.forEachDescendant((node) => {
-    if (!isFunctionRoot(node)) {
-      return;
-    }
-    const bySpan = spanKey({ start: node.getStart(), end: node.getEnd() });
-    index.set(bySpan, node);
-    const key = rangeKey({ start: startLineOf(node), end: endLineOf(node) });
-    if (!index.has(key)) {
-      index.set(key, node);
-    }
-  });
+  forEachDescendantOfKinds(
+    sf,
+    FUNCTION_ROOT_KINDS,
+    (found) => {
+      const node = found;
+      const bySpan = spanKey({ start: node.getStart(), end: node.getEnd() });
+      index.set(bySpan, node);
+      const key = rangeKey({ start: startLineOf(node), end: endLineOf(node) });
+      if (!index.has(key)) {
+        index.set(key, node);
+      }
+      return false;
+    },
+    isTypeOnlySyntax
+  );
   return index;
 }
 
@@ -442,15 +511,15 @@ function recordUnitClaim(key, pack) {
 }
 
 // src/facts/containerWrites.ts
-import { Node as Node8, SyntaxKind as SyntaxKind4 } from "ts-morph";
+import { Node as Node8, SyntaxKind as SyntaxKind8 } from "ts-morph";
 
 // src/facts/extract.ts
 import { posix } from "path";
 import {
   ModuleDeclarationKind,
   Node as Node6,
-  SyntaxKind as SyntaxKind2,
-  ts as ts2
+  SyntaxKind as SyntaxKind6,
+  ts as ts4
 } from "ts-morph";
 import {
   addEntryRows,
@@ -467,12 +536,12 @@ import {
 } from "@suss/resolution";
 
 // src/moduleExports.ts
-import { Node as Node3 } from "ts-morph";
+import { Node as Node3, SyntaxKind as SyntaxKind4 } from "ts-morph";
 
 // src/bootstrap/lazyProjectInit.ts
 import fs2 from "fs/promises";
 import path3 from "path";
-import { ts } from "ts-morph";
+import { ts as ts2 } from "ts-morph";
 
 // src/facts/generatedModules.ts
 import fs from "fs";
@@ -558,6 +627,7 @@ function generatedModulesOf(packs) {
 }
 
 // src/facts/moduleGraph.ts
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
 import { Database, evaluate, lit, rule, variable as v } from "@suss/datalog";
 var NO_GENERATOR = new GeneratedModules([]);
 var REACH_RULES = [
@@ -762,10 +832,16 @@ var ModuleGraph = class {
 };
 function readModuleSpecifiers(sourceFile) {
   const specifiers = [];
-  for (const importDecl of sourceFile.getImportDeclarations()) {
+  for (const importDecl of statementsOfKind(
+    sourceFile,
+    SyntaxKind2.ImportDeclaration
+  )) {
     specifiers.push(importDecl.getModuleSpecifierValue());
   }
-  for (const exportDecl of sourceFile.getExportDeclarations()) {
+  for (const exportDecl of statementsOfKind(
+    sourceFile,
+    SyntaxKind2.ExportDeclaration
+  )) {
     const specifier = exportDecl.getModuleSpecifierValue();
     if (specifier !== void 0) {
       specifiers.push(specifier);
@@ -785,13 +861,19 @@ function resolveModuleSpecifiers(sourceFile) {
 }
 function resolveModuleSpecifiersOf(sourceFile) {
   const resolved = [];
-  for (const importDecl of sourceFile.getImportDeclarations()) {
+  for (const importDecl of statementsOfKind(
+    sourceFile,
+    SyntaxKind2.ImportDeclaration
+  )) {
     const target = importDecl.getModuleSpecifierSourceFile();
     if (target !== void 0) {
       resolved.push(target);
     }
   }
-  for (const exportDecl of sourceFile.getExportDeclarations()) {
+  for (const exportDecl of statementsOfKind(
+    sourceFile,
+    SyntaxKind2.ExportDeclaration
+  )) {
     const target = exportDecl.getModuleSpecifierSourceFile();
     if (target !== void 0) {
       resolved.push(target);
@@ -809,6 +891,7 @@ function namesAnyPackage(specifiers, names) {
 }
 
 // src/bootstrap/preFilter.ts
+import { SyntaxKind as SyntaxKind3 } from "ts-morph";
 function computePackApplicability(sourceFiles, packs, resolution) {
   const ungatedPacks = [];
   const gatedPacks = [];
@@ -828,7 +911,9 @@ function computePackApplicability(sourceFiles, packs, resolution) {
     for (const sf of sourceFiles) {
       importsByFile.set(
         sf,
-        sf.getImportDeclarations().map((d) => d.getModuleSpecifierValue())
+        statementsOfKind(sf, SyntaxKind3.ImportDeclaration).map(
+          (d) => d.getModuleSpecifierValue()
+        )
       );
     }
   }
@@ -1088,7 +1173,7 @@ function resolutionCacheFor(project, options) {
   if (existing !== void 0) {
     return existing;
   }
-  const fresh = ts.createModuleResolutionCache(
+  const fresh = ts2.createModuleResolutionCache(
     project.getFileSystem().getCurrentDirectory(),
     (name) => name,
     options
@@ -1122,11 +1207,11 @@ function readSpecifierPaths(project, filePath, options, host) {
   if (text3 === null) {
     return [];
   }
-  const scanned = ts.preProcessFile(text3, true, true);
+  const scanned = ts2.preProcessFile(text3, true, true);
   const cache = resolutionCacheFor(project, options);
   const paths = [];
   for (const imported of scanned.importedFiles) {
-    const resolved = ts.resolveModuleName(
+    const resolved = ts2.resolveModuleName(
       imported.fileName,
       filePath,
       options,
@@ -1152,13 +1237,13 @@ function readFileText(project, filePath) {
 }
 function parseTsconfig(tsConfigFilePath, seen = /* @__PURE__ */ new Set()) {
   seen.add(tsConfigFilePath);
-  const configFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
+  const configFile = ts2.readConfigFile(tsConfigFilePath, ts2.sys.readFile);
   if (configFile.error !== void 0) {
     return { fileNames: [], options: {} };
   }
-  const parsed = ts.parseJsonConfigFileContent(
+  const parsed = ts2.parseJsonConfigFileContent(
     configFile.config,
-    ts.sys,
+    ts2.sys,
     path3.dirname(tsConfigFilePath),
     /*existingOptions*/
     void 0,
@@ -1167,7 +1252,7 @@ function parseTsconfig(tsConfigFilePath, seen = /* @__PURE__ */ new Set()) {
   if (parsed.fileNames.length > 0) {
     return { fileNames: parsed.fileNames, options: parsed.options };
   }
-  const referenced = (parsed.projectReferences ?? []).map((reference) => ts.resolveProjectReferencePath(reference)).filter((referencePath) => !seen.has(referencePath)).map((referencePath) => parseTsconfig(referencePath, seen));
+  const referenced = (parsed.projectReferences ?? []).map((reference) => ts2.resolveProjectReferencePath(reference)).filter((referencePath) => !seen.has(referencePath)).map((referencePath) => parseTsconfig(referencePath, seen));
   const fileNames = [
     ...new Set(referenced.flatMap((reference) => reference.fileNames))
   ];
@@ -1241,17 +1326,17 @@ function addImportersOfMatches(fileImports, matched, options) {
 }
 function internalSpecifierResolver(files, options) {
   const fileSet = new Set(files);
-  const cache = ts.createModuleResolutionCache(
-    ts.sys.getCurrentDirectory(),
+  const cache = ts2.createModuleResolutionCache(
+    ts2.sys.getCurrentDirectory(),
     (name) => name,
     options
   );
   return (fromFile, spec) => {
-    const resolved = ts.resolveModuleName(
+    const resolved = ts2.resolveModuleName(
       spec,
       fromFile,
       options,
-      ts.sys,
+      ts2.sys,
       cache
     ).resolvedModule?.resolvedFileName;
     if (resolved === void 0) {
@@ -1260,7 +1345,7 @@ function internalSpecifierResolver(files, options) {
     if (fileSet.has(resolved)) {
       return resolved;
     }
-    const real = ts.sys.realpath?.(resolved) ?? resolved;
+    const real = ts2.sys.realpath?.(resolved) ?? resolved;
     return fileSet.has(real) ? real : null;
   };
 }
@@ -1295,7 +1380,7 @@ async function readImportsConcurrently(paths, marks) {
       const p = paths[i];
       try {
         const text3 = await fs2.readFile(p, "utf-8");
-        const pre = ts.preProcessFile(text3, true, false);
+        const pre = ts2.preProcessFile(text3, true, false);
         results[i] = {
           path: p,
           importedModules: pre.importedFiles.map((f) => f.fileName),
@@ -1418,7 +1503,7 @@ function reExportShapeOf(file, reach) {
   const targets = [];
   const exportNodes = [];
   const localNames = /* @__PURE__ */ new Set();
-  for (const decl of file.getExportDeclarations()) {
+  for (const decl of statementsOfKind(file, SyntaxKind4.ExportDeclaration)) {
     const target = decl.getModuleSpecifierSourceFile();
     if (target !== void 0) {
       targets.push(target);
@@ -1430,7 +1515,10 @@ function reExportShapeOf(file, reach) {
       }
     }
   }
-  for (const assignment of file.getExportAssignments()) {
+  for (const assignment of statementsOfKind(
+    file,
+    SyntaxKind4.ExportAssignment
+  )) {
     exportNodes.push(assignment);
     const expression = assignment.getExpression();
     if (Node3.isIdentifier(expression)) {
@@ -1438,7 +1526,7 @@ function reExportShapeOf(file, reach) {
     }
   }
   const importNodes = [];
-  for (const decl of file.getImportDeclarations()) {
+  for (const decl of statementsOfKind(file, SyntaxKind4.ImportDeclaration)) {
     const all = importBindingsOf(decl);
     const bindings = reach === "every import" ? all : all.filter((binding) => localNames.has(binding.name));
     if (bindings.length === 0) {
@@ -1528,7 +1616,7 @@ function keyNameOf(name) {
 }
 
 // src/facts/assignments.ts
-import { Node as Node5, SyntaxKind, VariableDeclarationKind } from "ts-morph";
+import { Node as Node5, SyntaxKind as SyntaxKind5, ts as ts3, VariableDeclarationKind } from "ts-morph";
 import { valueLeftByWrites } from "@suss/resolution";
 var byFile = createPerFileCache();
 var byDeclaration = /* @__PURE__ */ new WeakMap();
@@ -1576,7 +1664,7 @@ function describeWrites(values) {
   }));
 }
 function isNotYetPlaceholder(value) {
-  return value.getKind() === SyntaxKind.NullKeyword || Node5.isIdentifier(value) && value.getText() === "undefined";
+  return value.getKind() === SyntaxKind5.NullKeyword || Node5.isIdentifier(value) && value.getText() === "undefined";
 }
 function isConstruction(value) {
   return Node5.isCallExpression(value) || Node5.isNewExpression(value) || Node5.isObjectLiteralExpression(value) || Node5.isArrayLiteralExpression(value);
@@ -1711,11 +1799,8 @@ function assignmentsInFile(sourceFile) {
   }
   const found = /* @__PURE__ */ new Map();
   byFile.set(sourceFile, found);
-  sourceFile.forEachDescendant((node) => {
+  forEachDescendantWhere(sourceFile, mayWrite, (node) => {
     const written = writeAt(node);
-    if (written === null) {
-      return;
-    }
     for (const declaration of declarationsOf(written.target)) {
       const writes = found.get(declaration);
       if (writes === void 0) {
@@ -1724,34 +1809,33 @@ function assignmentsInFile(sourceFile) {
         writes.push(written.write);
       }
     }
+    return false;
   });
   return found;
 }
+function mayWrite(raw) {
+  if (ts3.isBinaryExpression(raw)) {
+    return isAssignmentOperator(raw.operatorToken.kind) && (ts3.isIdentifier(raw.left) || ts3.isPropertyAccessExpression(raw.left));
+  }
+  if (ts3.isPrefixUnaryExpression(raw) || ts3.isPostfixUnaryExpression(raw)) {
+    return (raw.operator === SyntaxKind5.PlusPlusToken || raw.operator === SyntaxKind5.MinusMinusToken) && ts3.isIdentifier(raw.operand);
+  }
+  return false;
+}
 function isAssignmentOperator(kind) {
-  return kind >= SyntaxKind.FirstAssignment && kind <= SyntaxKind.LastAssignment;
+  return kind >= SyntaxKind5.FirstAssignment && kind <= SyntaxKind5.LastAssignment;
 }
 function writesItsWholeValue(kind) {
-  return kind === SyntaxKind.EqualsToken || kind === SyntaxKind.QuestionQuestionEqualsToken || kind === SyntaxKind.BarBarEqualsToken;
+  return kind === SyntaxKind5.EqualsToken || kind === SyntaxKind5.QuestionQuestionEqualsToken || kind === SyntaxKind5.BarBarEqualsToken;
 }
 function writeAt(node) {
   if (Node5.isBinaryExpression(node)) {
     const operator = node.getOperatorToken().getKind();
-    const target = node.getLeft();
-    if (!isAssignmentOperator(operator) || !(Node5.isIdentifier(target) || Node5.isPropertyAccessExpression(target))) {
-      return null;
-    }
     const value = writesItsWholeValue(operator) ? node.getRight() : null;
-    return { target, write: { value, node } };
-  }
-  if (Node5.isPrefixUnaryExpression(node) || Node5.isPostfixUnaryExpression(node)) {
-    const operator = node.getOperatorToken();
-    if (operator !== SyntaxKind.PlusPlusToken && operator !== SyntaxKind.MinusMinusToken) {
-      return null;
-    }
-    const target = node.getOperand();
-    return Node5.isIdentifier(target) ? { target, write: { value: null, node } } : null;
+    return { target: node.getLeft(), write: { value, node } };
   }
-  return null;
+  const update = node;
+  return { target: update.getOperand(), write: { value: null, node } };
 }
 function declarationsOf(name) {
   const nameNode = Node5.isPropertyAccessExpression(name) ? name.getNameNode() : name;
@@ -1793,35 +1877,39 @@ function statementOf(node) {
 function isReadBefore(declaration, position) {
   const name = declaration.getName();
   const sourceFile = declaration.getSourceFile();
-  let read2 = false;
-  sourceFile.forEachDescendant((node, traversal) => {
-    if (read2) {
-      traversal.stop();
-      return;
-    }
-    if (node.getStart() >= position) {
-      traversal.skip();
-      return;
-    }
-    if (startsItsOwnBody(node)) {
-      traversal.skip();
-      return;
-    }
-    if (!Node5.isIdentifier(node) || node.getText() !== name) {
-      return;
+  const file = sourceFile.compilerNode;
+  const readsHere = (raw) => {
+    if (!ts3.isIdentifier(raw) || raw.getText(file) !== name) {
+      return false;
     }
+    const node = wrapperOf(sourceFile, raw);
     if (node === declaration.getNameNode() || isWriteTarget(node)) {
-      return;
-    }
-    if (declarationsOf(node).includes(declaration)) {
-      read2 = true;
+      return false;
     }
-  });
-  return read2;
-}
-function startsItsOwnBody(node) {
-  return Node5.isFunctionDeclaration(node) || Node5.isFunctionExpression(node) || Node5.isArrowFunction(node) || Node5.isMethodDeclaration(node) || Node5.isClassDeclaration(node);
+    return declarationsOf(node).includes(declaration);
+  };
+  return someBefore(file, position, readsHere);
 }
+function someBefore(root, position, test) {
+  const file = root.getSourceFile();
+  const visit = (raw) => {
+    if (raw.getStart(file) >= position || OWN_BODY_KINDS.has(raw.kind)) {
+      return void 0;
+    }
+    if (test(raw)) {
+      return true;
+    }
+    return ts3.forEachChild(raw, visit);
+  };
+  return ts3.forEachChild(root, visit) === true;
+}
+var OWN_BODY_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind5.FunctionDeclaration,
+  SyntaxKind5.FunctionExpression,
+  SyntaxKind5.ArrowFunction,
+  SyntaxKind5.MethodDeclaration,
+  SyntaxKind5.ClassDeclaration
+]);
 function isWriteTarget(name) {
   const parent = name.getParent();
   if (parent === void 0) {
@@ -1911,21 +1999,12 @@ function runsAsItsOwnBody(node) {
   return Node5.isFunctionDeclaration(node) || Node5.isFunctionExpression(node) || Node5.isArrowFunction(node) || Node5.isMethodDeclaration(node) || Node5.isConstructorDeclaration(node) || Node5.isGetAccessorDeclaration(node) || Node5.isSetAccessorDeclaration(node);
 }
 function isPropertyReadBefore(statements, name, property, position) {
-  let read2 = false;
-  statements.forEachDescendant((node, traversal) => {
-    if (read2) {
-      traversal.stop();
-      return;
-    }
-    if (node.getStart() >= position || startsItsOwnBody(node)) {
-      traversal.skip();
-      return;
-    }
-    if (Node5.isPropertyAccessExpression(node) && node.getName() === property && node.getExpression().getText() === name && !isWriteTarget(node)) {
-      read2 = true;
-    }
-  });
-  return read2;
+  const file = statements.getSourceFile().compilerNode;
+  return someBefore(
+    statements.compilerNode,
+    position,
+    (raw) => ts3.isPropertyAccessExpression(raw) && raw.name.getText(file) === property && raw.expression.getText(file) === name && !isWriteTarget(wrapperOf(statements, raw))
+  );
 }
 
 // src/facts/languageWords.ts
@@ -1974,8 +2053,15 @@ function createNodeTable(environmentObjects = [], runtime = NO_RUNTIME_SPELLINGS
   };
 }
 function nodeId(node) {
-  return `${node.getSourceFile().getFilePath()}:${node.getStart()}-${node.getEnd()}`;
+  const known = idByNode.get(node.compilerNode);
+  if (known !== void 0) {
+    return known;
+  }
+  const id = `${node.getSourceFile().getFilePath()}:${node.getStart()}-${node.getEnd()}`;
+  idByNode.set(node.compilerNode, id);
+  return id;
 }
+var idByNode = /* @__PURE__ */ new WeakMap();
 function moduleKeyOf(declaration) {
   const resolved = declaration.getModuleSpecifierSourceFile();
   if (resolved !== void 0) {
@@ -1989,7 +2075,7 @@ function moduleKeyOf(declaration) {
 }
 function compilerResolvedPathOf(declaration, specifier) {
   const project = declaration.getProject();
-  const result = ts2.resolveModuleName(
+  const result = ts4.resolveModuleName(
     specifier,
     declaration.getSourceFile().getFilePath(),
     project.getCompilerOptions(),
@@ -2031,7 +2117,7 @@ function moduleKeysOf(moduleKey, specifier) {
 }
 function dynamicImportKeysOf(expression) {
   const call = unwrapExpression(expression);
-  if (!Node6.isCallExpression(call) || call.getExpression().getKind() !== SyntaxKind2.ImportKeyword) {
+  if (!Node6.isCallExpression(call) || call.getExpression().getKind() !== SyntaxKind6.ImportKeyword) {
     return null;
   }
   const [argument] = call.getArguments();
@@ -2296,7 +2382,33 @@ function spellingsHandedOn(paths, sourceFile) {
   if (!paths.some((path18) => text3.includes(path18))) {
     return [];
   }
-  return sourceFile.getDescendantsOfKind(SyntaxKind2.PropertyAccessExpression).filter((node) => spellsOneOf(paths, node) && flowsOnward(node));
+  const file = sourceFile.compilerNode;
+  const found = [];
+  forEachDescendantWhere(
+    sourceFile,
+    (raw) => ts4.isPropertyAccessExpression(raw) && paths.includes(compilerDottedPathOf(raw, file) ?? ""),
+    (node) => {
+      if (flowsOnward(node)) {
+        found.push(node);
+      }
+      return false;
+    }
+  );
+  return found;
+}
+function compilerDottedPathOf(raw, file) {
+  if (ts4.isIdentifier(raw)) {
+    return raw.getText(file);
+  }
+  if (ts4.isMetaProperty(raw)) {
+    const keyword = ts4.tokenToString(raw.keywordToken);
+    return `${keyword}.${raw.name.getText(file)}`;
+  }
+  if (!ts4.isPropertyAccessExpression(raw)) {
+    return null;
+  }
+  const object = compilerDottedPathOf(raw.expression, file);
+  return object === null ? null : `${object}.${raw.name.getText(file)}`;
 }
 function flowsOnward(node) {
   const parent = node.getParent();
@@ -2313,7 +2425,7 @@ function dottedPathOf(expression) {
     return expression.getText();
   }
   if (Node6.isMetaProperty(expression)) {
-    const keyword = ts2.tokenToString(expression.getKeywordToken());
+    const keyword = ts4.tokenToString(expression.getKeywordToken());
     return `${keyword}.${expression.getName()}`;
   }
   if (!Node6.isPropertyAccessExpression(expression)) {
@@ -2327,7 +2439,7 @@ function asFallbackExpression(expression) {
     return null;
   }
   const operator = expression.getOperatorToken().getKind();
-  return operator === SyntaxKind2.BarBarToken || operator === SyntaxKind2.QuestionQuestionToken ? expression : null;
+  return operator === SyntaxKind6.BarBarToken || operator === SyntaxKind6.QuestionQuestionToken ? expression : null;
 }
 function unwrapExpression(expression) {
   let current2 = expression;
@@ -2349,7 +2461,7 @@ function unwrapExpression(expression) {
 }
 function emitValue(db, table, value) {
   const expression = unwrapExpression(value);
-  if (expression.getKind() === SyntaxKind2.ThisKeyword) {
+  if (expression.getKind() === SyntaxKind6.ThisKeyword) {
     const receiver = receiverKeyOf(db, table, expression);
     if (receiver !== null) {
       return receiver;
@@ -2503,7 +2615,7 @@ function memberReadName(read2) {
 }
 function readsOffClassItself(receiver) {
   const written = unwrapExpression(receiver);
-  if (written.getKind() === SyntaxKind2.ThisKeyword) {
+  if (written.getKind() === SyntaxKind6.ThisKeyword) {
     return thisIsTheClass(written);
   }
   return isClassReference(written, /* @__PURE__ */ new Set());
@@ -2648,7 +2760,7 @@ function emitReferenceFacts(db, table, reference) {
     }
     if (Node6.isImportClause(declaration)) {
       const importDecl = declaration.getParentIfKind(
-        SyntaxKind2.ImportDeclaration
+        SyntaxKind6.ImportDeclaration
       );
       if (importDecl !== void 0) {
         emitImportFacts(
@@ -2664,7 +2776,7 @@ function emitReferenceFacts(db, table, reference) {
     }
     if (Node6.isNamespaceImport(declaration)) {
       const importDecl = declaration.getFirstAncestorByKind(
-        SyntaxKind2.ImportDeclaration
+        SyntaxKind6.ImportDeclaration
       );
       if (importDecl !== void 0) {
         emitImportFacts(
@@ -2978,11 +3090,11 @@ function emitConstructorFacts(db, table, declaration, classId) {
     return;
   }
   const writes = propertyWritesOf(implementation, body);
-  body.forEachDescendant((descendant, traversal) => {
-    if (recordBodyCalls(db, table, classId, descendant, writes)) {
-      traversal.skip();
-    }
-  });
+  forEachDescendantOfKinds(
+    body,
+    BODY_FACT_KINDS,
+    (descendant) => recordBodyCalls(db, table, classId, descendant, writes)
+  );
   emitNamedStores(db, table, writes);
 }
 function emitParameters(db, table, ownerId, parameters) {
@@ -3034,11 +3146,11 @@ function emitFunctionFacts(db, table, fn) {
         returns.stated = true;
         recordBodyNode(db, table, fnId, body, returns, writes);
       }
-      body.forEachDescendant((descendant, traversal) => {
-        if (recordBodyNode(db, table, fnId, descendant, returns, writes)) {
-          traversal.skip();
-        }
-      });
+      forEachDescendantOfKinds(
+        body,
+        BODY_FACT_KINDS,
+        (descendant) => recordBodyNode(db, table, fnId, descendant, returns, writes)
+      );
       emitNamedStores(db, table, writes);
     }
     if (!returns.stated) {
@@ -3096,6 +3208,18 @@ function recordBodyNode(db, table, fnId, node, returns, writes) {
   }
   return recordBodyCalls(db, table, fnId, node, writes);
 }
+var BODY_FACT_KINDS = /* @__PURE__ */ new Set([
+  ...FUNCTION_ROOT_KINDS,
+  SyntaxKind6.ReturnStatement,
+  SyntaxKind6.ElementAccessExpression,
+  SyntaxKind6.BinaryExpression,
+  SyntaxKind6.CallExpression,
+  SyntaxKind6.NewExpression,
+  SyntaxKind6.AwaitExpression,
+  SyntaxKind6.ParenthesizedExpression,
+  SyntaxKind6.AsExpression,
+  SyntaxKind6.SatisfiesExpression
+]);
 function recordBodyCalls(db, table, fnId, node, writes) {
   if (isFunctionRoot(node)) {
     emitValue(db, table, node);
@@ -3122,7 +3246,7 @@ function recordBodyCalls(db, table, fnId, node, writes) {
   return false;
 }
 function emitExitCodeWrite(db, table, node) {
-  if (table.exitCodeWrites.length === 0 || !Node6.isBinaryExpression(node) || node.getOperatorToken().getKind() !== SyntaxKind2.EqualsToken || !spellsOneOf(table.exitCodeWrites, node.getLeft())) {
+  if (table.exitCodeWrites.length === 0 || !Node6.isBinaryExpression(node) || node.getOperatorToken().getKind() !== SyntaxKind6.EqualsToken || !spellsOneOf(table.exitCodeWrites, node.getLeft())) {
     return;
   }
   fact(db, "exitCodeWrite", emitValue(db, table, node.getRight()));
@@ -3146,12 +3270,12 @@ function emitTopLevelStatements(db, table, sourceFile) {
       continue;
     }
     if (TOP_LEVEL_BLOCKS.has(statement.getKind())) {
-      statement.forEachDescendant((node, traversal) => {
+      forEachDescendantOfKinds(statement, TOP_LEVEL_WRITE_KINDS, (node) => {
         if (isFunctionRoot(node) || Node6.isClassDeclaration(node)) {
-          traversal.skip();
-          return;
+          return true;
         }
         notePropertyWrite(writes, node);
+        return false;
       });
     }
   }
@@ -3162,16 +3286,21 @@ function statementExpressionOf(statement) {
   return Node6.isVoidExpression(expression) ? unwrapExpression(expression.getExpression()) : expression;
 }
 var TOP_LEVEL_BLOCKS = /* @__PURE__ */ new Set([
-  SyntaxKind2.Block,
-  SyntaxKind2.IfStatement,
-  SyntaxKind2.TryStatement,
-  SyntaxKind2.SwitchStatement,
-  SyntaxKind2.LabeledStatement,
-  SyntaxKind2.ForStatement,
-  SyntaxKind2.ForOfStatement,
-  SyntaxKind2.ForInStatement,
-  SyntaxKind2.WhileStatement,
-  SyntaxKind2.DoStatement
+  SyntaxKind6.Block,
+  SyntaxKind6.IfStatement,
+  SyntaxKind6.TryStatement,
+  SyntaxKind6.SwitchStatement,
+  SyntaxKind6.LabeledStatement,
+  SyntaxKind6.ForStatement,
+  SyntaxKind6.ForOfStatement,
+  SyntaxKind6.ForInStatement,
+  SyntaxKind6.WhileStatement,
+  SyntaxKind6.DoStatement
+]);
+var TOP_LEVEL_WRITE_KINDS = /* @__PURE__ */ new Set([
+  ...FUNCTION_ROOT_KINDS,
+  SyntaxKind6.BinaryExpression,
+  SyntaxKind6.ClassDeclaration
 ]);
 function descendantIsReturned(fn) {
   const consumer = climbSyntax(fn).getParent();
@@ -3180,8 +3309,8 @@ function descendantIsReturned(fn) {
 function importedModuleKeys(sourceFile) {
   const keys = [];
   for (const declaration of [
-    ...sourceFile.getImportDeclarations(),
-    ...sourceFile.getExportDeclarations()
+    ...statementsOfKind(sourceFile, SyntaxKind6.ImportDeclaration),
+    ...statementsOfKind(sourceFile, SyntaxKind6.ExportDeclaration)
   ]) {
     const moduleKey = moduleKeyOf(declaration);
     if (moduleKey !== null) {
@@ -3192,7 +3321,10 @@ function importedModuleKeys(sourceFile) {
 }
 function extractReExportFacts(db, sourceFile) {
   const filePath = sourceFile.getFilePath();
-  for (const exportDecl of sourceFile.getExportDeclarations()) {
+  for (const exportDecl of statementsOfKind(
+    sourceFile,
+    SyntaxKind6.ExportDeclaration
+  )) {
     const moduleKey = moduleKeyOf(exportDecl);
     if (moduleKey === null) {
       continue;
@@ -3249,7 +3381,7 @@ function collectDirectExports(statements, found) {
           continue;
         }
         for (const element of nameNode.getDescendantsOfKind(
-          SyntaxKind2.BindingElement
+          SyntaxKind6.BindingElement
         )) {
           const bound = element.getNameNode();
           if (Node6.isIdentifier(bound)) {
@@ -3268,7 +3400,10 @@ function collectDirectExports(statements, found) {
   }
 }
 function emitLocalExportLists(db, table, sourceFile, filePath) {
-  for (const exportDecl of sourceFile.getExportDeclarations()) {
+  for (const exportDecl of statementsOfKind(
+    sourceFile,
+    SyntaxKind6.ExportDeclaration
+  )) {
     if (exportDecl.getModuleSpecifier() !== void 0) {
       continue;
     }
@@ -3279,7 +3414,10 @@ function emitLocalExportLists(db, table, sourceFile, filePath) {
       }
     }
   }
-  for (const assignment of sourceFile.getExportAssignments()) {
+  for (const assignment of statementsOfKind(
+    sourceFile,
+    SyntaxKind6.ExportAssignment
+  )) {
     if (assignment.isExportEquals()) {
       continue;
     }
@@ -3303,7 +3441,7 @@ function emitExportedDeclaration(db, table, filePath, alias, declaration) {
   const specifier = importSpecifierOf(declaration);
   if (specifier !== null) {
     const importDecl = declaration.getFirstAncestorByKind(
-      SyntaxKind2.ImportDeclaration
+      SyntaxKind6.ImportDeclaration
     );
     const moduleKey = importDecl === void 0 ? null : moduleKeyOf(importDecl);
     if (moduleKey !== null) {
@@ -3358,7 +3496,7 @@ function emitExportedValue(db, table, filePath, name, spelling) {
 }
 
 // src/facts/localUses.ts
-import { Node as Node7, SyntaxKind as SyntaxKind3 } from "ts-morph";
+import { Node as Node7, SyntaxKind as SyntaxKind7 } from "ts-morph";
 import { UNPLACED_STORE_NAME } from "@suss/resolution";
 function fact2(db, relation, ...tuple) {
   db.add(relation, tuple);
@@ -3420,25 +3558,25 @@ function emitUse(db, table, operand2) {
   return key;
 }
 var CONSUMERS = {
-  [SyntaxKind3.PropertyAccessExpression]: emitPartRead,
-  [SyntaxKind3.ElementAccessExpression]: emitPartRead,
-  [SyntaxKind3.CallExpression]: emitWhole,
-  [SyntaxKind3.NewExpression]: emitWhole,
-  [SyntaxKind3.ArrayLiteralExpression]: emitWhole,
-  [SyntaxKind3.PropertyAssignment]: emitHolder,
-  [SyntaxKind3.ShorthandPropertyAssignment]: emitHolder,
-  [SyntaxKind3.ReturnStatement]: emitEnclosingFunction,
-  [SyntaxKind3.ArrowFunction]: emitEnclosingFunction,
-  [SyntaxKind3.Parameter]: emitEnclosingFunction,
-  [SyntaxKind3.YieldExpression]: emitYield,
-  [SyntaxKind3.VariableDeclaration]: emitNameWrite,
-  [SyntaxKind3.BinaryExpression]: emitBinary,
-  [SyntaxKind3.ConditionalExpression]: emitConditionalBranch,
-  [SyntaxKind3.SpreadElement]: emitGivenTo,
-  [SyntaxKind3.SpreadAssignment]: emitGivenTo,
-  [SyntaxKind3.JsxSpreadAttribute]: emitGivenToElement,
-  [SyntaxKind3.JsxExpression]: emitGivenToElement,
-  [SyntaxKind3.PropertyDeclaration]: emitFieldInitializer
+  [SyntaxKind7.PropertyAccessExpression]: emitPartRead,
+  [SyntaxKind7.ElementAccessExpression]: emitPartRead,
+  [SyntaxKind7.CallExpression]: emitWhole,
+  [SyntaxKind7.NewExpression]: emitWhole,
+  [SyntaxKind7.ArrayLiteralExpression]: emitWhole,
+  [SyntaxKind7.PropertyAssignment]: emitHolder,
+  [SyntaxKind7.ShorthandPropertyAssignment]: emitHolder,
+  [SyntaxKind7.ReturnStatement]: emitEnclosingFunction,
+  [SyntaxKind7.ArrowFunction]: emitEnclosingFunction,
+  [SyntaxKind7.Parameter]: emitEnclosingFunction,
+  [SyntaxKind7.YieldExpression]: emitYield,
+  [SyntaxKind7.VariableDeclaration]: emitNameWrite,
+  [SyntaxKind7.BinaryExpression]: emitBinary,
+  [SyntaxKind7.ConditionalExpression]: emitConditionalBranch,
+  [SyntaxKind7.SpreadElement]: emitGivenTo,
+  [SyntaxKind7.SpreadAssignment]: emitGivenTo,
+  [SyntaxKind7.JsxSpreadAttribute]: emitGivenToElement,
+  [SyntaxKind7.JsxExpression]: emitGivenToElement,
+  [SyntaxKind7.PropertyDeclaration]: emitFieldInitializer
 };
 function emitGivenTo(db, _table, _operand, key, parent) {
   const container = parent.getParent();
@@ -3526,16 +3664,16 @@ function emitNameWrite(db, _table, _operand, key, parent) {
   fact2(db, "mayHold", nodeId(name), key);
 }
 var WHOLE_VALUE_WRITES = /* @__PURE__ */ new Set([
-  SyntaxKind3.EqualsToken,
-  SyntaxKind3.BarBarEqualsToken,
-  SyntaxKind3.QuestionQuestionEqualsToken
+  SyntaxKind7.EqualsToken,
+  SyntaxKind7.BarBarEqualsToken,
+  SyntaxKind7.QuestionQuestionEqualsToken
 ]);
 function emitBinary(db, table, operand2, key, parent) {
   if (!Node7.isBinaryExpression(parent)) {
     return;
   }
   const operator = parent.getOperatorToken().getKind();
-  if (operator === SyntaxKind3.AmpersandAmpersandToken && parent.getRight() === operand2) {
+  if (operator === SyntaxKind7.AmpersandAmpersandToken && parent.getRight() === operand2) {
     fact2(db, "conditionalBranch", nodeId(parent), key);
     return;
   }
@@ -3611,7 +3749,7 @@ function valueWrittenThrough(name) {
   const parent = name.getParent();
   if (Node8.isElementAccessExpression(parent) && parent.getExpression() === name) {
     const assignment = parent.getParent();
-    return Node8.isBinaryExpression(assignment) && assignment.getLeft() === parent && assignment.getOperatorToken().getKind() === SyntaxKind4.EqualsToken ? assignment.getRight() : null;
+    return Node8.isBinaryExpression(assignment) && assignment.getLeft() === parent && assignment.getOperatorToken().getKind() === SyntaxKind8.EqualsToken ? assignment.getRight() : null;
   }
   if (Node8.isPropertyAccessExpression(parent) && parent.getExpression() === name && parent.getName() === MAP_ENTRY_WRITE) {
     const call = parent.getParent();
@@ -5246,12 +5384,12 @@ function forgetProgramMemos(project) {
 }
 
 // src/values/lowering.ts
-import { Node as Node11, SyntaxKind as SyntaxKind6 } from "ts-morph";
+import { Node as Node11, SyntaxKind as SyntaxKind10 } from "ts-morph";
 
 // src/resolve/unfollowedCall.ts
 import {
   Node as Node10,
-  SyntaxKind as SyntaxKind5
+  SyntaxKind as SyntaxKind9
 } from "ts-morph";
 import {
   unfollowedCallGap,
@@ -5274,14 +5412,14 @@ function isExternalDeclaration(declaration) {
     return true;
   }
   if (Node10.isImportSpecifier(declaration) || Node10.isImportClause(declaration) || Node10.isNamespaceImport(declaration)) {
-    const target = declaration.getFirstAncestorByKind(SyntaxKind5.ImportDeclaration)?.getModuleSpecifierSourceFile();
+    const target = declaration.getFirstAncestorByKind(SyntaxKind9.ImportDeclaration)?.getModuleSpecifierSourceFile();
     return target === void 0 || isInExternalCode(target);
   }
   return declaresAnotherModule(declaration);
 }
 function declaresAnotherModule(declaration) {
   const module = declaration.getFirstAncestorByKind(
-    SyntaxKind5.ModuleDeclaration
+    SyntaxKind9.ModuleDeclaration
   );
   return module !== void 0 && Node10.isStringLiteral(module.getNameNode());
 }
@@ -5534,7 +5672,7 @@ function expressionOf(node, originOf2) {
   }
   if (Node11.isPrefixUnaryExpression(node)) {
     const operator = node.getOperatorToken();
-    return operator === SyntaxKind6.ExclamationToken ? { kind: "operator", operator: "!", operands: [node.getOperand()] } : { kind: "opaque" };
+    return operator === SyntaxKind10.ExclamationToken ? { kind: "operator", operator: "!", operands: [node.getOperand()] } : { kind: "opaque" };
   }
   if (Node11.isConditionalExpression(node)) {
     return {
@@ -6295,7 +6433,7 @@ function settledChannel(argument, resolution) {
 }
 
 // src/discovery/importedCalls.ts
-import { Node as Node14 } from "ts-morph";
+import { Node as Node14, ts as ts5 } from "ts-morph";
 function callsResolvingTo(sourceFile, resolution, spec) {
   return [
     ...callsByOriginName(
@@ -6307,26 +6445,30 @@ function callsResolvingTo(sourceFile, resolution, spec) {
   ];
 }
 function callsByOriginName(sourceFile, resolution, module, names) {
+  return callsNamed(importedCallOrigins(sourceFile, resolution, module), names);
+}
+function importedCallOrigins(sourceFile, resolution, module) {
   const candidates = [];
-  sourceFile.forEachDescendant((node) => {
-    if (!Node14.isCallExpression(node) && !Node14.isNewExpression(node)) {
-      return;
-    }
-    const callee = node.getExpression();
-    if (Node14.isIdentifier(callee) && !declaredLocally(callee)) {
-      candidates.push(node);
+  forEachDescendantWhere(sourceFile, callsANamedCallee, (node) => {
+    const call = node;
+    if (!declaredLocally(call.getExpression())) {
+      candidates.push(call);
     }
+    return false;
   });
-  const matched = /* @__PURE__ */ new Map();
   if (candidates.length === 0) {
-    return matched;
+    return { candidates, origins: /* @__PURE__ */ new Map() };
   }
   const origins = resolution.importOriginsOfMany(
     candidates.map((call) => call.getExpression()),
     [module]
   );
-  for (const call of candidates) {
-    const origin = (origins.get(call.getExpression()) ?? []).find(
+  return { candidates, origins };
+}
+function callsNamed(found, names) {
+  const matched = /* @__PURE__ */ new Map();
+  for (const call of found.candidates) {
+    const origin = (found.origins.get(call.getExpression()) ?? []).find(
       (one) => one.path.length === 1 && names.has(one.path[0] ?? "")
     );
     const name = origin?.path[0];
@@ -6336,6 +6478,9 @@ function callsByOriginName(sourceFile, resolution, module, names) {
   }
   return matched;
 }
+function callsANamedCallee(raw) {
+  return (ts5.isCallExpression(raw) || ts5.isNewExpression(raw)) && ts5.isIdentifier(raw.expression);
+}
 function declaredLocally(callee) {
   const declarations = callee.getSymbol()?.getDeclarations() ?? [];
   return declarations.length > 0 && declarations.every(
@@ -6384,7 +6529,7 @@ function unitFor(call, func, match, kind, store, binding) {
 }
 
 // src/discovery/clientCall.ts
-import { Node as Node15, SyntaxKind as SyntaxKind7 } from "ts-morph";
+import { Node as Node15, SyntaxKind as SyntaxKind12 } from "ts-morph";
 import { hasNameHole } from "@suss/behavioral-ir";
 
 // src/resolve/routePath.ts
@@ -6424,6 +6569,9 @@ function propertyValueAt(arg, property, resolution, site) {
 
 // src/discovery/importScan.ts
 import path4 from "path";
+import {
+  SyntaxKind as SyntaxKind11
+} from "ts-morph";
 import { commonDirectoryOf } from "@suss/extractor";
 function specifierMatches(specifier, moduleName, subpaths) {
   if (specifier === moduleName) {
@@ -6468,7 +6616,10 @@ function importedRootsOf(sourceFile, modules, options = {}) {
   return roots;
 }
 function moduleImportedWholeAs(sourceFile, local) {
-  for (const decl of sourceFile.getImportDeclarations()) {
+  for (const decl of statementsOfKind(
+    sourceFile,
+    SyntaxKind11.ImportDeclaration
+  )) {
     const bound = decl.getNamespaceImport()?.getText() ?? decl.getDefaultImport()?.getText();
     if (bound !== local) {
       continue;
@@ -6479,7 +6630,10 @@ function moduleImportedWholeAs(sourceFile, local) {
   return null;
 }
 function specifierImportedAs(sourceFile, local) {
-  for (const decl of sourceFile.getImportDeclarations()) {
+  for (const decl of statementsOfKind(
+    sourceFile,
+    SyntaxKind11.ImportDeclaration
+  )) {
     const bound = [
       decl.getDefaultImport()?.getText(),
       decl.getNamespaceImport()?.getText(),
@@ -6510,9 +6664,11 @@ function importDeclarationsOf(sourceFile, modules, options = {}) {
 function matchingImportDeclarations(sourceFile, importModule, resolution, subpaths = false) {
   const target = isPathShapedSpecifier(importModule) ? resolvedModuleFile(sourceFile.getProject(), importModule, resolution) : null;
   if (target !== null) {
-    return sourceFile.getImportDeclarations().filter((decl) => decl.getModuleSpecifierSourceFile() === target);
+    return statementsOfKind(sourceFile, SyntaxKind11.ImportDeclaration).filter(
+      (decl) => decl.getModuleSpecifierSourceFile() === target
+    );
   }
-  return sourceFile.getImportDeclarations().filter(
+  return statementsOfKind(sourceFile, SyntaxKind11.ImportDeclaration).filter(
     (decl) => specifierMatches(decl.getModuleSpecifierValue(), importModule, subpaths)
   );
 }
@@ -6588,14 +6744,18 @@ function importedReferenceSpellings(sourceFile, importModule, importName) {
 }
 
 // src/discovery/clientCall.ts
+var CALL_KIND = /* @__PURE__ */ new Set([SyntaxKind12.CallExpression]);
+var BINDING_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind12.VariableDeclaration,
+  SyntaxKind12.Parameter
+]);
 var GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["globalThis", "window", "self", "global"]);
 function discoverClientCalls(sourceFile, match, kind, resolution, binding) {
   const results = [];
   const calls = [];
-  sourceFile.forEachDescendant((node) => {
-    if (Node15.isCallExpression(node)) {
-      calls.push(node);
-    }
+  forEachDescendantOfKinds(sourceFile, CALL_KIND, (node) => {
+    calls.push(node);
+    return false;
   });
   const matched = match.importModule === "global" ? globalCallsAmong(calls, match) : clientCallsAmong(calls, match, sourceFile, resolution);
   for (const call of calls) {
@@ -6709,7 +6869,7 @@ function clientsBuiltAtTopLevel(sourceFile, match, resolution) {
   );
 }
 function sitesToReadUnder(call, binding, resolution) {
-  const cls = call.getFirstAncestorByKind(SyntaxKind7.ClassDeclaration);
+  const cls = call.getFirstAncestorByKind(SyntaxKind12.ClassDeclaration);
   if (binding === void 0 || resolution === void 0 || cls === void 0) {
     return [void 0];
   }
@@ -6797,7 +6957,7 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
   );
   const constructedHere = /* @__PURE__ */ new Set();
   const initializedBy = /* @__PURE__ */ new Map();
-  sourceFile.forEachDescendant((node) => {
+  const visit = (node) => {
     if (Node15.isVariableDeclaration(node)) {
       const init = node.getInitializer();
       if (init !== void 0 && (Node15.isCallExpression(init) || Node15.isNewExpression(init))) {
@@ -6806,7 +6966,7 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
       if (localName !== null && typedAsClient(node.getTypeNode(), localName)) {
         constructedHere.add(node.getName());
       }
-      return;
+      return false;
     }
     if (Node15.isParameterDeclaration(node) && localName !== null && typedAsClient(node.getTypeNode(), localName)) {
       const written = node.getNameNode();
@@ -6814,7 +6974,9 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
         constructedHere.add(written.getText());
       }
     }
-  });
+    return false;
+  };
+  forEachDescendantOfKinds(sourceFile, BINDING_KINDS, visit, skipsNothing);
   const creating = creationCallsAmong(
     [...initializedBy.keys()],
     match,
@@ -7011,7 +7173,7 @@ function callableOf(member) {
 }
 
 // src/discovery/decoratorComposition.ts
-import { Node as Node17, SyntaxKind as SyntaxKind8 } from "ts-morph";
+import { Node as Node17, SyntaxKind as SyntaxKind13 } from "ts-morph";
 function classDecoratorStandingFor(cls, names, modules, resolution) {
   for (const candidate of names) {
     const decorator = cls.getDecorator(candidate);
@@ -7049,7 +7211,7 @@ function frameworkArgs(decorator, standsFor, modules, resolution) {
   if (wrapper === null) {
     return atClass;
   }
-  for (const call of wrapper.getDescendantsOfKind(SyntaxKind8.CallExpression)) {
+  for (const call of wrapper.getDescendantsOfKind(SyntaxKind13.CallExpression)) {
     const names = resolution.importedNamesOf(call.getExpression(), modules);
     if (!names.includes(standsFor)) {
       continue;
@@ -7060,7 +7222,7 @@ function frameworkArgs(decorator, standsFor, modules, resolution) {
   return atClass;
 }
 function statesAValue(arg, wrapper) {
-  const identifiers = Node17.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(SyntaxKind8.Identifier);
+  const identifiers = Node17.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(SyntaxKind13.Identifier);
   return !identifiers.some(
     (identifier) => identifier.getSymbol()?.getDeclarations().some(
       (declaration) => Node17.isParameterDeclaration(declaration) && isWithin(declaration, wrapper)
@@ -7798,7 +7960,8 @@ import picomatch from "picomatch";
 
 // src/discovery/namedExport.ts
 import {
-  Node as Node27
+  Node as Node27,
+  SyntaxKind as SyntaxKind15
 } from "ts-morph";
 
 // src/discovery/wrappedExport.ts
@@ -7808,7 +7971,7 @@ import { Node as Node26 } from "ts-morph";
 import { Node as Node23 } from "ts-morph";
 
 // src/walk/descent.ts
-import { Node as Node22 } from "ts-morph";
+import { Node as Node22, SyntaxKind as SyntaxKind14 } from "ts-morph";
 var NO_BARRIERS = /* @__PURE__ */ new Set();
 function isDescentStop(node, func, barriers = NO_BARRIERS) {
   if (node === func) {
@@ -7822,24 +7985,16 @@ function isDescentStop(node, func, barriers = NO_BARRIERS) {
   }
   return false;
 }
-function forEachInUnitBody(root, visit) {
-  root.forEachDescendant(visit);
+function forEachInUnitBodyOfKinds(root, kinds, visit) {
+  forEachInUnitBodyWhere(root, (raw) => kinds.has(raw.kind), visit);
+}
+function forEachInUnitBodyWhere(root, accepts, visit) {
+  forEachDescendantWhere(root, accepts, visit);
   for (const initializer of fieldInitializersRunBy(root)) {
-    let skipped = false;
-    visit(initializer, {
-      stop: () => {
-        skipped = true;
-      },
-      skip: () => {
-        skipped = true;
-      },
-      up: () => {
-        skipped = true;
-      }
-    });
-    if (!skipped) {
-      initializer.forEachDescendant(visit);
+    if (accepts(initializer.compilerNode) && visit(initializer)) {
+      continue;
     }
+    forEachDescendantWhere(initializer, accepts, visit);
   }
 }
 function fieldInitializersRunBy(root) {
@@ -7868,6 +8023,19 @@ function isInlineCallback(node, func, barriers = NO_BARRIERS) {
   }
   return !barriers.has(node);
 }
+var DESCENT_STOP_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind14.FunctionDeclaration,
+  SyntaxKind14.MethodDeclaration,
+  SyntaxKind14.Constructor,
+  SyntaxKind14.ArrowFunction,
+  SyntaxKind14.FunctionExpression,
+  SyntaxKind14.ClassDeclaration,
+  SyntaxKind14.ClassExpression,
+  SyntaxKind14.Decorator
+]);
+function withDescentStops(...kinds) {
+  return /* @__PURE__ */ new Set([...DESCENT_STOP_KINDS, ...kinds]);
+}
 function isModuleScopeStop(node) {
   if (isImmediatelyInvoked(node)) {
     return false;
@@ -7896,11 +8064,17 @@ function crossesNestedFunctionScope(node, func) {
   return false;
 }
 function startsItsOwnScope(node) {
-  return Node22.isArrowFunction(node) || Node22.isFunctionExpression(node) || Node22.isFunctionDeclaration(node) || Node22.isMethodDeclaration(node) || Node22.isGetAccessorDeclaration(node) || Node22.isSetAccessorDeclaration(node) || Node22.isConstructorDeclaration(node);
-}
-function containsNoCode(node) {
-  return Node22.isTypeNode(node) && !Node22.isExpressionWithTypeArguments(node);
-}
+  return OWN_SCOPE_KINDS.has(node.getKind());
+}
+var OWN_SCOPE_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind14.ArrowFunction,
+  SyntaxKind14.FunctionExpression,
+  SyntaxKind14.FunctionDeclaration,
+  SyntaxKind14.MethodDeclaration,
+  SyntaxKind14.GetAccessor,
+  SyntaxKind14.SetAccessor,
+  SyntaxKind14.Constructor
+]);
 
 // src/parameterReads.ts
 function pathAbove(reference) {
@@ -9101,7 +9275,10 @@ function discoverNamedExports(sourceFile, match, kind, resolution, options = {})
   return results;
 }
 function defaultExportUnits(sourceFile, kind, resolution, options) {
-  for (const assignment of sourceFile.getExportAssignments()) {
+  for (const assignment of statementsOfKind(
+    sourceFile,
+    SyntaxKind15.ExportAssignment
+  )) {
     if (assignment.isExportEquals()) {
       continue;
     }
@@ -10022,7 +10199,7 @@ function sameDeclaration(a, b) {
 }
 
 // src/discovery/factorySurface.ts
-import { Node as Node32, SyntaxKind as SyntaxKind9 } from "ts-morph";
+import { Node as Node32, SyntaxKind as SyntaxKind16 } from "ts-morph";
 var MAX_BUILDER_HOPS = 2;
 function surfaceMethods(decl, resolution) {
   if (Node32.isClassDeclaration(decl)) {
@@ -10037,7 +10214,7 @@ function surfaceClassMethods(cls) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const method of cls.getInstanceMethods()) {
-    if (method.hasModifier(SyntaxKind9.PrivateKeyword)) {
+    if (method.hasModifier(SyntaxKind16.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -10048,7 +10225,7 @@ function surfaceClassMethods(cls) {
     out.push({ func: method, name });
   }
   for (const method of cls.getStaticMethods()) {
-    if (method.hasModifier(SyntaxKind9.PrivateKeyword)) {
+    if (method.hasModifier(SyntaxKind16.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -11882,7 +12059,7 @@ function constructorCalledAt(construction) {
 }
 function baseConstructorCalledAt(superKeyword) {
   const owner = superKeyword.getFirstAncestorByKind(
-    SyntaxKind10.ClassDeclaration
+    SyntaxKind17.ClassDeclaration
   );
   const base = owner?.getBaseClass();
   return base === void 0 ? null : constructorOf(base);
@@ -12088,7 +12265,7 @@ function shapeFromDeclaration(decl, extractShape2, ctx) {
     return enterShape(init, extractShape2, ctx);
   }
   if (Node42.isBindingElement(decl)) {
-    const varDecl = decl.getFirstAncestorByKind(SyntaxKind11.VariableDeclaration);
+    const varDecl = decl.getFirstAncestorByKind(SyntaxKind18.VariableDeclaration);
     if (!varDecl) {
       return null;
     }
@@ -12174,7 +12351,7 @@ function isInformativeInitializer(node) {
     return isInformativeInitializer(unwrapped2.getOperand());
   }
   const kind = unwrapped2.getKind();
-  return kind === SyntaxKind11.TrueKeyword || kind === SyntaxKind11.FalseKeyword || kind === SyntaxKind11.NullKeyword;
+  return kind === SyntaxKind18.TrueKeyword || kind === SyntaxKind18.FalseKeyword || kind === SyntaxKind18.NullKeyword;
 }
 function resolveCallableBody(callee) {
   if (!Node42.isIdentifier(callee)) {
@@ -12523,7 +12700,7 @@ function parseConditionExpression(expr, depth = 0) {
     }
   }
   if (Node45.isPrefixUnaryExpression(expr)) {
-    if (expr.getOperatorToken() !== SyntaxKind12.ExclamationToken) {
+    if (expr.getOperatorToken() !== SyntaxKind19.ExclamationToken) {
       return null;
     }
     const operand2 = expr.getOperand();
@@ -12551,7 +12728,7 @@ function parseConditionExpression(expr, depth = 0) {
     const right = expr.getRight();
     const opToken = expr.getOperatorToken();
     const opText = opToken.getText();
-    if (opToken.getKind() === SyntaxKind12.AmpersandAmpersandToken) {
+    if (opToken.getKind() === SyntaxKind19.AmpersandAmpersandToken) {
       const leftPred = parseConditionExpression(left, depth);
       const rightPred = parseConditionExpression(right, depth);
       return {
@@ -12563,7 +12740,7 @@ function parseConditionExpression(expr, depth = 0) {
         ]
       };
     }
-    if (opToken.getKind() === SyntaxKind12.BarBarToken) {
+    if (opToken.getKind() === SyntaxKind19.BarBarToken) {
       const leftPred = parseConditionExpression(left, depth);
       const rightPred = parseConditionExpression(right, depth);
       return {
@@ -12575,11 +12752,11 @@ function parseConditionExpression(expr, depth = 0) {
         ]
       };
     }
-    if (opToken.getKind() === SyntaxKind12.InstanceOfKeyword) {
+    if (opToken.getKind() === SyntaxKind19.InstanceOfKeyword) {
       const subject = resolveSubject(left);
       return { type: "typeCheck", subject, expectedType: right.getText() };
     }
-    if (opToken.getKind() === SyntaxKind12.InKeyword) {
+    if (opToken.getKind() === SyntaxKind19.InKeyword) {
       if (Node45.isStringLiteral(left)) {
         const subject = resolveSubject(right);
         return {
@@ -12896,7 +13073,7 @@ function collectFallthroughCaseLabels(caseClause) {
 }
 
 // src/paths/pathConditions.ts
-import { Node as Node48 } from "ts-morph";
+import { Node as Node48, SyntaxKind as SyntaxKind21 } from "ts-morph";
 import {
   enumerateStructuredPaths,
   PathBudgetExceeded,
@@ -12906,7 +13083,9 @@ import {
 
 // src/paths/lowering.ts
 import {
-  Node as Node47
+  Node as Node47,
+  SyntaxKind as SyntaxKind20,
+  ts as ts6
 } from "ts-morph";
 import {
   UnmodeledFlow
@@ -12915,24 +13094,25 @@ var NO_ENDINGS = /* @__PURE__ */ new Set();
 function exitKindOf(stmt, endings) {
   let sawReturn = false;
   let sawThrow = false;
-  const visit = (node) => {
-    if (node !== stmt && startsItsOwnScope(node)) {
-      return;
+  const ending = new Set([...endings].map((node) => node.compilerNode));
+  const root = stmt.compilerNode;
+  const visit = (raw) => {
+    if (raw !== root && OWN_SCOPE_KINDS.has(raw.kind)) {
+      return void 0;
     }
-    if (containsNoCode(node)) {
-      return;
+    if (runsNothing(raw)) {
+      return void 0;
     }
-    if (Node47.isReturnStatement(node) || endings.has(node)) {
+    if (raw.kind === SyntaxKind20.ReturnStatement || ending.has(raw)) {
       sawReturn = true;
     }
-    if (Node47.isThrowStatement(node)) {
+    if (raw.kind === SyntaxKind20.ThrowStatement) {
       sawThrow = true;
     }
-    for (const child of node.getChildren()) {
-      visit(child);
-    }
+    ts6.forEachChild(raw, visit);
+    return void 0;
   };
-  visit(stmt);
+  visit(root);
   if (sawThrow) {
     return "throw";
   }
@@ -12947,7 +13127,20 @@ var statementsOf = (stmt) => {
   }
   return [stmt];
 };
-var isLoop = (stmt) => Node47.isForOfStatement(stmt) || Node47.isForInStatement(stmt) || Node47.isForStatement(stmt) || Node47.isWhileStatement(stmt) || Node47.isDoStatement(stmt);
+var LOOP_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind20.ForOfStatement,
+  SyntaxKind20.ForInStatement,
+  SyntaxKind20.ForStatement,
+  SyntaxKind20.WhileStatement,
+  SyntaxKind20.DoStatement
+]);
+var isLoop = (stmt) => LOOP_KINDS.has(stmt.getKind());
+var CLAUSE_BREAK_KINDS = /* @__PURE__ */ new Set([
+  ...OWN_SCOPE_KINDS,
+  ...LOOP_KINDS,
+  SyntaxKind20.SwitchStatement,
+  SyntaxKind20.BreakStatement
+]);
 function getLoopBody(stmt) {
   if (Node47.isForOfStatement(stmt) || Node47.isForInStatement(stmt) || Node47.isForStatement(stmt) || Node47.isWhileStatement(stmt) || Node47.isDoStatement(stmt)) {
     return stmt.getStatement();
@@ -13006,28 +13199,33 @@ function ownExpressionsOf(stmt) {
 }
 function lowerCallbacksIn(parts, ctx) {
   const bodies = [];
-  const visit = (node, root) => {
-    if (node !== root && isDescentStop(node, ctx.func, ctx.barriers)) {
-      return;
-    }
-    if (node !== root && (Node47.isArrowFunction(node) || Node47.isFunctionExpression(node)) && isInlineCallback(node, ctx.func, ctx.barriers)) {
-      const body = node.getBody();
-      if (body !== void 0 && Node47.isBlock(body)) {
-        bodies.push(lowerList(body.getStatements(), ctx));
-        return;
-      }
-    } else if (node !== root && startsItsOwnScope(node)) {
-      return;
+  const entersScope = (node) => {
+    if (isDescentStop(node, ctx.func, ctx.barriers)) {
+      return false;
     }
-    if (containsNoCode(node)) {
-      return;
+    if (!(Node47.isArrowFunction(node) || Node47.isFunctionExpression(node)) || !isInlineCallback(node, ctx.func, ctx.barriers)) {
+      return !startsItsOwnScope(node);
     }
-    for (const child of node.getChildren()) {
-      visit(child, root);
+    const body = node.getBody();
+    if (body !== void 0 && Node47.isBlock(body)) {
+      bodies.push(lowerList(body.getStatements(), ctx));
+      return false;
     }
+    return true;
   };
   for (const part of parts) {
-    visit(part, part);
+    const root = part.compilerNode;
+    const visit = (raw) => {
+      if (raw !== root && OWN_SCOPE_KINDS.has(raw.kind) && !entersScope(wrapperOf(part, raw))) {
+        return void 0;
+      }
+      if (runsNothing(raw)) {
+        return void 0;
+      }
+      ts6.forEachChild(raw, visit);
+      return void 0;
+    };
+    visit(root);
   }
   return bodies;
 }
@@ -13149,14 +13347,11 @@ function validateClauseBreaks(stmts) {
     if (Node47.isSwitchStatement(stmt) || isLoop(stmt)) {
       continue;
     }
-    stmt.forEachDescendant((node, traversal) => {
-      if (startsItsOwnScope(node) || Node47.isSwitchStatement(node) || isLoop(node)) {
-        traversal.skip();
-        return;
-      }
+    forEachDescendantOfKinds(stmt, CLAUSE_BREAK_KINDS, (node) => {
       if (Node47.isBreakStatement(node)) {
         throw new UnmodeledFlow("non-trailing break in switch clause");
       }
+      return true;
     });
     if (Node47.isBreakStatement(stmt)) {
       throw new UnmodeledFlow("non-trailing break in switch clause");
@@ -13211,18 +13406,20 @@ function enclosingLoweredStatement(terminal, body, rawToStructured) {
 // src/paths/pathConditions.ts
 function containsUnmodeledFlow(body, func, barriers) {
   let found = false;
-  body.forEachDescendant((node, traversal) => {
-    if (isDescentStop(node, func, barriers)) {
-      traversal.skip();
-      return;
-    }
-    if (Node48.isLabeledStatement(node)) {
-      found = true;
-      traversal.stop();
+  forEachDescendantWhere(
+    body,
+    (raw) => !found && LABELS_AND_STOPS.has(raw.kind),
+    (node) => {
+      if (isDescentStop(node, func, barriers)) {
+        return true;
+      }
+      found = Node48.isLabeledStatement(node);
+      return found;
     }
-  });
+  );
   return found;
 }
+var LABELS_AND_STOPS = withDescentStops(SyntaxKind21.LabeledStatement);
 function loweredExpressionBody(body, terminalNodes, func, barriers) {
   const statement = {
     kind: "opaque",
@@ -13385,6 +13582,8 @@ function literalAt(node, resolution) {
 // src/resolve/invocationEffects.ts
 import {
   Node as Node54,
+  SyntaxKind as SyntaxKind23,
+  ts as ts8,
   VariableDeclarationKind as VariableDeclarationKind2
 } from "ts-morph";
 import {
@@ -13402,27 +13601,43 @@ import { Node as Node51 } from "ts-morph";
 import { Node as Node50 } from "ts-morph";
 
 // src/shapes/typeText.ts
-import { ts as ts3 } from "ts-morph";
-var PRINTER = ts3.createPrinter({
+import { ts as ts7 } from "ts-morph";
+var PRINTER = ts7.createPrinter({
   removeComments: true,
-  newLine: ts3.NewLineKind.LineFeed
+  newLine: ts7.NewLineKind.LineFeed
 });
-var NO_FILE = ts3.createSourceFile("", "", ts3.ScriptTarget.Latest);
+var NO_FILE = ts7.createSourceFile("", "", ts7.ScriptTarget.Latest);
 function defaultFlags(enclosing) {
-  const flags = ts3.TypeFormatFlags.UseTypeOfFunction | ts3.TypeFormatFlags.NoTruncation | ts3.TypeFormatFlags.UseFullyQualifiedType | ts3.TypeFormatFlags.WriteTypeArgumentsOfSignature;
-  if (enclosing?.getKind() === ts3.SyntaxKind.TypeAliasDeclaration) {
-    return flags | ts3.TypeFormatFlags.InTypeAlias;
+  const flags = ts7.TypeFormatFlags.UseTypeOfFunction | ts7.TypeFormatFlags.NoTruncation | ts7.TypeFormatFlags.UseFullyQualifiedType | ts7.TypeFormatFlags.WriteTypeArgumentsOfSignature;
+  if (enclosing?.getKind() === ts7.SyntaxKind.TypeAliasDeclaration) {
+    return flags | ts7.TypeFormatFlags.InTypeAlias;
   }
   return flags;
 }
 function stableTypeText(type, reader, enclosing, flags) {
-  const checker = reader.getProject().getTypeChecker().compilerObject;
   const format = flags ?? defaultFlags(enclosing);
+  const place = enclosing?.compilerNode ?? NOWHERE;
+  const atPlace = printedAt.get(place) ?? /* @__PURE__ */ new WeakMap();
+  printedAt.set(place, atPlace);
+  const byFormat = atPlace.get(type.compilerType) ?? /* @__PURE__ */ new Map();
+  atPlace.set(type.compilerType, byFormat);
+  const kept = byFormat.get(format);
+  if (kept !== void 0) {
+    return kept;
+  }
+  const text3 = printedType(type, reader, enclosing, format);
+  byFormat.set(format, text3);
+  return text3;
+}
+var NOWHERE = {};
+var printedAt = /* @__PURE__ */ new WeakMap();
+function printedType(type, reader, enclosing, format) {
+  const checker = reader.getProject().getTypeChecker().compilerObject;
   const enclosingNode = enclosing?.compilerNode;
   const typeNode = checker.typeToTypeNode(
     type.compilerType,
     enclosingNode,
-    format & ts3.TypeFormatFlags.NodeBuilderFlagsMask | ts3.NodeBuilderFlags.IgnoreErrors
+    format & ts7.TypeFormatFlags.NodeBuilderFlagsMask | ts7.NodeBuilderFlags.IgnoreErrors
   );
   if (typeNode === void 0) {
     return withoutImportQualifiers(
@@ -13436,23 +13651,23 @@ function stableTypeText(type, reader, enclosing, flags) {
 var IMPORT_QUALIFIER = /import\("[^"]*"\)\./g;
 var withoutImportQualifiers = (text3) => text3.replace(IMPORT_QUALIFIER, "");
 function printed(node, file) {
-  return PRINTER.printNode(ts3.EmitHint.Unspecified, node, file).replace(
+  return PRINTER.printNode(ts7.EmitHint.Unspecified, node, file).replace(
     /\n/g,
     ""
   );
 }
 function containsUnion(node) {
-  if (ts3.isUnionTypeNode(node)) {
+  if (ts7.isUnionTypeNode(node)) {
     return true;
   }
-  return ts3.forEachChild(node, (child) => containsUnion(child) || void 0) === true;
+  return ts7.forEachChild(node, (child) => containsUnion(child) || void 0) === true;
 }
 function withUnionMembersOrdered(root, file) {
-  const result = ts3.transform(root, [
+  const result = ts7.transform(root, [
     (context) => {
       const visit = (node) => {
-        const visited = ts3.visitEachChild(node, visit, context);
-        if (!ts3.isUnionTypeNode(visited)) {
+        const visited = ts7.visitEachChild(node, visit, context);
+        if (!ts7.isUnionTypeNode(visited)) {
           return visited;
         }
         return context.factory.updateUnionTypeNode(
@@ -13650,7 +13865,7 @@ function rootIdentifier(node) {
 }
 
 // src/resolve/readName.ts
-import { Node as Node52, SyntaxKind as SyntaxKind13 } from "ts-morph";
+import { Node as Node52, SyntaxKind as SyntaxKind22 } from "ts-morph";
 import { patternHole, referenceName } from "@suss/behavioral-ir";
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
@@ -13748,7 +13963,7 @@ function isFallbackBranch(node) {
     return false;
   }
   const operator = step.getOperatorToken().getKind();
-  return operator === SyntaxKind13.BarBarToken || operator === SyntaxKind13.QuestionQuestionToken;
+  return operator === SyntaxKind22.BarBarToken || operator === SyntaxKind22.QuestionQuestionToken;
 }
 function fromTemplate(expr, ctx) {
   if (!Node52.isTemplateExpression(expr)) {
@@ -13766,10 +13981,10 @@ function fromBinary(expr, ctx) {
     return null;
   }
   const operator = expr.getOperatorToken().getKind();
-  if (operator === SyntaxKind13.BarBarToken || operator === SyntaxKind13.QuestionQuestionToken) {
+  if (operator === SyntaxKind22.BarBarToken || operator === SyntaxKind22.QuestionQuestionToken) {
     return ctx.insideHole ? null : read(expr.getRight(), ctx);
   }
-  if (operator !== SyntaxKind13.PlusToken) {
+  if (operator !== SyntaxKind22.PlusToken) {
     return null;
   }
   const parts = { ...ctx, insideHole: true };
@@ -14483,16 +14698,32 @@ function extractInvocationEffectsAtModuleScope(sourceFile) {
     (call) => !invokesFunctionInPlace(call.node)
   );
 }
+var CALLS_AND_STOPS = withDescentStops(SyntaxKind23.CallExpression);
+var ACCESSES_CONSTRUCTIONS_AND_STOPS = withDescentStops(
+  SyntaxKind23.PropertyAccessExpression,
+  SyntaxKind23.CallExpression,
+  SyntaxKind23.TaggedTemplateExpression,
+  SyntaxKind23.NewExpression
+);
+var INVOCATIONS_AND_STOPS = withDescentStops(
+  SyntaxKind23.CallExpression,
+  SyntaxKind23.NewExpression
+);
+var ACCESSES_AND_STOPS = withDescentStops(
+  SyntaxKind23.PropertyAccessExpression,
+  SyntaxKind23.CallExpression,
+  SyntaxKind23.TaggedTemplateExpression
+);
 function invocationsUnder(root, isStop) {
   const calls = [];
-  forEachInUnitBody(root, (node, traversal) => {
+  forEachInUnitBodyOfKinds(root, INVOCATIONS_AND_STOPS, (node) => {
     if (isStop(node)) {
-      traversal.skip();
-      return;
+      return true;
     }
     if (Node54.isCallExpression(node) || runsProjectConstructor(node)) {
       calls.push(node);
     }
+    return false;
   });
   calls.sort((a, b) => a.getEnd() - b.getEnd());
   return calls.map((call) => invocationAt(call, root));
@@ -14530,14 +14761,14 @@ function runInvocationRecognizers(func, recognizers, barriers = NO_BARRIERS, res
   const sites = [];
   const sourceFile = func.getSourceFile();
   const calls = [];
-  forEachInUnitBody(func, (node, traversal) => {
+  forEachInUnitBodyOfKinds(func, CALLS_AND_STOPS, (node) => {
     if (isDescentStop(node, func, barriers)) {
-      traversal.skip();
-      return;
+      return true;
     }
     if (Node54.isCallExpression(node)) {
       calls.push(node);
     }
+    return false;
   });
   const walk = walkArguments(calls, resolution);
   for (const node of calls) {
@@ -14697,10 +14928,11 @@ function dispatchAccessRecognizers(root, recognizers, isStop, resolution, origin
 function accessedIn(root, isStop) {
   const sites = [];
   const calls = [];
-  forEachInUnitBody(root, (node, traversal) => {
+  const own = root.compilerNode;
+  const accepts = (raw) => ACCESSES_CONSTRUCTIONS_AND_STOPS.has(raw.kind) || ts8.isParameter(raw.parent) && raw.parent.initializer === raw && raw.parent.parent === own;
+  forEachInUnitBodyWhere(root, accepts, (node) => {
     if (isStop(node) || isOwnParameterDefault(node, root)) {
-      traversal.skip();
-      return;
+      return true;
     }
     if (isAccessed(node)) {
       sites.push({ node, at: node });
@@ -14708,17 +14940,18 @@ function accessedIn(root, isStop) {
     if (Node54.isCallExpression(node) || Node54.isNewExpression(node)) {
       calls.push(node);
     }
+    return false;
   });
   for (const call of calls) {
     for (const initializer of defaultsRunBy(call)) {
-      forEachInUnitBody(initializer, (node, traversal) => {
+      forEachInUnitBodyOfKinds(initializer, ACCESSES_AND_STOPS, (node) => {
         if (isStop(node)) {
-          traversal.skip();
-          return;
+          return true;
         }
         if (isAccessed(node)) {
           sites.push({ node, at: call });
         }
+        return false;
       });
       if (isAccessed(initializer)) {
         sites.push({ node: initializer, at: call });
@@ -15455,7 +15688,7 @@ function rootOf(ref) {
 }
 
 // src/terminals/index.ts
-import { Node as Node66 } from "ts-morph";
+import { Node as Node66, SyntaxKind as SyntaxKind26 } from "ts-morph";
 
 // src/terminals/continuation.ts
 import { Node as Node57 } from "ts-morph";
@@ -15493,7 +15726,7 @@ import { constantOf as constantOf5 } from "@suss/values";
 // src/shapes/shapes.ts
 import {
   Node as Node59,
-  SyntaxKind as SyntaxKind14
+  SyntaxKind as SyntaxKind24
 } from "ts-morph";
 
 // src/shapes/typeShapes.ts
@@ -15505,6 +15738,8 @@ var current = null;
 var definitionsInProgress = () => current;
 function createDefinitionTable() {
   const shapes = /* @__PURE__ */ new Map();
+  const deferred = [];
+  let settling = false;
   return {
     has: (key) => shapes.has(key),
     reserve: (key) => {
@@ -15513,6 +15748,22 @@ function createDefinitionTable() {
     define: (key, shape) => {
       shapes.set(key, shape);
     },
+    defer: (key, expand) => {
+      deferred.push({ key, expand });
+    },
+    settle: () => {
+      if (settling) {
+        return;
+      }
+      settling = true;
+      try {
+        for (let next = deferred.shift(); next; next = deferred.shift()) {
+          shapes.set(next.key, next.expand());
+        }
+      } finally {
+        settling = false;
+      }
+    },
     // Sorted because the walk meets types in the checker's union order,
     // which changes between runs.
     collected: () => {
@@ -15882,16 +16133,16 @@ function namedOnce(type, ctx) {
   const filed = { ...named2, def: key };
   if (!table.has(key)) {
     table.reserve(key);
-    const expanded = objectToShape(type, {
-      enclosing: ctx.enclosing,
-      depth: 0,
-      seen: /* @__PURE__ */ new Set()
-    });
-    if (expanded === null) {
-      return null;
-    }
-    table.define(key, expanded);
+    table.defer(
+      key,
+      () => objectToShape(type, {
+        enclosing: ctx.enclosing,
+        depth: 0,
+        seen: /* @__PURE__ */ new Set()
+      })
+    );
   }
+  table.settle();
   return filed;
 }
 function definitionKeyFor(type, name, reader) {
@@ -16055,13 +16306,13 @@ function extractShapeInner(node) {
   }
   if (Node59.isPrefixUnaryExpression(unwrapped2)) {
     const op = unwrapped2.getOperatorToken();
-    if (op === SyntaxKind14.MinusToken || op === SyntaxKind14.PlusToken) {
+    if (op === SyntaxKind24.MinusToken || op === SyntaxKind24.PlusToken) {
       const inner = unwrapped2.getOperand();
       if (Node59.isNumericLiteral(inner)) {
         const v2 = inner.getLiteralValue();
-        const signed = op === SyntaxKind14.MinusToken ? -v2 : v2;
+        const signed = op === SyntaxKind24.MinusToken ? -v2 : v2;
         const rawBody = inner.getText();
-        const raw = op === SyntaxKind14.MinusToken ? `-${rawBody}` : rawBody;
+        const raw = op === SyntaxKind24.MinusToken ? `-${rawBody}` : rawBody;
         return numericLiteralShape(signed, raw);
       }
     }
@@ -16070,13 +16321,13 @@ function extractShapeInner(node) {
     return { type: "ref", name: "bigint" };
   }
   const kind = unwrapped2.getKind();
-  if (kind === SyntaxKind14.TrueKeyword) {
+  if (kind === SyntaxKind24.TrueKeyword) {
     return { type: "literal", value: true };
   }
-  if (kind === SyntaxKind14.FalseKeyword) {
+  if (kind === SyntaxKind24.FalseKeyword) {
     return { type: "literal", value: false };
   }
-  if (kind === SyntaxKind14.NullKeyword) {
+  if (kind === SyntaxKind24.NullKeyword) {
     return { type: "null" };
   }
   if (Node59.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
@@ -16664,7 +16915,7 @@ import {
 } from "ts-morph";
 
 // src/terminals/helperResolution.ts
-import { Node as Node62, SyntaxKind as SyntaxKind15 } from "ts-morph";
+import { Node as Node62, SyntaxKind as SyntaxKind25 } from "ts-morph";
 function resolveHelperReturn(call, resolveCallee2) {
   const callee = call.getExpression();
   if (!Node62.isIdentifier(callee)) {
@@ -16877,7 +17128,7 @@ function returnedObjects(fn) {
   }
   const found = [];
   for (const statement of body.getDescendantsOfKind(
-    SyntaxKind15.ReturnStatement
+    SyntaxKind25.ReturnStatement
   )) {
     if (enclosingFunctionOf2(statement) !== body) {
       continue;
@@ -17437,12 +17688,23 @@ function classifyThrownExpression(thrown, constructorPattern) {
 
 // src/terminals/index.ts
 var NESTED_ESCAPING_MATCH_TYPES = /* @__PURE__ */ new Set(["parameterMethodCall"]);
+var TERMINAL_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind26.ObjectLiteralExpression,
+  SyntaxKind26.ReturnStatement,
+  SyntaxKind26.ThrowStatement,
+  SyntaxKind26.CallExpression,
+  SyntaxKind26.NewExpression,
+  SyntaxKind26.ArrowFunction,
+  SyntaxKind26.FunctionExpression,
+  SyntaxKind26.FunctionDeclaration,
+  SyntaxKind26.MethodDeclaration,
+  SyntaxKind26.Constructor
+]);
 function findTerminals(func, patterns, barriers = NO_BARRIERS, resolution, originatesFrom, resolveCallee2) {
   const results = [];
-  func.forEachDescendant((node, traversal) => {
+  forEachDescendantOfKinds(func, TERMINAL_KINDS, (node) => {
     if (isDescentStop(node, func, barriers)) {
-      traversal.skip();
-      return;
+      return true;
     }
     const nested = crossesNestedFunctionScope(node, func);
     for (const pattern of patterns) {
@@ -17510,6 +17772,7 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolution, origi
         break;
       }
     }
+    return false;
   });
   if (results.length === 0 && Node66.isArrowFunction(func)) {
     const body = func.getBody();
@@ -17635,27 +17898,27 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
     return claimed.has(body) ? 0 : 1;
   }
   let unmatched = 0;
-  body.forEachDescendant((node, traversal) => {
+  forEachDescendantOfKinds(body, RETURNS_AND_SCOPES, (node) => {
     if (isDescentStop(node, func, barriers)) {
-      traversal.skip();
-      return;
+      return true;
     }
     if (startsItsOwnScope(node)) {
-      traversal.skip();
-      return;
-    }
-    if (!Node67.isReturnStatement(node)) {
-      return;
+      return true;
     }
     if (node.getExpression() === void 0) {
-      return;
+      return false;
     }
     if (!claimed.has(node)) {
       unmatched++;
     }
+    return false;
   });
   return unmatched;
 }
+var RETURNS_AND_SCOPES = /* @__PURE__ */ new Set([
+  ...OWN_SCOPE_KINDS,
+  SyntaxKind27.ReturnStatement
+]);
 function extractRawBranches(func, terminalPatterns, invocationRecognizers = [], accessRecognizers = [], barriers = NO_BARRIERS, resolution, originatesFrom, anchorCallsOf, resolveCallee2, collectCallAccounting = false, keepsArms, handOff) {
   const terminals = findTerminals(
     func,
@@ -17847,14 +18110,14 @@ function accountFor(site, terminalNodes, branches) {
 }
 
 // src/bootstrap/automaticTypes.ts
-import { ts as ts4 } from "ts-morph";
+import { ts as ts9 } from "ts-morph";
 function pinAutomaticTypes(project) {
   const options = project.getCompilerOptions();
   if (options.types !== void 0) {
     return;
   }
   project.compilerOptions.set({
-    types: ts4.getAutomaticTypeDirectiveNames(options, ts4.sys)
+    types: ts9.getAutomaticTypeDirectiveNames(options, ts9.sys)
   });
 }
 
@@ -18297,7 +18560,7 @@ function readContractForClientCall(callExpression, methodName, pattern, framewor
 
 // src/diagnostics.ts
 import path10 from "path";
-import { ts as ts5 } from "ts-morph";
+import { ts as ts10 } from "ts-morph";
 import {
   createPackTallies,
   emptyTally,
@@ -18305,23 +18568,23 @@ import {
   summaryCountsByPack
 } from "@suss/extractor";
 var DEFAULT_RESOLUTION = {
-  moduleResolution: ts5.ModuleResolutionKind.Bundler,
-  target: ts5.ScriptTarget.ESNext,
-  module: ts5.ModuleKind.ESNext
+  moduleResolution: ts10.ModuleResolutionKind.Bundler,
+  target: ts10.ScriptTarget.ESNext,
+  module: ts10.ModuleKind.ESNext
 };
 function resolutionContext(args) {
   if (args.tsConfigFilePath !== void 0) {
-    const configFile = ts5.readConfigFile(
+    const configFile = ts10.readConfigFile(
       args.tsConfigFilePath,
-      ts5.sys.readFile
+      ts10.sys.readFile
     );
     if (configFile.error !== void 0) {
       return null;
     }
     const dir = path10.dirname(args.tsConfigFilePath);
-    const parsed = ts5.parseJsonConfigFileContent(
+    const parsed = ts10.parseJsonConfigFileContent(
       configFile.config,
-      ts5.sys,
+      ts10.sys,
       dir,
       /*existingOptions*/
       void 0,
@@ -18350,11 +18613,11 @@ function unresolvedGatesFor(gates, args) {
   }
   const unresolved = [];
   for (const gate of gates) {
-    const resolved = ts5.resolveModuleName(
+    const resolved = ts10.resolveModuleName(
       gate,
       context.containingFile,
       context.options,
-      ts5.sys
+      ts10.sys
     );
     if (resolved.resolvedModule === void 0) {
       unresolved.push(gate);
@@ -18706,14 +18969,14 @@ function graphqlClientConstructions(sourceFiles, specs, resolution) {
   const store = resolution ?? new ResolutionStore();
   const found = [];
   for (const sourceFile of sourceFiles) {
+    const byModule = /* @__PURE__ */ new Map();
     for (const spec of specs) {
-      const constructions = callsByOriginName(
-        sourceFile,
-        store,
-        spec.importModule,
+      const origins = byModule.get(spec.importModule) ?? importedCallOrigins(sourceFile, store, spec.importModule);
+      byModule.set(spec.importModule, origins);
+      for (const node of callsNamed(
+        origins,
         /* @__PURE__ */ new Set([spec.importName])
-      );
-      for (const node of constructions.keys()) {
+      ).keys()) {
         found.push({ node, spec });
       }
     }
@@ -19851,7 +20114,17 @@ function scopeOf(args, wraps, resolution) {
 }
 
 // src/discoveryContext.ts
-import { Node as Node75 } from "ts-morph";
+import { Node as Node75, SyntaxKind as SyntaxKind28 } from "ts-morph";
+var NESTED_FUNCTION_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind28.FunctionDeclaration,
+  SyntaxKind28.FunctionExpression,
+  SyntaxKind28.ArrowFunction,
+  SyntaxKind28.MethodDeclaration
+]);
+var RETURNS_AND_FUNCTIONS = /* @__PURE__ */ new Set([
+  ...NESTED_FUNCTION_KINDS,
+  SyntaxKind28.ReturnStatement
+]);
 function createTsDiscoveryContext(resolution) {
   const store = resolution ?? new ResolutionStore();
   return {
@@ -19936,22 +20209,20 @@ function hasJsxReturn(func) {
     return false;
   }
   let found = false;
-  body.forEachDescendant((node, traversal) => {
-    if (found) {
-      traversal.stop();
-      return;
-    }
-    if (node !== func && (Node75.isFunctionDeclaration(node) || Node75.isFunctionExpression(node) || Node75.isArrowFunction(node) || Node75.isMethodDeclaration(node))) {
-      traversal.skip();
-      return;
-    }
-    if (Node75.isReturnStatement(node)) {
-      const expr = node.getExpression();
-      if (expr !== void 0 && isJsxOrFragment(expr)) {
-        found = true;
+  forEachDescendantWhere(
+    body,
+    (raw) => !found && RETURNS_AND_FUNCTIONS.has(raw.kind),
+    (node) => {
+      if (node !== func && NESTED_FUNCTION_KINDS.has(node.getKind())) {
+        return true;
+      }
+      if (Node75.isReturnStatement(node)) {
+        const expr = node.getExpression();
+        found = expr !== void 0 && isJsxOrFragment(expr);
       }
+      return found;
     }
-  });
+  );
   return found;
 }
 function isJsxOrFragment(node) {
@@ -20505,7 +20776,8 @@ function placeOfKey(key) {
 
 // src/resolve/reachableClosure.ts
 import {
-  Node as Node79
+  Node as Node79,
+  SyntaxKind as SyntaxKind29
 } from "ts-morph";
 import {
   functionCallBinding,
@@ -20912,6 +21184,21 @@ function resolveJsxReference(node, scan) {
     )
   };
 }
+var BODY_SCAN_KINDS = /* @__PURE__ */ new Set([
+  SyntaxKind29.CallExpression,
+  SyntaxKind29.NewExpression,
+  SyntaxKind29.JsxOpeningElement,
+  SyntaxKind29.JsxSelfClosingElement
+]);
+var MODULE_SCAN_KINDS = /* @__PURE__ */ new Set([
+  ...BODY_SCAN_KINDS,
+  SyntaxKind29.FunctionDeclaration,
+  SyntaxKind29.MethodDeclaration,
+  SyntaxKind29.ArrowFunction,
+  SyntaxKind29.FunctionExpression,
+  SyntaxKind29.ClassDeclaration,
+  SyntaxKind29.ClassExpression
+]);
 function collectReachable(root, scan) {
   const atModuleScope = Node79.isSourceFile(root);
   const inFunc = atModuleScope ? { ...scan } : { ...scan, scanning: root };
@@ -20978,31 +21265,32 @@ function collectReachable(root, scan) {
     });
   };
   const found = [];
-  forEachInUnitBody(root, (node, traversal) => {
+  const kinds = atModuleScope ? MODULE_SCAN_KINDS : BODY_SCAN_KINDS;
+  forEachInUnitBodyOfKinds(root, kinds, (node) => {
     if (atModuleScope && isModuleScopeStop(node)) {
-      traversal.skip();
-      return;
+      return true;
     }
     const jsx = resolveJsxReference(node, inFunc);
     if (jsx !== null) {
       found.push({ node, outcome: jsx.outcome });
-      return;
+      return false;
     }
     if (Node79.isNewExpression(node)) {
       const outcome2 = resolveConstruction(node, inFunc);
       if (outcome2 !== null) {
         found.push({ node, calleeText: constructionCallee(node), outcome: outcome2 });
       }
-      return;
+      return false;
     }
     if (!Node79.isCallExpression(node)) {
-      return;
+      return false;
     }
     const calleeText = normalizeCalleeText2(node.getExpression().getText());
     const outcome = resolveCallee(node, calleeText, inFunc);
     if (outcome !== null) {
       found.push({ node, calleeText, outcome });
     }
+    return false;
   });
   const settle = settleThroughStore(
     found.map((one) => one.outcome),
@@ -21775,7 +22063,8 @@ function resolveCalleeSummary(call, index) {
 
 // src/subUnitContext.ts
 import {
-  Node as Node81
+  Node as Node81,
+  SyntaxKind as SyntaxKind30
 } from "ts-morph";
 function createTsSubUnitContext() {
   return {
@@ -21787,24 +22076,19 @@ function createTsSubUnitContext() {
     readArrayLiteralText
   };
 }
-function skipNestedFunctions(parent) {
-  return (node, traversal) => {
-    if (isDescentStop(node, parent)) {
-      traversal.skip();
-      return true;
-    }
-    return false;
-  };
-}
+var JSX_ELEMENTS_AND_STOPS = withDescentStops(
+  SyntaxKind30.JsxOpeningElement,
+  SyntaxKind30.JsxSelfClosingElement
+);
+var CALLS_AND_STOPS2 = withDescentStops(SyntaxKind30.CallExpression);
 function findJsxAttributes(parent) {
   const out = [];
-  const skip = skipNestedFunctions(parent);
-  parent.forEachDescendant((node, traversal) => {
-    if (skip(node, traversal)) {
-      return;
+  forEachDescendantOfKinds(parent, JSX_ELEMENTS_AND_STOPS, (node) => {
+    if (isDescentStop(node, parent)) {
+      return true;
     }
     if (!Node81.isJsxOpeningElement(node) && !Node81.isJsxSelfClosingElement(node)) {
-      return;
+      return false;
     }
     const tag = node.getTagNameNode().getText();
     for (const attr of node.getAttributes()) {
@@ -21827,23 +22111,24 @@ function findJsxAttributes(parent) {
         valueExpression
       });
     }
+    return false;
   });
   return out;
 }
 function findCallExpressionsByName(parent, name) {
   const out = [];
-  const skip = skipNestedFunctions(parent);
-  parent.forEachDescendant((node, traversal) => {
-    if (skip(node, traversal)) {
-      return;
+  forEachDescendantOfKinds(parent, CALLS_AND_STOPS2, (node) => {
+    if (isDescentStop(node, parent)) {
+      return true;
     }
     if (!Node81.isCallExpression(node)) {
-      return;
+      return false;
     }
     const callee = node.getExpression();
     if (Node81.isIdentifier(callee) && callee.getText() === name) {
       out.push(node);
     }
+    return false;
   });
   return out;
 }
@@ -22494,17 +22779,16 @@ function extractParameters(func, inputMapping) {
 }
 function extractDependencyCalls(func, barriers = NO_BARRIERS) {
   const results = [];
-  func.forEachDescendant((node, traversal) => {
+  forEachDescendantOfKinds(func, DECLARATIONS_AND_STOPS, (node) => {
     if (isDescentStop(node, func, barriers)) {
-      traversal.skip();
-      return;
+      return true;
     }
     if (!Node82.isVariableDeclaration(node)) {
-      return;
+      return false;
     }
     const init = node.getInitializer();
     if (init === void 0) {
-      return;
+      return false;
     }
     let isAsync = false;
     let callExpr = init;
@@ -22513,7 +22797,7 @@ function extractDependencyCalls(func, barriers = NO_BARRIERS) {
       callExpr = init.getExpression();
     }
     if (!Node82.isCallExpression(callExpr)) {
-      return;
+      return false;
     }
     const calleeName = callExpr.getExpression().getText();
     const nameNode = node.getNameNode();
@@ -22531,9 +22815,11 @@ function extractDependencyCalls(func, barriers = NO_BARRIERS) {
         end: endLineOf(locationNode)
       }
     });
+    return false;
   });
   return results;
 }
+var DECLARATIONS_AND_STOPS = withDescentStops(SyntaxKind31.VariableDeclaration);
 function resolveResponseProperties(branches, calleeText, semantics) {
   return branches.map((branch) => ({
     ...branch,
@@ -23480,7 +23766,10 @@ function fileImporting(project, modulePrefix) {
     if (sourceFile.isInNodeModules() || sourceFile.isDeclarationFile()) {
       continue;
     }
-    for (const imp of sourceFile.getImportDeclarations()) {
+    for (const imp of statementsOfKind(
+      sourceFile,
+      SyntaxKind31.ImportDeclaration
+    )) {
       if (imp.getModuleSpecifierValue().startsWith(modulePrefix)) {
         return sourceFile.getFilePath();
       }
@@ -23530,10 +23819,16 @@ function internalImportsOf(project, file) {
       targets.add(target.getFilePath());
     }
   };
-  for (const imp of sourceFile.getImportDeclarations()) {
+  for (const imp of statementsOfKind(
+    sourceFile,
+    SyntaxKind31.ImportDeclaration
+  )) {
     record2(imp.getModuleSpecifierSourceFile());
   }
-  for (const exp of sourceFile.getExportDeclarations()) {
+  for (const exp of statementsOfKind(
+    sourceFile,
+    SyntaxKind31.ExportDeclaration
+  )) {
     record2(exp.getModuleSpecifierSourceFile());
   }
   return [...targets].sort();
@@ -24751,7 +25046,7 @@ function buildSubUnitSummary(subUnit, parent, parentFunc, recognizers, everyUnit
 
 // src/facts/why.ts
 import path16 from "path";
-import { Node as Node83, Project as Project3, SyntaxKind as SyntaxKind16 } from "ts-morph";
+import { Node as Node83, Project as Project3, SyntaxKind as SyntaxKind32 } from "ts-morph";
 import { explainResolutionProof, renderExplanation } from "@suss/resolution";
 var TypeScriptWhySession = class {
   project;
@@ -24793,7 +25088,7 @@ var TypeScriptWhySession = class {
       return null;
     }
     for (const call of sourceFile.getDescendantsOfKind(
-      SyntaxKind16.CallExpression
+      SyntaxKind32.CallExpression
     )) {
       const line = call.getStartLineNumber();
       if (line < startLine || line > endLine) {
@@ -24929,7 +25224,7 @@ function stubEvidence(options) {
 }
 
 // src/walk/defaulted.ts
-import { Node as Node84, SyntaxKind as SyntaxKind17 } from "ts-morph";
+import { Node as Node84, SyntaxKind as SyntaxKind33, ts as ts11 } from "ts-morph";
 function isDefaultedAt(node) {
   if (!Node84.isBindingElement(node)) {
     const read2 = climbSyntax(node);
@@ -25219,7 +25514,7 @@ function comparedValue(operand2, other, loose) {
   return missing ? operand2 : null;
 }
 function negatedOperand(node) {
-  if (Node84.isPrefixUnaryExpression(node) && node.getOperatorToken() === SyntaxKind17.ExclamationToken) {
+  if (Node84.isPrefixUnaryExpression(node) && node.getOperatorToken() === SyntaxKind33.ExclamationToken) {
     return node.getOperand();
   }
   return null;
@@ -25261,9 +25556,20 @@ function declarationInitializedBy(node) {
   return null;
 }
 function usesOf(local) {
-  return local.scope.getDescendantsOfKind(SyntaxKind17.Identifier).filter(
-    (identifier) => identifier !== local.name && refersTo(identifier, local)
-  );
+  const name = local.name.getText();
+  const file = local.scope.getSourceFile();
+  const uses = [];
+  const visit = (node) => {
+    if (ts11.isIdentifier(node) && node.text === name) {
+      const found = file.getDescendantAtPos(node.getStart(file.compilerNode));
+      if (found !== void 0 && Node84.isIdentifier(found) && found !== local.name && refersTo(found, local)) {
+        uses.push(found);
+      }
+    }
+    ts11.forEachChild(node, visit);
+  };
+  ts11.forEachChild(local.scope.compilerNode, visit);
+  return uses;
 }
 export {
   ADAPTER_VERSION,