@suss/adapter-typescript 0.37.0 → 0.38.0

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,21 +38,412 @@ 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";
 
+// src/depTracking.ts
+function createDependencySink() {
+  return { files: /* @__PURE__ */ new Set(), mountPrefixes: /* @__PURE__ */ new Map(), claims: [] };
+}
+var activeSink = null;
+function withDependencySink(sink, fn) {
+  const previous = activeSink;
+  activeSink = sink;
+  try {
+    return fn();
+  } finally {
+    activeSink = previous;
+  }
+}
+function withFilesNoted(fn) {
+  const outer = activeSink;
+  const noted = createDependencySink();
+  activeSink = noted;
+  let value;
+  try {
+    value = fn();
+  } finally {
+    activeSink = outer;
+  }
+  if (outer !== null) {
+    for (const filePath of noted.files) {
+      outer.files.add(filePath);
+    }
+    for (const [childId, prefix] of noted.mountPrefixes) {
+      outer.mountPrefixes.set(childId, prefix);
+    }
+    outer.claims.push(...noted.claims);
+  }
+  return { value, files: [...noted.files] };
+}
+function recordFileDependency(filePath) {
+  activeSink?.files.add(filePath);
+}
+function recordMountPrefix(childId, prefix) {
+  activeSink?.mountPrefixes.set(childId, prefix);
+}
+function recordUnitClaim(key, pack) {
+  activeSink?.claims.push({ key, pack });
+}
+
+// src/shapes/typeText.ts
+import { ts } from "ts-morph";
+var PRINTER = ts.createPrinter({
+  removeComments: true,
+  newLine: ts.NewLineKind.LineFeed
+});
+var NO_FILE = ts.createSourceFile("", "", ts.ScriptTarget.Latest);
+function defaultFlags(enclosing) {
+  const flags = ts.TypeFormatFlags.UseTypeOfFunction | ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseFullyQualifiedType | ts.TypeFormatFlags.WriteTypeArgumentsOfSignature;
+  if (enclosing?.getKind() === ts.SyntaxKind.TypeAliasDeclaration) {
+    return flags | ts.TypeFormatFlags.InTypeAlias;
+  }
+  return flags;
+}
+function stableTypeText(type, reader, enclosing, flags) {
+  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 & ts.TypeFormatFlags.NodeBuilderFlagsMask | ts.NodeBuilderFlags.IgnoreErrors
+  );
+  if (typeNode === void 0) {
+    return withoutImportQualifiers(
+      checker.typeToString(type.compilerType, enclosingNode, format)
+    );
+  }
+  const file = enclosing?.getSourceFile().compilerNode ?? NO_FILE;
+  const ordered = containsUnion(typeNode) ? withUnionMembersOrdered(typeNode, file) : typeNode;
+  return withoutImportQualifiers(printed(ordered, file));
+}
+var IMPORT_QUALIFIER = /import\("[^"]*"\)\./g;
+var withoutImportQualifiers = (text3) => text3.replace(IMPORT_QUALIFIER, "");
+function printed(node, file) {
+  return PRINTER.printNode(ts.EmitHint.Unspecified, node, file).replace(
+    /\n/g,
+    ""
+  );
+}
+function containsUnion(node) {
+  if (ts.isUnionTypeNode(node)) {
+    return true;
+  }
+  return ts.forEachChild(node, (child) => containsUnion(child) || void 0) === true;
+}
+function withUnionMembersOrdered(root, file) {
+  const result = ts.transform(root, [
+    (context) => {
+      const visit = (node) => {
+        const visited = ts.visitEachChild(node, visit, context);
+        if (!ts.isUnionTypeNode(visited)) {
+          return visited;
+        }
+        return context.factory.updateUnionTypeNode(
+          visited,
+          context.factory.createNodeArray(inStableOrder(visited.types, file))
+        );
+      };
+      return (node) => visit(node);
+    }
+  ]);
+  const [ordered] = result.transformed;
+  result.dispose();
+  return ordered;
+}
+function inStableOrder(members, file) {
+  return members.map((member) => ({
+    member,
+    text: withoutImportQualifiers(printed(member, file))
+  })).sort((a, b) => compareMembers(a.text, b.text)).map(({ member }) => member);
+}
+function compareMembers(a, b) {
+  return nullishRank(a) - nullishRank(b) || compareText(a, b);
+}
+function nullishRank(text3) {
+  if (text3 === "null") {
+    return 1;
+  }
+  if (text3 === "undefined") {
+    return 2;
+  }
+  return 0;
+}
+function compareText(a, b) {
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return 0;
+}
+function stablePropertyName(symbol, reader) {
+  const name = symbol.getName();
+  if (!name.startsWith("__@")) {
+    return name;
+  }
+  const checker = reader.getProject().getTypeChecker().compilerObject;
+  return checker.symbolToString(symbol.compilerSymbol);
+}
+
+// src/shapes/definitions.ts
+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) => {
+      shapes.set(key, null);
+    },
+    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: () => {
+      const out = {};
+      let any = false;
+      const keys = [...shapes.keys()].sort(compareText);
+      for (const key of keys) {
+        const shape = shapes.get(key) ?? null;
+        if (shape !== null) {
+          out[key] = shape;
+          any = true;
+        }
+      }
+      return any ? out : null;
+    },
+    shapeOf: (key) => shapes.get(key)
+  };
+}
+function withDefinitionsNoted(read2) {
+  const table = current;
+  if (table === null) {
+    return { value: read2(), noted: [] };
+  }
+  const keys = /* @__PURE__ */ new Set();
+  current = {
+    has: (key) => {
+      keys.add(key);
+      return table.has(key);
+    },
+    reserve: (key) => {
+      keys.add(key);
+      table.reserve(key);
+    },
+    define: (key, shape) => {
+      keys.add(key);
+      table.define(key, shape);
+    },
+    defer: (key, expand) => {
+      keys.add(key);
+      table.defer(key, expand);
+    },
+    settle: () => table.settle(),
+    collected: () => table.collected(),
+    shapeOf: (key) => table.shapeOf(key)
+  };
+  let value;
+  try {
+    value = read2();
+  } finally {
+    current = table;
+  }
+  const noted = [];
+  for (const key of keys) {
+    const shape = table.shapeOf(key);
+    if (shape === null || shape === void 0) {
+      return { value, noted: null };
+    }
+    noted.push([key, shape]);
+  }
+  return { value, noted };
+}
+function writeNotedDefinitions(noted) {
+  const table = current;
+  if (table === null) {
+    return;
+  }
+  for (const [key, shape] of noted) {
+    if (!table.has(key)) {
+      table.define(key, structuredClone(shape));
+    }
+  }
+}
+function withDefinitions(read2) {
+  const table = createDefinitionTable();
+  const outer = current;
+  current = table;
+  try {
+    return { value: read2(), definitions: table.collected() };
+  } finally {
+    current = outer;
+  }
+}
+
+// src/bodyWalks.ts
+var keptByBody = /* @__PURE__ */ new WeakMap();
+var talliesByRecognizer = /* @__PURE__ */ new WeakMap();
+var ids = /* @__PURE__ */ new WeakMap();
+var nextId = 1;
+function noteRecognizerTally(recognizer, tally) {
+  talliesByRecognizer.set(recognizer, tally);
+}
+function walkBodyOnce(body, inputs, walk) {
+  const key = keyOf(inputs);
+  const facts = inputs.resolution?.sourceFactCount() ?? -1;
+  const kept = keptByBody.get(body)?.find((one) => one.key === key && one.facts === facts);
+  if (kept !== void 0) {
+    return replay(kept);
+  }
+  const before = new Map(
+    [...talliesOf(inputs)].map((tally) => [tally, tally.effectsRecognized])
+  );
+  const read2 = withFilesNoted(() => withDefinitionsNoted(walk));
+  const { value, noted } = read2.value;
+  const factsAfter = inputs.resolution?.sourceFactCount() ?? -1;
+  if (noted === null || factsAfter !== facts) {
+    return value;
+  }
+  const effectsByTally = /* @__PURE__ */ new Map();
+  for (const [tally, count] of before) {
+    effectsByTally.set(tally, tally.effectsRecognized - count);
+  }
+  const entry = {
+    key,
+    facts,
+    walk: copyWalk(value),
+    definitions: noted.map(([name, shape]) => [name, structuredClone(shape)]),
+    files: read2.files,
+    effectsByTally
+  };
+  const forBody = keptByBody.get(body);
+  if (forBody === void 0) {
+    keptByBody.set(body, [entry]);
+  } else {
+    forBody.push(entry);
+  }
+  return value;
+}
+function replay(kept) {
+  writeNotedDefinitions(kept.definitions);
+  for (const filePath of kept.files) {
+    recordFileDependency(filePath);
+  }
+  for (const [tally, count] of kept.effectsByTally) {
+    tally.effectsRecognized += count;
+  }
+  return copyWalk(kept.walk);
+}
+function keyOf(inputs) {
+  const barrierIds = [...inputs.barriers].map(idOf).sort((a, b) => a - b);
+  return [
+    inputs.terminalPatterns.map(idOf).join(","),
+    idOf(inputs.invocationRecognizers),
+    idOf(inputs.accessRecognizers),
+    barrierIds.join(","),
+    inputs.resolution === void 0 ? 0 : idOf(inputs.resolution),
+    inputs.callbacks.map((present) => present ? 1 : 0).join(""),
+    // A walk with no table to write named types into notes none, so it
+    // cannot stand in for one that has a table.
+    definitionsInProgress() === null ? 0 : 1
+  ].join("|");
+}
+function idOf(value) {
+  const known = ids.get(value);
+  if (known !== void 0) {
+    return known;
+  }
+  const id = nextId++;
+  ids.set(value, id);
+  return id;
+}
+function talliesOf(inputs) {
+  const tallies = /* @__PURE__ */ new Set();
+  for (const recognizer of [
+    ...inputs.invocationRecognizers,
+    ...inputs.accessRecognizers
+  ]) {
+    const tally = talliesByRecognizer.get(recognizer);
+    if (tally !== void 0) {
+      tallies.add(tally);
+    }
+  }
+  return tallies;
+}
+function copyWalk(walk) {
+  return {
+    terminals: walk.terminals.map((found) => ({
+      ...found,
+      terminal: structuredClone(found.terminal),
+      ...found.whenAlso === void 0 ? {} : { whenAlso: copyCondition(found.whenAlso) }
+    })),
+    invocations: walk.invocations.map((site) => ({
+      ...site,
+      effect: structuredClone(site.effect)
+    })),
+    recognized: walk.recognized.map((site) => ({
+      ...site,
+      effect: structuredClone(site.effect),
+      preconditions: site.preconditions.map(copyCondition),
+      ...site.slots === void 0 ? {} : { slots: site.slots.map((slot) => ({ ...slot })) }
+    }))
+  };
+}
+function copyCondition(condition) {
+  return structuredClone(condition);
+}
+
 // src/conditions.ts
 import {
   Node as Node46
 } 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,12 +530,11 @@ 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
 import { Node as Node9 } from "ts-morph";
