@suss/adapter-typescript 0.37.1 → 0.38.1

package/dist/index.js

@@ -43,6 +43,409 @@ import {
 } 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 = containsReordered(typeNode) ? withMembersOrdered(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,
+    ""
+  );
+}
+var isReordered = (node) => ts.isUnionTypeNode(node) || ts.isTypeLiteralNode(node);
+function containsReordered(node) {
+  if (isReordered(node)) {
+    return true;
+  }
+  return ts.forEachChild(node, (child) => containsReordered(child) || void 0) === true;
+}
+function withMembersOrdered(root, file) {
+  const result = ts.transform(root, [
+    (context) => {
+      const visit = (node) => {
+        const visited = ts.visitEachChild(node, visit, context);
+        if (ts.isUnionTypeNode(visited)) {
+          return context.factory.updateUnionTypeNode(
+            visited,
+            context.factory.createNodeArray(inStableOrder(visited.types, file))
+          );
+        }
+        if (ts.isTypeLiteralNode(visited)) {
+          return context.factory.updateTypeLiteralNode(
+            visited,
+            context.factory.createNodeArray(inNameOrder(visited.members, file))
+          );
+        }
+        return visited;
+      };
+      return (node) => visit(node);
+    }
+  ]);
+  const [ordered] = result.transformed;
+  result.dispose();
+  return ordered;
+}
+function inNameOrder(members, file) {
+  return members.map((member) => ({
+    member,
+    name: member.name === void 0 ? "" : printed(member.name, file)
+  })).sort((a, b) => compareText(a.name, b.name)).map(({ member }) => member);
+}
+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
@@ -145,11 +548,11 @@ 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,
   evaluate as evaluate2,
+  noteReads,
   proofOf,
   tupleKey,
   tupleKeyParts,