-import { isTestFile } from "@suss/behavioral-ir";
 import {
   clearRelations,
   Database as Database2,
@@ -179,7 +570,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 +610,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 +699,61 @@ function createPerFileCache() {
   };
 }
 
+// src/walk/rawDescent.ts
+import {
+  ts as ts2
+} 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;
+    }
+    ts2.forEachChild(raw, walk);
+    return void 0;
+  };
+  ts2.forEachChild(root.compilerNode, walk);
+}
+function runsNothing(raw) {
+  return isTypeOnlySyntax(raw) || isAmbient(raw);
+}
+function skipsNothing() {
+  return false;
+}
+function isTypeOnlySyntax(raw) {
+  return raw.kind >= ts2.SyntaxKind.FirstTypeNode && raw.kind <= ts2.SyntaxKind.LastTypeNode || TYPE_DECLARATIONS.has(raw.kind);
+}
+var TYPE_DECLARATIONS = /* @__PURE__ */ new Set([
+  ts2.SyntaxKind.TypeAliasDeclaration,
+  ts2.SyntaxKind.InterfaceDeclaration,
+  ts2.SyntaxKind.TypeParameter
+]);
+function isAmbient(raw) {
+  if (!ts2.canHaveModifiers(raw)) {
+    return false;
+  }
+  return ts2.getModifiers(raw)?.some((modifier) => modifier.kind === ts2.SyntaxKind.DeclareKeyword) ?? false;
+}
+function wrapperOf(anchor, raw) {
+  return anchor._getNodeFromCompilerNode(
+    raw
+  );
+}
+
 // src/bootstrap/sourceFileLookup.ts
 function sourceFileFor(project, moduleKey) {
   if (!isPathKey(moduleKey)) {
@@ -403,54 +857,43 @@ 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;
 }
 
-// src/depTracking.ts
-function createDependencySink() {
-  return { files: /* @__PURE__ */ new Set(), mountPrefixes: /* @__PURE__ */ new Map(), claims: [] };
-}
-var activeSink = null;
-function withDependencySink(sink, fn) {
-  const previous = activeSink;
-  activeSink = sink;
-  try {
-    return fn();
-  } finally {
-    activeSink = previous;
-  }
-}
-function recordFileDependency(filePath) {
-  activeSink?.files.add(filePath);
-}
-function recordMountPrefix(childId, prefix) {
-  activeSink?.mountPrefixes.set(childId, prefix);
+// src/testCode.ts
+import { isTestFile } from "@suss/behavioral-ir";
+function inTestFile(node) {
+  return isTestFile(node.getSourceFile().getFilePath());
 }
-function recordUnitClaim(key, pack) {
-  activeSink?.claims.push({ key, pack });
+function testCallingProduction(call, callee) {
+  return inTestFile(call) && !inTestFile(callee);
 }
 
 // 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 ts5
 } from "ts-morph";
 import {
   addEntryRows,
@@ -467,12 +910,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 ts3 } from "ts-morph";
 
 // src/facts/generatedModules.ts
 import fs from "fs";
@@ -558,6 +1001,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 +1206,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 +1235,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 +1265,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 +1285,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 +1547,7 @@ function resolutionCacheFor(project, options) {
   if (existing !== void 0) {
     return existing;
   }
-  const fresh = ts.createModuleResolutionCache(
+  const fresh = ts3.createModuleResolutionCache(
     project.getFileSystem().getCurrentDirectory(),
     (name) => name,
     options
@@ -1122,11 +1581,11 @@ function readSpecifierPaths(project, filePath, options, host) {
   if (text3 === null) {
     return [];
   }
-  const scanned = ts.preProcessFile(text3, true, true);
+  const scanned = ts3.preProcessFile(text3, true, true);
   const cache = resolutionCacheFor(project, options);
   const paths = [];
   for (const imported of scanned.importedFiles) {
-    const resolved = ts.resolveModuleName(
+    const resolved = ts3.resolveModuleName(
       imported.fileName,
       filePath,
       options,
@@ -1152,13 +1611,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 = ts3.readConfigFile(tsConfigFilePath, ts3.sys.readFile);
   if (configFile.error !== void 0) {
     return { fileNames: [], options: {} };
   }
-  const parsed = ts.parseJsonConfigFileContent(
+  const parsed = ts3.parseJsonConfigFileContent(
     configFile.config,
-    ts.sys,
+    ts3.sys,
     path3.dirname(tsConfigFilePath),
     /*existingOptions*/
     void 0,
@@ -1167,7 +1626,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) => ts3.resolveProjectReferencePath(reference)).filter((referencePath) => !seen.has(referencePath)).map((referencePath) => parseTsconfig(referencePath, seen));
   const fileNames = [
     ...new Set(referenced.flatMap((reference) => reference.fileNames))
   ];
@@ -1241,17 +1700,17 @@ function addImportersOfMatches(fileImports, matched, options) {
 }
 function internalSpecifierResolver(files, options) {
   const fileSet = new Set(files);
-  const cache = ts.createModuleResolutionCache(
-    ts.sys.getCurrentDirectory(),
+  const cache = ts3.createModuleResolutionCache(
+    ts3.sys.getCurrentDirectory(),
     (name) => name,
     options
   );
   return (fromFile, spec) => {
-    const resolved = ts.resolveModuleName(
+    const resolved = ts3.resolveModuleName(
       spec,
       fromFile,
       options,
-      ts.sys,
+      ts3.sys,
       cache
     ).resolvedModule?.resolvedFileName;
     if (resolved === void 0) {
@@ -1260,7 +1719,7 @@ function internalSpecifierResolver(files, options) {
     if (fileSet.has(resolved)) {
       return resolved;
     }
-    const real = ts.sys.realpath?.(resolved) ?? resolved;
+    const real = ts3.sys.realpath?.(resolved) ?? resolved;
     return fileSet.has(real) ? real : null;
   };
 }
@@ -1295,7 +1754,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 = ts3.preProcessFile(text3, true, false);
         results[i] = {
           path: p,
           importedModules: pre.importedFiles.map((f) => f.fileName),
@@ -1418,7 +1877,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 +1889,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 +1900,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 +1990,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 ts4, VariableDeclarationKind } from "ts-morph";
 import { valueLeftByWrites } from "@suss/resolution";
 var byFile = createPerFileCache();
 var byDeclaration = /* @__PURE__ */ new WeakMap();
@@ -1576,7 +2038,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 +2173,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 +2183,33 @@ function assignmentsInFile(sourceFile) {
         writes.push(written.write);
       }
     }
+    return false;
   });
   return found;
 }
+function mayWrite(raw) {
+  if (ts4.isBinaryExpression(raw)) {
+    return isAssignmentOperator(raw.operatorToken.kind) && (ts4.isIdentifier(raw.left) || ts4.isPropertyAccessExpression(raw.left));
+  }
+  if (ts4.isPrefixUnaryExpression(raw) || ts4.isPostfixUnaryExpression(raw)) {
+    return (raw.operator === SyntaxKind5.PlusPlusToken || raw.operator === SyntaxKind5.MinusMinusToken) && ts4.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 +2251,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 (!ts4.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 ts4.forEachChild(raw, visit);
+  };
+  return ts4.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 +2373,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) => ts4.isPropertyAccessExpression(raw) && raw.name.getText(file) === property && raw.expression.getText(file) === name && !isWriteTarget(wrapperOf(statements, raw))
+  );
 }
 
 // src/facts/languageWords.ts
@@ -1974,8 +2427,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 +2449,7 @@ function moduleKeyOf(declaration) {
 }
 function compilerResolvedPathOf(declaration, specifier) {
   const project = declaration.getProject();
-  const result = ts2.resolveModuleName(
+  const result = ts5.resolveModuleName(
     specifier,
     declaration.getSourceFile().getFilePath(),
     project.getCompilerOptions(),
@@ -2031,7 +2491,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 +2756,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) => ts5.isPropertyAccessExpression(raw) && paths.includes(compilerDottedPathOf(raw, file) ?? ""),
+    (node) => {
+      if (flowsOnward(node)) {
+        found.push(node);
+      }
+      return false;
+    }
+  );
+  return found;
+}
+function compilerDottedPathOf(raw, file) {
+  if (ts5.isIdentifier(raw)) {
+    return raw.getText(file);
+  }
+  if (ts5.isMetaProperty(raw)) {
+    const keyword = ts5.tokenToString(raw.keywordToken);
+    return `${keyword}.${raw.name.getText(file)}`;
+  }
+  if (!ts5.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 +2799,7 @@ function dottedPathOf(expression) {
     return expression.getText();
   }
   if (Node6.isMetaProperty(expression)) {
-    const keyword = ts2.tokenToString(expression.getKeywordToken());
+    const keyword = ts5.tokenToString(expression.getKeywordToken());
     return `${keyword}.${expression.getName()}`;
   }
   if (!Node6.isPropertyAccessExpression(expression)) {
@@ -2327,7 +2813,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 +2835,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 +2989,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 +3134,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 +3150,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 +3464,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 +3520,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 +3582,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 +3620,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 +3644,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 +3660,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 +3683,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 +3695,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 +3755,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 +3774,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 +3788,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 +3815,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 +3870,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 +3932,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 +4038,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 +4123,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();
@@ -3629,6 +4141,10 @@ var NOT_BASE_FACTS = /* @__PURE__ */ new Set([
   ...RESOLUTION_PROGRAM.rules.map((r) => r.head.relation),
   ...ASKING_RELATIONS
 ]);
+var DERIVED_RELATIONS = /* @__PURE__ */ new Set([
+  ...NOT_BASE_FACTS,
+  ...resolutionUnderProgram().rules.map((r) => r.head.relation)
+]);
 var QUERY_FACTS = queryFacts(RESOLUTION_PROGRAM);
 var MODULE_DEMANDS = RESOLUTION_PROGRAM.demands.filter(
   (one) => (one.relation === "moduleExport" || one.relation === "moduleForwards") && one.bound[0] === true
@@ -3665,6 +4181,8 @@ var ResolutionStore = class _ResolutionStore {
   constructionSites = /* @__PURE__ */ new Map();
   /** What each local's reads do with it, by its declaration. A local's function is walked whole, so an answer stays true. */
   localUses = /* @__PURE__ */ new Map();
+  /** See `remembered`. */
+  answers = /* @__PURE__ */ new Map();
   /** Files the most recent query read, for the memo to keep. */
   lastQueryWalked = [];
   /** See `environmentSiteFiles`; null until the first env question. */
@@ -3716,12 +4234,18 @@ var ResolutionStore = class _ResolutionStore {
    */
   resolveCallableSources(value, alsoFrom) {
     const target = factKeyOf(value);
-    return this.askAbout(
-      target,
-      "wanted",
-      () => this.lookupSources(target),
-      alsoFrom
-    );
+    const key = `sources|${nodeId(target)}|${alsoFrom?.getFilePath() ?? ""}`;
+    return [
+      ...this.remembered(
+        key,
+        () => this.askAbout(
+          target,
+          "wanted",
+          () => this.lookupSources(target),
+          alsoFrom
+        )
+      )
+    ];
   }
   /**
    * `resolveCallable` for several values, asked as one question. A file
@@ -3783,7 +4307,45 @@ var ResolutionStore = class _ResolutionStore {
   }
   resolveObject(value) {
     const target = factKeyOf(value);
-    return this.askAbout(target, "wanted", () => this.lookupObject(target));
+    return this.remembered(
+      `object|${nodeId(target)}`,
+      () => this.askAbout(target, "wanted", () => this.lookupObject(target))
+    );
+  }
+  /**
+   * A question asked again over the same facts reads the same files and
+   * derives the same answer, so the store gives back the one it found
+   * before. The files that answer read still count as read.
+   */
+  remembered(key, ask) {
+    const known = this.answers.get(key);
+    if (known !== void 0 && known.facts === this.sourceFactCount()) {
+      for (const walkedPath of known.walked) {
+        recordFileDependency(walkedPath);
+      }
+      return known.answer;
+    }
+    const answer = ask();
+    this.answers.set(key, {
+      answer,
+      walked: [...this.lastQueryWalked],
+      facts: this.sourceFactCount()
+    });
+    return answer;
+  }
+  /**
+   * How many facts the store has read from source. They are only ever
+   * added, so work that asked the store questions and found this number
+   * unchanged afterwards would get the same answers asking again.
+   */
+  sourceFactCount() {
+    let count = 0;
+    for (const relation of this.db.relationNames()) {
+      if (!DERIVED_RELATIONS.has(relation)) {
+        count += this.db.size(relation);
+      }
+    }
+    return count;
   }
   /**
    * The function a call returns: `app.use(requireCaller(config))`
@@ -3883,7 +4445,7 @@ var ResolutionStore = class _ResolutionStore {
   writtenAnswers(values, wanted) {
     const found = /* @__PURE__ */ new Map();
     const asked = /* @__PURE__ */ new Map();
-    const keyOf = /* @__PURE__ */ new Map();
+    const keyOf2 = /* @__PURE__ */ new Map();
     for (const value of values) {
       const target = factKeyOf(value);
       const key = nodeId(this.sharedDeclarationFor(target));
@@ -3898,7 +4460,7 @@ var ResolutionStore = class _ResolutionStore {
       if (!asked.has(key)) {
         asked.set(key, target);
       }
-      keyOf.set(value, key);
+      keyOf2.set(value, key);
     }
     if (asked.size === 0) {
       return found;
@@ -3913,7 +4475,7 @@ var ResolutionStore = class _ResolutionStore {
         });
       }
     });
-    for (const [value, key] of keyOf) {
+    for (const [value, key] of keyOf2) {
       found.set(value, this.writtenValues.get(key)?.[wanted] ?? null);
     }
     return found;
@@ -5196,9 +5758,6 @@ function namesPackage2(moduleKey, packages) {
     packages
   );
 }
-function inTestFile(node) {
-  return isTestFile(node.getSourceFile().getFilePath());
-}
 function declarationOf(value) {
   const nameNode = Node9.isPropertyAccessExpression(value) ? value.getNameNode() : value;
   return nameNode.getSymbol()?.getDeclarations()[0] ?? value;
@@ -5246,12 +5805,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 +5833,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 +6093,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 +6854,7 @@ function settledChannel(argument, resolution) {
 }
 
 // src/discovery/importedCalls.ts
-import { Node as Node14 } from "ts-morph";
+import { Node as Node14, ts as ts6 } from "ts-morph";
 function callsResolvingTo(sourceFile, resolution, spec) {
   return [
     ...callsByOriginName(
@@ -6307,26 +6866,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 +6899,9 @@ function callsByOriginName(sourceFile, resolution, module, names) {
   }
   return matched;
 }
+function callsANamedCallee(raw) {
+  return (ts6.isCallExpression(raw) || ts6.isNewExpression(raw)) && ts6.isIdentifier(raw.expression);
+}
 function declaredLocally(callee) {
   const declarations = callee.getSymbol()?.getDeclarations() ?? [];
   return declarations.length > 0 && declarations.every(
@@ -6384,7 +6950,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 +6990,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 +7037,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 +7051,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 +7085,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 +7165,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 +7290,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 +7378,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 +7387,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 +7395,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 +7594,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 +7632,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 +7643,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 +8381,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 +8392,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 +8406,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 +8444,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 +8485,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) {
@@ -8710,7 +9305,7 @@ function evaluateObjectLiteralAsJson(node) {
     return node.getLiteralValue();
   }
   if (Node25.isNumericLiteral(node)) {
-    return Number(node.getText());
+    return node.getLiteralValue();
   }
   const kind = node.getText();
   if (kind === "true") {
@@ -9101,7 +9696,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;
     }
@@ -9215,6 +9813,9 @@ function expandParameter(parameter, forwardsResult, depth, expanded, context, ch
   const units = [];
   let unfollowed = 0;
   for (const { call, argument } of passed) {
+    if (testCallingProduction(call, parameter)) {
+      continue;
+    }
     const caller = enclosingFunctionRoot(call);
     if (caller === null || !Node28.isCallExpression(call)) {
       unfollowed++;
@@ -10022,7 +10623,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 +10638,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 +10649,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();
@@ -10831,7 +11432,7 @@ function creationSiteBehind(parameter, resolution) {
 }
 function registrationSubjectIdsOf(sourceFile, matches, resolution) {
   const seenImports = /* @__PURE__ */ new Set();
-  const ids = /* @__PURE__ */ new Set();
+  const ids2 = /* @__PURE__ */ new Set();
   for (const match of matches) {
     const importKey = `${match.importModule}::${match.importName}`;
     if (seenImports.has(importKey)) {
@@ -10844,17 +11445,17 @@ function registrationSubjectIdsOf(sourceFile, matches, resolution) {
       match.importName,
       resolution
     ).values()) {
-      ids.add(nodeId(node));
+      ids2.add(nodeId(node));
     }
     for (const node of unboundConstructionsOf(
       sourceFile,
       match.importModule,
       match.importName
     )) {
-      ids.add(nodeId(node));
+      ids2.add(nodeId(node));
     }
   }
-  return ids;
+  return ids2;
 }
 function unboundConstructionsOf(sourceFile, importModule, importName) {
   const spellings = importedReferenceSpellings(
@@ -11882,7 +12483,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 +12689,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 +12775,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 +13124,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 +13152,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 +13164,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 +13176,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 +13497,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 +13507,9 @@ import {
 
 // src/paths/lowering.ts
 import {
-  Node as Node47
+  Node as Node47,
+  SyntaxKind as SyntaxKind20,
+  ts as ts7
 } from "ts-morph";
 import {
   UnmodeledFlow
@@ -12915,24 +13518,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);
-    }
+    ts7.forEachChild(raw, visit);
+    return void 0;
   };
-  visit(stmt);
+  visit(root);
   if (sawThrow) {
     return "throw";
   }
@@ -12947,7 +13551,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 +13623,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;
+      }
+      ts7.forEachChild(raw, visit);
+      return void 0;
+    };
+    visit(root);
   }
   return bodies;
 }
@@ -13149,14 +13771,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 +13830,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",
@@ -13359,151 +13980,49 @@ function refsOf(found, func, resolution) {
     textAt: (key) => nodes.get(key)?.getText() ?? null
   };
   return sourceRefsOf(
-    found.map((one) => one.leaf),
-    spelling
-  );
-}
-function inputOf(found, func) {
-  const { leaf, node, parameterOf } = found;
-  if (node !== null && Node49.isBindingElement(node)) {
-    return boundByParameterOf(node, func) ? { type: "input", inputRef: node.getName(), path: leaf.path } : null;
-  }
-  if (parameterOf !== func || node === null || !Node49.isParameterDeclaration(node)) {
-    return null;
-  }
-  const name = node.getNameNode();
-  return Node49.isIdentifier(name) ? { type: "input", inputRef: name.getText(), path: leaf.path } : null;
-}
-function boundByParameterOf(element, func) {
-  const parameter = element.getParent().getParent();
-  return Node49.isParameterDeclaration(parameter) && parameter.getParent() === func;
-}
-function literalAt(node, resolution) {
-  return node === void 0 ? void 0 : constantOf4(evaluatedValue(node, resolution));
-}
-
-// src/resolve/invocationEffects.ts
-import {
-  Node as Node54,
-  VariableDeclarationKind as VariableDeclarationKind2
-} from "ts-morph";
-import {
-  numberRepeatedCallSites,
-  rawConditionToPredicate
-} from "@suss/extractor";
-
-// src/resolve/callOps.ts
-import { Node as Node53 } from "ts-morph";
-
-// src/configuredCall.ts
-import { Node as Node51 } from "ts-morph";
-
-// src/values/receiverType.ts
-import { Node as Node50 } from "ts-morph";
-
-// src/shapes/typeText.ts
-import { ts as ts3 } from "ts-morph";
-var PRINTER = ts3.createPrinter({
-  removeComments: true,
-  newLine: ts3.NewLineKind.LineFeed
-});
-var NO_FILE = ts3.createSourceFile("", "", ts3.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;
-  }
-  return flags;
-}
-function stableTypeText(type, reader, enclosing, flags) {
-  const checker = reader.getProject().getTypeChecker().compilerObject;
-  const format = flags ?? defaultFlags(enclosing);
-  const enclosingNode = enclosing?.compilerNode;
-  const typeNode = checker.typeToTypeNode(
-    type.compilerType,
-    enclosingNode,
-    format & ts3.TypeFormatFlags.NodeBuilderFlagsMask | ts3.NodeBuilderFlags.IgnoreErrors
-  );
-  if (typeNode === void 0) {
-    return withoutImportQualifiers(
-      checker.typeToString(type.compilerType, enclosingNode, format)
-    );
-  }
-  const file = enclosing?.getSourceFile().compilerNode ?? NO_FILE;
-  const ordered = containsUnion(typeNode) ? withUnionMembersOrdered(typeNode, file) : typeNode;
-  return withoutImportQualifiers(printed(ordered, file));
-}
-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(
-    /\n/g,
-    ""
-  );
-}
-function containsUnion(node) {
-  if (ts3.isUnionTypeNode(node)) {
-    return true;
-  }
-  return ts3.forEachChild(node, (child) => containsUnion(child) || void 0) === true;
-}
-function withUnionMembersOrdered(root, file) {
-  const result = ts3.transform(root, [
-    (context) => {
-      const visit = (node) => {
-        const visited = ts3.visitEachChild(node, visit, context);
-        if (!ts3.isUnionTypeNode(visited)) {
-          return visited;
-        }
-        return context.factory.updateUnionTypeNode(
-          visited,
-          context.factory.createNodeArray(inStableOrder(visited.types, file))
-        );
-      };
-      return (node) => visit(node);
-    }
-  ]);
-  const [ordered] = result.transformed;
-  result.dispose();
-  return ordered;
-}
-function inStableOrder(members, file) {
-  return members.map((member) => ({
-    member,
-    text: withoutImportQualifiers(printed(member, file))
-  })).sort((a, b) => compareMembers(a.text, b.text)).map(({ member }) => member);
-}
-function compareMembers(a, b) {
-  return nullishRank(a) - nullishRank(b) || compareText(a, b);
+    found.map((one) => one.leaf),
+    spelling
+  );
 }
-function nullishRank(text3) {
-  if (text3 === "null") {
-    return 1;
+function inputOf(found, func) {
+  const { leaf, node, parameterOf } = found;
+  if (node !== null && Node49.isBindingElement(node)) {
+    return boundByParameterOf(node, func) ? { type: "input", inputRef: node.getName(), path: leaf.path } : null;
   }
-  if (text3 === "undefined") {
-    return 2;
+  if (parameterOf !== func || node === null || !Node49.isParameterDeclaration(node)) {
+    return null;
   }
-  return 0;
+  const name = node.getNameNode();
+  return Node49.isIdentifier(name) ? { type: "input", inputRef: name.getText(), path: leaf.path } : null;
 }
-function compareText(a, b) {
-  if (a < b) {
-    return -1;
-  }
-  if (a > b) {
-    return 1;
-  }
-  return 0;
+function boundByParameterOf(element, func) {
+  const parameter = element.getParent().getParent();
+  return Node49.isParameterDeclaration(parameter) && parameter.getParent() === func;
 }
-function stablePropertyName(symbol, reader) {
-  const name = symbol.getName();
-  if (!name.startsWith("__@")) {
-    return name;
-  }
-  const checker = reader.getProject().getTypeChecker().compilerObject;
-  return checker.symbolToString(symbol.compilerSymbol);
+function literalAt(node, resolution) {
+  return node === void 0 ? void 0 : constantOf4(evaluatedValue(node, resolution));
 }
 
+// src/resolve/invocationEffects.ts
+import {
+  Node as Node54,
+  SyntaxKind as SyntaxKind23,
+  ts as ts8,
+  VariableDeclarationKind as VariableDeclarationKind2
+} from "ts-morph";
+import {
+  numberRepeatedCallSites,
+  rawConditionToPredicate
+} from "@suss/extractor";
+
+// src/resolve/callOps.ts
+import { Node as Node53 } from "ts-morph";
+
+// src/configuredCall.ts
+import { Node as Node51 } from "ts-morph";
+
 // src/values/receiverType.ts
+import { Node as Node50 } from "ts-morph";
 function receiverTypesOf(node) {
   const type = node.getType();
   if (type.isAny()) {
@@ -13650,7 +14169,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 +14267,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 +14285,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 +15002,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 +15065,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 +15232,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 +15244,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 +15992,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,55 +16030,12 @@ 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
 import { createHash } from "crypto";
 import { Node as Node58, TypeFormatFlags } from "ts-morph";
-
-// src/shapes/definitions.ts
-var current = null;
-var definitionsInProgress = () => current;
-function createDefinitionTable() {
-  const shapes = /* @__PURE__ */ new Map();
-  return {
-    has: (key) => shapes.has(key),
-    reserve: (key) => {
-      shapes.set(key, null);
-    },
-    define: (key, shape) => {
-      shapes.set(key, shape);
-    },
-    // Sorted because the walk meets types in the checker's union order,
-    // which changes between runs.
-    collected: () => {
-      const out = {};
-      let any = false;
-      const keys = [...shapes.keys()].sort(compareText);
-      for (const key of keys) {
-        const shape = shapes.get(key) ?? null;
-        if (shape !== null) {
-          out[key] = shape;
-          any = true;
-        }
-      }
-      return any ? out : null;
-    }
-  };
-}
-function withDefinitions(read2) {
-  const table = createDefinitionTable();
-  const outer = current;
-  current = table;
-  try {
-    return { value: read2(), definitions: table.collected() };
-  } finally {
-    current = outer;
-  }
-}
-
-// src/shapes/typeShapes.ts
 var MAX_DEPTH = 6;
 var OPAQUE_NAMED_TYPES = /* @__PURE__ */ new Set([
   "Date",
@@ -15579,16 +16073,17 @@ function overloadIsAGuess(node) {
   if (signatures.length < 2) {
     return false;
   }
-  const returns = new Set(
-    signatures.map((signature) => signature.getReturnType().getText(node))
-  );
-  if (returns.size < 2) {
-    return false;
-  }
-  return node.getArguments().some((argument) => {
+  const untypedArgument = node.getArguments().some((argument) => {
     const type = argument.getType();
     return type.isAny() || type.isNever();
   });
+  if (!untypedArgument) {
+    return false;
+  }
+  const returns = new Set(
+    signatures.map((signature) => signature.getReturnType().getText(node))
+  );
+  return returns.size >= 2;
 }
 function typeToShape(type, ctx) {
   if (type.isAny()) {
@@ -15882,16 +16377,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 +16550,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 +16565,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 +17159,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)) {
@@ -16767,7 +17262,7 @@ function evaluateComparison(condition, substitutions) {
 }
 function numberFor(node, substitutions) {
   const resolved = Node62.isIdentifier(node) && substitutions.has(node.getText()) ? substitutions.get(node.getText()) : node;
-  return Node62.isNumericLiteral(resolved) ? Number(resolved.getText()) : null;
+  return Node62.isNumericLiteral(resolved) ? resolved.getLiteralValue() : null;
 }
 var helperBySymbol = createProgramMemo();
 function memoizedLocalHelper(callee, resolveCallee2) {
@@ -16877,7 +17372,7 @@ function returnedObjects(fn) {
   }
   const found = [];
   for (const statement of body.getDescendantsOfKind(
-    SyntaxKind15.ReturnStatement
+    SyntaxKind25.ReturnStatement
   )) {
     if (enclosingFunctionOf2(statement) !== body) {
       continue;
@@ -17437,12 +17932,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 +18016,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,55 +18142,72 @@ 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(
+  const { terminals, invocations, recognized } = walkBodyOnce(
     func,
-    terminalPatterns,
-    barriers,
-    resolution,
-    originatesFrom,
-    resolveCallee2
-  );
-  const invocations = extractInvocationEffects(func, barriers);
-  const recognized = [
-    ...runInvocationRecognizers(
-      func,
+    {
+      terminalPatterns,
       invocationRecognizers,
-      barriers,
-      resolution,
-      originatesFrom,
-      anchorCallsOf
-    ),
-    ...runAccessRecognizers(
-      func,
       accessRecognizers,
       barriers,
       resolution,
-      originatesFrom,
-      anchorCallsOf
-    )
-  ];
+      callbacks: [
+        originatesFrom !== void 0,
+        anchorCallsOf !== void 0,
+        resolveCallee2 !== void 0
+      ]
+    },
+    () => ({
+      terminals: findTerminals(
+        func,
+        terminalPatterns,
+        barriers,
+        resolution,
+        originatesFrom,
+        resolveCallee2
+      ),
+      invocations: extractInvocationEffects(func, barriers),
+      recognized: [
+        ...runInvocationRecognizers(
+          func,
+          invocationRecognizers,
+          barriers,
+          resolution,
+          originatesFrom,
+          anchorCallsOf
+        ),
+        ...runAccessRecognizers(
+          func,
+          accessRecognizers,
+          barriers,
+          resolution,
+          originatesFrom,
+          anchorCallsOf
+        )
+      ]
+    })
+  );
   const endings = new Set(
     terminals.filter(({ terminal }) => terminal.kind === "exit").map(({ node }) => node)
   );
@@ -17847,14 +18371,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 +18821,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 +18829,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 +18874,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 +19230,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 });
       }
     }
@@ -19550,6 +20074,9 @@ function callSitesOf(func, store) {
       if (!Node73.isCallExpression(passed.call)) {
         continue;
       }
+      if (testCallingProduction(passed.call, func)) {
+        continue;
+      }
       const key = siteKey(passed.call);
       const site = byCall.get(key) ?? {
         call: passed.call,
@@ -19851,7 +20378,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 +20473,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 +21040,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 +21448,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 +21529,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 +22327,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 +22340,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 +22375,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 +23043,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 +23061,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 +23079,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,
@@ -22994,13 +23544,15 @@ function resolveContractField(callSite, pack, field, resolution) {
   return value ?? void 0;
 }
 function reportingTo(recognize, tally) {
-  return (node, ctx) => {
+  const reporting = (node, ctx) => {
     const effects = recognize(node, ctx);
     if (effects !== null) {
       tally.effectsRecognized += effects.length;
     }
     return effects;
   };
+  noteRecognizerTally(reporting, tally);
+  return reporting;
 }
 function collectInvocationRecognizers(frameworks, tallies) {
   const out = [];
@@ -23480,7 +24032,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 +24085,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 +25312,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 +25354,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 +25490,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 +25780,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 +25822,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,