@@ -312,7 +715,7 @@ function createPerFileCache() {
 
 // src/walk/rawDescent.ts
 import {
-  ts
+  ts as ts2
 } from "ts-morph";
 function statementsOfKind(file, kind) {
   const found = [];
@@ -334,10 +737,10 @@ function forEachDescendantWhere(root, accepts, visit, skips = runsNothing) {
     if (accepts(raw) && visit(wrapperOf(root, raw)) === true) {
       return void 0;
     }
-    ts.forEachChild(raw, walk);
+    ts2.forEachChild(raw, walk);
     return void 0;
   };
-  ts.forEachChild(root.compilerNode, walk);
+  ts2.forEachChild(root.compilerNode, walk);
 }
 function runsNothing(raw) {
   return isTypeOnlySyntax(raw) || isAmbient(raw);
@@ -346,18 +749,18 @@ function skipsNothing() {
   return false;
 }
 function isTypeOnlySyntax(raw) {
-  return raw.kind >= ts.SyntaxKind.FirstTypeNode && raw.kind <= ts.SyntaxKind.LastTypeNode || TYPE_DECLARATIONS.has(raw.kind);
+  return raw.kind >= ts2.SyntaxKind.FirstTypeNode && raw.kind <= ts2.SyntaxKind.LastTypeNode || TYPE_DECLARATIONS.has(raw.kind);
 }
 var TYPE_DECLARATIONS = /* @__PURE__ */ new Set([
-  ts.SyntaxKind.TypeAliasDeclaration,
-  ts.SyntaxKind.InterfaceDeclaration,
-  ts.SyntaxKind.TypeParameter
+  ts2.SyntaxKind.TypeAliasDeclaration,
+  ts2.SyntaxKind.InterfaceDeclaration,
+  ts2.SyntaxKind.TypeParameter
 ]);
 function isAmbient(raw) {
-  if (!ts.canHaveModifiers(raw)) {
+  if (!ts2.canHaveModifiers(raw)) {
     return false;
   }
-  return ts.getModifiers(raw)?.some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword) ?? false;
+  return ts2.getModifiers(raw)?.some((modifier) => modifier.kind === ts2.SyntaxKind.DeclareKeyword) ?? false;
 }
 function wrapperOf(anchor, raw) {
   return anchor._getNodeFromCompilerNode(
@@ -483,31 +886,16 @@ function indexFunctions(sf) {
     },
     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);
+  return index;
 }
-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
@@ -519,7 +907,7 @@ import {
   ModuleDeclarationKind,
   Node as Node6,
   SyntaxKind as SyntaxKind6,
-  ts as ts4
+  ts as ts5
 } from "ts-morph";
 import {
   addEntryRows,
@@ -541,7 +929,7 @@ 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 as ts2 } from "ts-morph";
+import { ts as ts3 } from "ts-morph";
 
 // src/facts/generatedModules.ts
 import fs from "fs";
@@ -1173,7 +1561,7 @@ function resolutionCacheFor(project, options) {
   if (existing !== void 0) {
     return existing;
   }
-  const fresh = ts2.createModuleResolutionCache(
+  const fresh = ts3.createModuleResolutionCache(
     project.getFileSystem().getCurrentDirectory(),
     (name) => name,
     options
@@ -1207,11 +1595,11 @@ function readSpecifierPaths(project, filePath, options, host) {
   if (text3 === null) {
     return [];
   }
-  const scanned = ts2.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 = ts2.resolveModuleName(
+    const resolved = ts3.resolveModuleName(
       imported.fileName,
       filePath,
       options,
@@ -1237,13 +1625,13 @@ function readFileText(project, filePath) {
 }
 function parseTsconfig(tsConfigFilePath, seen = /* @__PURE__ */ new Set()) {
   seen.add(tsConfigFilePath);
-  const configFile = ts2.readConfigFile(tsConfigFilePath, ts2.sys.readFile);
+  const configFile = ts3.readConfigFile(tsConfigFilePath, ts3.sys.readFile);
   if (configFile.error !== void 0) {
     return { fileNames: [], options: {} };
   }
-  const parsed = ts2.parseJsonConfigFileContent(
+  const parsed = ts3.parseJsonConfigFileContent(
     configFile.config,
-    ts2.sys,
+    ts3.sys,
     path3.dirname(tsConfigFilePath),
     /*existingOptions*/
     void 0,
@@ -1252,7 +1640,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) => ts2.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))
   ];
@@ -1326,17 +1714,17 @@ function addImportersOfMatches(fileImports, matched, options) {
 }
 function internalSpecifierResolver(files, options) {
   const fileSet = new Set(files);
-  const cache = ts2.createModuleResolutionCache(
-    ts2.sys.getCurrentDirectory(),
+  const cache = ts3.createModuleResolutionCache(
+    ts3.sys.getCurrentDirectory(),
     (name) => name,
     options
   );
   return (fromFile, spec) => {
-    const resolved = ts2.resolveModuleName(
+    const resolved = ts3.resolveModuleName(
       spec,
       fromFile,
       options,
-      ts2.sys,
+      ts3.sys,
       cache
     ).resolvedModule?.resolvedFileName;
     if (resolved === void 0) {
@@ -1345,7 +1733,7 @@ function internalSpecifierResolver(files, options) {
     if (fileSet.has(resolved)) {
       return resolved;
     }
-    const real = ts2.sys.realpath?.(resolved) ?? resolved;
+    const real = ts3.sys.realpath?.(resolved) ?? resolved;
     return fileSet.has(real) ? real : null;
   };
 }
@@ -1380,7 +1768,7 @@ async function readImportsConcurrently(paths, marks) {
       const p = paths[i];
       try {
         const text3 = await fs2.readFile(p, "utf-8");
-        const pre = ts2.preProcessFile(text3, true, false);
+        const pre = ts3.preProcessFile(text3, true, false);
         results[i] = {
           path: p,
           importedModules: pre.importedFiles.map((f) => f.fileName),
@@ -1616,7 +2004,7 @@ function keyNameOf(name) {
 }
 
 // src/facts/assignments.ts
-import { Node as Node5, SyntaxKind as SyntaxKind5, ts as ts3, 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();
@@ -1814,11 +2202,11 @@ function assignmentsInFile(sourceFile) {
   return found;
 }
 function mayWrite(raw) {
-  if (ts3.isBinaryExpression(raw)) {
-    return isAssignmentOperator(raw.operatorToken.kind) && (ts3.isIdentifier(raw.left) || ts3.isPropertyAccessExpression(raw.left));
+  if (ts4.isBinaryExpression(raw)) {
+    return isAssignmentOperator(raw.operatorToken.kind) && (ts4.isIdentifier(raw.left) || ts4.isPropertyAccessExpression(raw.left));
   }
-  if (ts3.isPrefixUnaryExpression(raw) || ts3.isPostfixUnaryExpression(raw)) {
-    return (raw.operator === SyntaxKind5.PlusPlusToken || raw.operator === SyntaxKind5.MinusMinusToken) && ts3.isIdentifier(raw.operand);
+  if (ts4.isPrefixUnaryExpression(raw) || ts4.isPostfixUnaryExpression(raw)) {
+    return (raw.operator === SyntaxKind5.PlusPlusToken || raw.operator === SyntaxKind5.MinusMinusToken) && ts4.isIdentifier(raw.operand);
   }
   return false;
 }
@@ -1879,7 +2267,7 @@ function isReadBefore(declaration, position) {
   const sourceFile = declaration.getSourceFile();
   const file = sourceFile.compilerNode;
   const readsHere = (raw) => {
-    if (!ts3.isIdentifier(raw) || raw.getText(file) !== name) {
+    if (!ts4.isIdentifier(raw) || raw.getText(file) !== name) {
       return false;
     }
     const node = wrapperOf(sourceFile, raw);
@@ -1899,9 +2287,9 @@ function someBefore(root, position, test) {
     if (test(raw)) {
       return true;
     }
-    return ts3.forEachChild(raw, visit);
+    return ts4.forEachChild(raw, visit);
   };
-  return ts3.forEachChild(root, visit) === true;
+  return ts4.forEachChild(root, visit) === true;
 }
 var OWN_BODY_KINDS = /* @__PURE__ */ new Set([
   SyntaxKind5.FunctionDeclaration,
@@ -2003,7 +2391,7 @@ function isPropertyReadBefore(statements, name, property, position) {
   return someBefore(
     statements.compilerNode,
     position,
-    (raw) => ts3.isPropertyAccessExpression(raw) && raw.name.getText(file) === property && raw.expression.getText(file) === name && !isWriteTarget(wrapperOf(statements, raw))
+    (raw) => ts4.isPropertyAccessExpression(raw) && raw.name.getText(file) === property && raw.expression.getText(file) === name && !isWriteTarget(wrapperOf(statements, raw))
   );
 }
 
@@ -2075,7 +2463,7 @@ function moduleKeyOf(declaration) {
 }
 function compilerResolvedPathOf(declaration, specifier) {
   const project = declaration.getProject();
-  const result = ts4.resolveModuleName(
+  const result = ts5.resolveModuleName(
     specifier,
     declaration.getSourceFile().getFilePath(),
     project.getCompilerOptions(),
@@ -2386,7 +2774,7 @@ function spellingsHandedOn(paths, sourceFile) {
   const found = [];
   forEachDescendantWhere(
     sourceFile,
-    (raw) => ts4.isPropertyAccessExpression(raw) && paths.includes(compilerDottedPathOf(raw, file) ?? ""),
+    (raw) => ts5.isPropertyAccessExpression(raw) && paths.includes(compilerDottedPathOf(raw, file) ?? ""),
     (node) => {
       if (flowsOnward(node)) {
         found.push(node);
@@ -2397,14 +2785,14 @@ function spellingsHandedOn(paths, sourceFile) {
   return found;
 }
 function compilerDottedPathOf(raw, file) {
-  if (ts4.isIdentifier(raw)) {
+  if (ts5.isIdentifier(raw)) {
     return raw.getText(file);
   }
-  if (ts4.isMetaProperty(raw)) {
-    const keyword = ts4.tokenToString(raw.keywordToken);
+  if (ts5.isMetaProperty(raw)) {
+    const keyword = ts5.tokenToString(raw.keywordToken);
     return `${keyword}.${raw.name.getText(file)}`;
   }
-  if (!ts4.isPropertyAccessExpression(raw)) {
+  if (!ts5.isPropertyAccessExpression(raw)) {
     return null;
   }
   const object = compilerDottedPathOf(raw.expression, file);
@@ -2425,7 +2813,7 @@ function dottedPathOf(expression) {
     return expression.getText();
   }
   if (Node6.isMetaProperty(expression)) {
-    const keyword = ts4.tokenToString(expression.getKeywordToken());
+    const keyword = ts5.tokenToString(expression.getKeywordToken());
     return `${keyword}.${expression.getName()}`;
   }
   if (!Node6.isPropertyAccessExpression(expression)) {
@@ -3767,7 +4155,12 @@ 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 DERIVED_AGAIN = new Set(QUERY_FACTS);
 var MODULE_DEMANDS = RESOLUTION_PROGRAM.demands.filter(
   (one) => (one.relation === "moduleExport" || one.relation === "moduleForwards") && one.bound[0] === true
 ).map((one) => one.demand);
@@ -3803,6 +4196,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. */
@@ -3854,12 +4249,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
@@ -3921,7 +4322,65 @@ 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, when no fact its derivation looked up has
+   * arrived since, 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.
+   *
+   * Noting the lookups costs the question a share of its time, and most
+   * questions are asked once, so a question notes them only once it has
+   * had to be asked again. Until then, as without demand, only an
+   * unchanged fact count says the answer is the same. Without demand the
+   * rules keep every conclusion between questions, so a question's own
+   * lookups miss what earlier questions derived for it. A question that
+   * started on another question's leftovers gets the count too.
+   */
+  remembered(key, ask) {
+    const known = this.answers.get(key);
+    if (known !== void 0 && this.stillDerives(known.check)) {
+      for (const walkedPath of known.walked) {
+        recordFileDependency(walkedPath);
+      }
+      return known.answer;
+    }
+    const { value, reads } = known === void 0 || QUERY_FACTS.length === 0 ? { value: ask(), reads: null } : noteReads(this.db, DERIVED_AGAIN, ask);
+    this.answers.set(key, {
+      answer: value,
+      walked: [...this.lastQueryWalked],
+      check: reads ?? this.sourceFactCount()
+    });
+    return value;
+  }
+  /**
+   * Facts added since the last derivation have not reached the relations
+   * the rules keep between questions, so the reads cannot say yet what
+   * those facts change.
+   */
+  stillDerives(check) {
+    if (typeof check === "number") {
+      return check === this.sourceFactCount();
+    }
+    return !this.stale && check.unchangedIn(this.db);
+  }
+  /**
+   * 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))`
@@ -4021,7 +4480,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));
@@ -4036,7 +4495,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;
@@ -4051,7 +4510,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;
@@ -5334,9 +5793,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;
@@ -6433,7 +6889,7 @@ function settledChannel(argument, resolution) {
 }
 
 // src/discovery/importedCalls.ts
-import { Node as Node14, ts as ts5 } from "ts-morph";
+import { Node as Node14, ts as ts6 } from "ts-morph";
 function callsResolvingTo(sourceFile, resolution, spec) {
   return [
     ...callsByOriginName(
@@ -6451,7 +6907,8 @@ function importedCallOrigins(sourceFile, resolution, module) {
   const candidates = [];
   forEachDescendantWhere(sourceFile, callsANamedCallee, (node) => {
     const call = node;
-    if (!declaredLocally(call.getExpression())) {
+    const callee = call.getExpression();
+    if (!declaredLocally(callee) && !importedFromAnotherPackage(callee, module)) {
       candidates.push(call);
     }
     return false;
@@ -6479,7 +6936,27 @@ function callsNamed(found, names) {
   return matched;
 }
 function callsANamedCallee(raw) {
-  return (ts5.isCallExpression(raw) || ts5.isNewExpression(raw)) && ts5.isIdentifier(raw.expression);
+  return (ts6.isCallExpression(raw) || ts6.isNewExpression(raw)) && ts6.isIdentifier(raw.expression);
+}
+var samePackage = (specifier, module) => specifier === module || specifier.startsWith(`${module}/`) || module.startsWith(`${specifier}/`);
+function importOf(declaration) {
+  if (Node14.isImportSpecifier(declaration)) {
+    return declaration.getImportDeclaration();
+  }
+  const parent = Node14.isImportClause(declaration) ? declaration.getParent() : void 0;
+  return parent !== void 0 && Node14.isImportDeclaration(parent) ? parent : void 0;
+}
+function importedFromAnotherPackage(callee, module) {
+  const declarations = callee.getSymbol()?.getDeclarations() ?? [];
+  return declarations.length > 0 && declarations.every((declaration) => {
+    const from = importOf(declaration);
+    if (from === void 0) {
+      return false;
+    }
+    const resolved = from.getModuleSpecifierSourceFile();
+    const specifier = from.getModuleSpecifierValue();
+    return (resolved === void 0 || resolved.isInNodeModules()) && !specifier.startsWith(".") && !samePackage(specifier, module);
+  });
 }
 function declaredLocally(callee) {
   const declarations = callee.getSymbol()?.getDeclarations() ?? [];
@@ -8884,7 +9361,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") {
@@ -9392,6 +9869,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++;
@@ -11008,7 +11488,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)) {
@@ -11021,17 +11501,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(
@@ -13085,7 +13565,7 @@ import {
 import {
   Node as Node47,
   SyntaxKind as SyntaxKind20,
-  ts as ts6
+  ts as ts7
 } from "ts-morph";
 import {
   UnmodeledFlow
@@ -13109,7 +13589,7 @@ function exitKindOf(stmt, endings) {
     if (raw.kind === SyntaxKind20.ThrowStatement) {
       sawThrow = true;
     }
-    ts6.forEachChild(raw, visit);
+    ts7.forEachChild(raw, visit);
     return void 0;
   };
   visit(root);
@@ -13222,7 +13702,7 @@ function lowerCallbacksIn(parts, ctx) {
       if (runsNothing(raw)) {
         return void 0;
       }
-      ts6.forEachChild(raw, visit);
+      ts7.forEachChild(raw, visit);
       return void 0;
     };
     visit(root);
@@ -13599,126 +14079,6 @@ 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 ts7 } from "ts-morph";
-var PRINTER = ts7.createPrinter({
-  removeComments: true,
-  newLine: ts7.NewLineKind.LineFeed
-});
-var NO_FILE = ts7.createSourceFile("", "", ts7.ScriptTarget.Latest);
-function defaultFlags(enclosing) {
-  const flags = ts7.TypeFormatFlags.UseTypeOfFunction | ts7.TypeFormatFlags.NoTruncation | ts7.TypeFormatFlags.UseFullyQualifiedType | ts7.TypeFormatFlags.WriteTypeArgumentsOfSignature;
-  if (enclosing?.getKind() === ts7.SyntaxKind.TypeAliasDeclaration) {
-    return flags | ts7.TypeFormatFlags.InTypeAlias;
-  }
-  return flags;
-}
-function stableTypeText(type, reader, enclosing, flags) {
-  const 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 & ts7.TypeFormatFlags.NodeBuilderFlagsMask | ts7.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(ts7.EmitHint.Unspecified, node, file).replace(
-    /\n/g,
-    ""
-  );
-}
-function containsUnion(node) {
-  if (ts7.isUnionTypeNode(node)) {
-    return true;
-  }
-  return ts7.forEachChild(node, (child) => containsUnion(child) || void 0) === true;
-}
-function withUnionMembersOrdered(root, file) {
-  const result = ts7.transform(root, [
-    (context) => {
-      const visit = (node) => {
-        const visited = ts7.visitEachChild(node, visit, context);
-        if (!ts7.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/values/receiverType.ts
 function receiverTypesOf(node) {
   const type = node.getType();
   if (type.isAny()) {
@@ -15732,67 +16092,6 @@ import {
 // 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();
-  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;
-    }
-  };
-}
-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",
@@ -15830,16 +16129,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()) {
@@ -17018,7 +17318,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) {
@@ -17920,33 +18220,50 @@ var RETURNS_AND_SCOPES = /* @__PURE__ */ new Set([
   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)
   );
@@ -19813,6 +20130,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,
@@ -23280,13 +23600,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 = [];