@suss/adapter-typescript 0.12.0 → 0.13.0

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   ADAPTER_VERSION: () => ADAPTER_VERSION,
   ResolutionStore: () => ResolutionStore,
   WhySession: () => WhySession,
+  accessContextFor: () => accessContextFor,
   callOpsFor: () => callOpsFor,
   collectAncestorBranches: () => collectAncestorBranches,
   collectClientFieldAccesses: () => collectClientFieldAccesses,
@@ -50,6 +51,7 @@ __export(index_exports, {
   findNearestTsconfig: () => findNearestTsconfig,
   findTerminals: () => findTerminals,
   formatPackHealth: () => formatPackHealth,
+  invocationContextFor: () => invocationContextFor,
   isImportedFrom: () => isImportedFrom,
   methodDeclaredIn: () => methodDeclaredIn,
   parseConditionExpression: () => parseConditionExpression,
@@ -66,8 +68,8 @@ module.exports = __toCommonJS(index_exports);
 
 // src/adapter.ts
 var import_node_path9 = __toESM(require("path"), 1);
-var import_ts_morph59 = require("ts-morph");
-var import_behavioral_ir7 = require("@suss/behavioral-ir");
+var import_ts_morph60 = require("ts-morph");
+var import_behavioral_ir8 = require("@suss/behavioral-ir");
 var import_datalog6 = require("@suss/datalog");
 var import_extractor5 = require("@suss/extractor");
 
@@ -296,14 +298,14 @@ function dedupe(shapes) {
   return out;
 }
 function isInformativeInitializer(node) {
-  const unwrapped = peelSyntax(node);
-  if (import_ts_morph2.Node.isStringLiteral(unwrapped) || import_ts_morph2.Node.isNoSubstitutionTemplateLiteral(unwrapped) || import_ts_morph2.Node.isNumericLiteral(unwrapped) || import_ts_morph2.Node.isBigIntLiteral(unwrapped) || import_ts_morph2.Node.isObjectLiteralExpression(unwrapped) || import_ts_morph2.Node.isArrayLiteralExpression(unwrapped) || import_ts_morph2.Node.isTemplateExpression(unwrapped) || import_ts_morph2.Node.isConditionalExpression(unwrapped) || import_ts_morph2.Node.isIdentifier(unwrapped) || import_ts_morph2.Node.isPropertyAccessExpression(unwrapped) || import_ts_morph2.Node.isElementAccessExpression(unwrapped)) {
+  const unwrapped2 = peelSyntax(node);
+  if (import_ts_morph2.Node.isStringLiteral(unwrapped2) || import_ts_morph2.Node.isNoSubstitutionTemplateLiteral(unwrapped2) || import_ts_morph2.Node.isNumericLiteral(unwrapped2) || import_ts_morph2.Node.isBigIntLiteral(unwrapped2) || import_ts_morph2.Node.isObjectLiteralExpression(unwrapped2) || import_ts_morph2.Node.isArrayLiteralExpression(unwrapped2) || import_ts_morph2.Node.isTemplateExpression(unwrapped2) || import_ts_morph2.Node.isConditionalExpression(unwrapped2) || import_ts_morph2.Node.isIdentifier(unwrapped2) || import_ts_morph2.Node.isPropertyAccessExpression(unwrapped2) || import_ts_morph2.Node.isElementAccessExpression(unwrapped2)) {
     return true;
   }
-  if (import_ts_morph2.Node.isPrefixUnaryExpression(unwrapped)) {
-    return isInformativeInitializer(unwrapped.getOperand());
+  if (import_ts_morph2.Node.isPrefixUnaryExpression(unwrapped2)) {
+    return isInformativeInitializer(unwrapped2.getOperand());
   }
-  const kind = unwrapped.getKind();
+  const kind = unwrapped2.getKind();
   return kind === import_ts_morph2.SyntaxKind.TrueKeyword || kind === import_ts_morph2.SyntaxKind.FalseKeyword || kind === import_ts_morph2.SyntaxKind.NullKeyword;
 }
 function resolveCallableBody(callee) {
@@ -1612,8 +1614,8 @@ var ModuleGraph = class {
    * earlier walk settled stops it for the same reason.
    */
   settle(root, name) {
-    const settled = this.settledOf(name);
-    if (settled.has(root.getFilePath())) {
+    const settled2 = this.settledOf(name);
+    if (settled2.has(root.getFilePath())) {
       return;
     }
     const walked = /* @__PURE__ */ new Set();
@@ -1621,7 +1623,7 @@ var ModuleGraph = class {
     while (stack.length > 0) {
       const current2 = stack.pop();
       const currentPath = current2.getFilePath();
-      if (walked.has(currentPath) || settled.has(currentPath)) {
+      if (walked.has(currentPath) || settled2.has(currentPath)) {
         continue;
       }
       walked.add(currentPath);
@@ -1632,7 +1634,7 @@ var ModuleGraph = class {
       stack.push(...this.importedFilesOf(current2));
     }
     for (const filePath of walked) {
-      settled.add(filePath);
+      settled2.add(filePath);
     }
   }
   settledOf(name) {
@@ -2681,15 +2683,28 @@ function holeName(expr, ctx) {
 }
 
 // src/resolve/callOps.ts
+var MAX_WRITTEN_HOPS = 4;
 var ORIGIN = {
-  declaredBy: (origin, receiver) => origin.importedFrom.some(
+  declaredBy: (origin, receiver) => receiver.callee !== null && origin.importedFrom.some(
     (module2) => methodDeclaredIn(receiver.callee, module2, receiver.resolve)
   ),
   constructed: (origin, receiver) => origin.importedFrom.some(
     (module2) => isImportedFrom(madeBy(receiver), module2)
   )
 };
+var CALL_ORIGIN = {
+  declaredBy: ORIGIN.declaredBy,
+  constructed: (origin, receiver) => origin.importedFrom.some(
+    (module2) => isImportedFrom(
+      rootIdentifier(receiver.expression) ?? receiver.expression,
+      module2
+    )
+  )
+};
 function madeBy(receiver) {
+  if (receiver.callee === null) {
+    return rootIdentifier(receiver.expression) ?? receiver.expression;
+  }
   const written = receiver.resolve(receiver.callee.getExpression());
   if (written === null || !import_ts_morph14.Node.isNewExpression(written) && !import_ts_morph14.Node.isCallExpression(written)) {
     return receiver.callee;
@@ -2698,30 +2713,217 @@ function madeBy(receiver) {
 }
 function callOpsFor(call, resolveWrittenValue) {
   const resolve2 = resolveWrittenValue ?? (() => null);
-  const expression = call.getExpression();
+  const expression = calleeOf(call);
   const callee = import_ts_morph14.Node.isPropertyAccessExpression(expression) ? expression : null;
   let args = null;
   const argumentsOf = () => {
-    args ??= call.getArguments();
+    args ??= argumentsIn(call);
     return args;
   };
   return {
     method: () => callee === null ? null : callee.getName(),
-    receiverIsFrom: (origin) => callee !== null && ORIGIN[origin.origin](origin, { callee, resolve: resolve2 }),
+    receiverIsFrom: (origin) => ORIGIN[origin.origin](origin, { callee, expression, resolve: resolve2 }),
+    isFrom: (origin) => CALL_ORIGIN[origin.origin](origin, { callee, expression, resolve: resolve2 }),
     argumentCount: () => argumentsOf().length,
     nameAt: (index, unsettled) => nameAt(argumentsOf()[index], unsettled, resolve2),
     calleeText: () => expression.getText(),
+    receiver: () => callee === null ? null : opsOverCall(callee.getExpression(), resolve2),
+    argument: (index) => opsOverCall(argumentsOf()[index], resolve2),
+    callee: () => opsOverCall(expression, resolve2),
+    propertyAt: (index, property, unsettled) => propertyAt(argumentsOf()[index], property, unsettled, resolve2),
+    valueAt: (index) => {
+      const argument = argumentsOf()[index];
+      return argument === void 0 ? null : valueOpsFor(argument, resolve2);
+    },
     ast: () => call
   };
 }
+function valueOpsFor(value, resolve2) {
+  let settledValue;
+  const written = () => {
+    settledValue ??= settled(value, resolve2) ?? value;
+    return settledValue;
+  };
+  return {
+    text: () => literalText(written()),
+    flag: () => literalFlag(written()),
+    entries: (unsettled) => entriesOf(written(), unsettled, resolve2),
+    items: () => itemsOf(written(), resolve2),
+    property: (name) => {
+      const object = written();
+      const inside = import_ts_morph14.Node.isObjectLiteralExpression(object) ? initializerOf(object, name) : null;
+      return inside === null ? null : valueOpsFor(inside, resolve2);
+    },
+    parts: () => literalParts(written()),
+    holes: () => templateHoles(written(), resolve2)
+  };
+}
+function literalParts(value) {
+  const written = untagged(value);
+  const whole = literalText(written);
+  if (whole !== null) {
+    return [whole];
+  }
+  if (!import_ts_morph14.Node.isTemplateExpression(written)) {
+    return null;
+  }
+  return [
+    written.getHead().getLiteralText(),
+    ...written.getTemplateSpans().map((span) => span.getLiteral().getLiteralText())
+  ];
+}
+function templateHoles(value, resolve2) {
+  const written = untagged(value);
+  if (!import_ts_morph14.Node.isTemplateExpression(written)) {
+    return [];
+  }
+  return written.getTemplateSpans().map((span) => opsOverCall(span.getExpression(), resolve2));
+}
+function untagged(value) {
+  return import_ts_morph14.Node.isTaggedTemplateExpression(value) ? value.getTemplate() : value;
+}
+function entriesOf(value, unsettled, resolve2) {
+  if (!import_ts_morph14.Node.isObjectLiteralExpression(value)) {
+    return [];
+  }
+  const found = [];
+  for (const written of value.getProperties()) {
+    if (import_ts_morph14.Node.isShorthandPropertyAssignment(written)) {
+      const name = written.getNameNode();
+      found.push({ key: name.getText(), value: valueOpsFor(name, resolve2) });
+      continue;
+    }
+    if (!import_ts_morph14.Node.isPropertyAssignment(written)) {
+      continue;
+    }
+    const stated = written.getInitializer();
+    found.push({
+      key: entryKey(written, unsettled, resolve2),
+      value: valueOpsFor(stated ?? written, resolve2)
+    });
+  }
+  return found;
+}
+function entryKey(written, unsettled, resolve2) {
+  const name = written.getNameNode();
+  if (import_ts_morph14.Node.isComputedPropertyName(name)) {
+    return readName(name.getExpression(), { resolve: resolve2, unsettled });
+  }
+  return unquoted(written.getName());
+}
+function itemsOf(value, resolve2) {
+  if (!import_ts_morph14.Node.isArrayLiteralExpression(value)) {
+    return [];
+  }
+  return value.getElements().map((element) => valueOpsFor(element, resolve2));
+}
+function literalText(value) {
+  return import_ts_morph14.Node.isStringLiteral(value) || import_ts_morph14.Node.isNoSubstitutionTemplateLiteral(value) ? value.getLiteralValue() : null;
+}
+function literalFlag(value) {
+  if (import_ts_morph14.Node.isTrueLiteral(value) || import_ts_morph14.Node.isFalseLiteral(value)) {
+    return import_ts_morph14.Node.isTrueLiteral(value);
+  }
+  return import_ts_morph14.Node.isNumericLiteral(value) ? value.getLiteralValue() !== 0 : null;
+}
+function unquoted(name) {
+  return name.replace(/^["']|["']$/g, "");
+}
+function opsOverCall(value, resolve2) {
+  const written = settled(value, resolve2);
+  if (written === null || !isCalled(written)) {
+    return null;
+  }
+  return callOpsFor(written, resolve2);
+}
+function isCalled(value) {
+  return import_ts_morph14.Node.isCallExpression(value) || import_ts_morph14.Node.isNewExpression(value) || import_ts_morph14.Node.isTaggedTemplateExpression(value);
+}
+function calleeOf(call) {
+  return import_ts_morph14.Node.isTaggedTemplateExpression(call) ? call.getTag() : call.getExpression();
+}
+function argumentsIn(call) {
+  return import_ts_morph14.Node.isTaggedTemplateExpression(call) ? [call.getTemplate()] : call.getArguments();
+}
+function settled(value, resolve2) {
+  let step = unwrapped(value ?? null);
+  for (let hops = 0; hops < MAX_WRITTEN_HOPS; hops += 1) {
+    if (step === null || !import_ts_morph14.Node.isIdentifier(step)) {
+      return step;
+    }
+    const written = variableFor(step)?.getInitializer() ?? resolve2(step);
+    if (written === null || written === step) {
+      return null;
+    }
+    step = unwrapped(written);
+  }
+  return null;
+}
+function unwrapped(value) {
+  let inside = value;
+  while (inside !== null && (import_ts_morph14.Node.isAwaitExpression(inside) || import_ts_morph14.Node.isParenthesizedExpression(inside))) {
+    inside = inside.getExpression();
+  }
+  return inside;
+}
+function variableFor(name) {
+  if (!import_ts_morph14.Node.isIdentifier(name)) {
+    return null;
+  }
+  for (const declaration of name.getSymbol()?.getDeclarations() ?? []) {
+    if (import_ts_morph14.Node.isVariableDeclaration(declaration)) {
+      return declaration;
+    }
+  }
+  return null;
+}
 function nameAt(argument, unsettled, resolve2) {
   if (argument === void 0) {
     return null;
   }
   return readName(argument, { resolve: resolve2, unsettled });
 }
+function propertyAt(argument, property, unsettled, resolve2) {
+  const stated = objectAt(argument, resolve2);
+  const written = stated === null ? null : initializerOf(stated, property);
+  return written === null ? null : readName(written, { resolve: resolve2, unsettled });
+}
+function objectAt(argument, resolve2) {
+  const written = settled(argument, resolve2);
+  if (written === null) {
+    return null;
+  }
+  if (isCalled(written)) {
+    return objectAt(argumentsIn(written)[0], resolve2);
+  }
+  return import_ts_morph14.Node.isObjectLiteralExpression(written) ? written : null;
+}
+function initializerOf(object, property) {
+  for (const written of object.getProperties()) {
+    if (import_ts_morph14.Node.isPropertyAssignment(written) && written.getName() === property) {
+      return written.getInitializer() ?? null;
+    }
+  }
+  return null;
+}
 
 // src/resolve/invocationEffects.ts
+function invocationContextFor(call, resolveWrittenValue) {
+  let ops = null;
+  return {
+    call,
+    sourceFile: call.getSourceFile(),
+    extractArgs: () => extractArgs(call),
+    isImportedFrom,
+    // A context built without a store gives null, and the recognizer's
+    // own pattern match runs on the raw node.
+    resolveWrittenValue: resolveWrittenValue ?? (() => null),
+    get ops() {
+      ops ??= callOpsFor(call, resolveWrittenValue);
+      return ops;
+    }
+  };
+}
 function isImportedFrom(identifier, expectedModule) {
   if (!import_ts_morph15.Node.isIdentifier(identifier)) {
     return false;
@@ -2930,20 +3132,7 @@ function runInvocationRecognizers(func, recognizers, barriers = NO_BARRIERS, res
     if (!import_ts_morph15.Node.isCallExpression(node)) {
       return;
     }
-    let ops = null;
-    const ctx = {
-      call: node,
-      sourceFile,
-      extractArgs: () => extractArgs(node),
-      isImportedFrom,
-      // A context built without a store gives null, and the recognizer's
-      // own pattern match runs on the raw node.
-      resolveWrittenValue: resolveWrittenValue ?? (() => null),
-      get ops() {
-        ops ??= callOpsFor(node, resolveWrittenValue);
-        return ops;
-      }
-    };
+    const ctx = invocationContextFor(node, resolveWrittenValue);
     const line = enclosingStatementLine(node);
     for (const recognizer of recognizers) {
       let emitted = null;
@@ -2984,6 +3173,20 @@ function runAccessRecognizersAtModuleScope(sourceFile, recognizers, resolveWritt
     resolveWrittenValue
   );
 }
+function accessContextFor(node, sourceFile, resolveWrittenValue = () => null) {
+  const given = { access: node, sourceFile, resolveWrittenValue };
+  if (import_ts_morph15.Node.isPropertyAccessExpression(node)) {
+    return given;
+  }
+  let ops;
+  return {
+    ...given,
+    get ops() {
+      ops ??= callOpsFor(node, resolveWrittenValue);
+      return ops;
+    }
+  };
+}
 function dispatchAccessRecognizers(root, recognizers, isStop, resolveWrittenValue) {
   if (recognizers.length === 0) {
     return [];
@@ -2999,11 +3202,7 @@ function dispatchAccessRecognizers(root, recognizers, isStop, resolveWrittenValu
     if (!import_ts_morph15.Node.isPropertyAccessExpression(node) && !import_ts_morph15.Node.isCallExpression(node) && !import_ts_morph15.Node.isTaggedTemplateExpression(node)) {
       return;
     }
-    const ctx = {
-      access: node,
-      sourceFile,
-      resolveWrittenValue: resolveWrittenValue ?? (() => null)
-    };
+    const ctx = accessContextFor(node, sourceFile, resolveWrittenValue);
     const line = enclosingStatementLine(node);
     for (const recognizer of recognizers) {
       let emitted = null;
@@ -3166,8 +3365,8 @@ function inlineModuleBinding(ident, depth) {
     if (init === void 0) {
       continue;
     }
-    const unwrapped = unwrapCasts(init);
-    const captured = extractArg(unwrapped, depth - 1);
+    const unwrapped2 = unwrapCasts(init);
+    const captured = extractArg(unwrapped2, depth - 1);
     if (captured !== null) {
       return captured;
     }
@@ -3872,35 +4071,35 @@ function extractShapeWithArguments(node, substitutions) {
   }
 }
 function extractShapeInner(node) {
-  const unwrapped = peelSyntax(node);
-  if (boundArguments !== null && import_ts_morph17.Node.isIdentifier(unwrapped)) {
-    const argument = boundArguments.get(unwrapped.getText());
-    if (argument !== void 0 && argument !== unwrapped) {
+  const unwrapped2 = peelSyntax(node);
+  if (boundArguments !== null && import_ts_morph17.Node.isIdentifier(unwrapped2)) {
+    const argument = boundArguments.get(unwrapped2.getText());
+    if (argument !== void 0 && argument !== unwrapped2) {
       return extractShape(argument);
     }
   }
-  if (import_ts_morph17.Node.isObjectLiteralExpression(unwrapped)) {
-    return shapeFromObjectLiteral(unwrapped);
+  if (import_ts_morph17.Node.isObjectLiteralExpression(unwrapped2)) {
+    return shapeFromObjectLiteral(unwrapped2);
   }
-  if (import_ts_morph17.Node.isArrayLiteralExpression(unwrapped)) {
-    return shapeFromArrayLiteral(unwrapped);
+  if (import_ts_morph17.Node.isArrayLiteralExpression(unwrapped2)) {
+    return shapeFromArrayLiteral(unwrapped2);
   }
-  if (import_ts_morph17.Node.isStringLiteral(unwrapped) || import_ts_morph17.Node.isNoSubstitutionTemplateLiteral(unwrapped)) {
-    return { type: "literal", value: unwrapped.getLiteralValue() };
+  if (import_ts_morph17.Node.isStringLiteral(unwrapped2) || import_ts_morph17.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+    return { type: "literal", value: unwrapped2.getLiteralValue() };
   }
-  if (import_ts_morph17.Node.isTemplateExpression(unwrapped)) {
+  if (import_ts_morph17.Node.isTemplateExpression(unwrapped2)) {
     return { type: "text" };
   }
-  if (import_ts_morph17.Node.isNumericLiteral(unwrapped)) {
+  if (import_ts_morph17.Node.isNumericLiteral(unwrapped2)) {
     return numericLiteralShape(
-      unwrapped.getLiteralValue(),
-      unwrapped.getText()
+      unwrapped2.getLiteralValue(),
+      unwrapped2.getText()
     );
   }
-  if (import_ts_morph17.Node.isPrefixUnaryExpression(unwrapped)) {
-    const op = unwrapped.getOperatorToken();
+  if (import_ts_morph17.Node.isPrefixUnaryExpression(unwrapped2)) {
+    const op = unwrapped2.getOperatorToken();
     if (op === import_ts_morph17.SyntaxKind.MinusToken || op === import_ts_morph17.SyntaxKind.PlusToken) {
-      const inner = unwrapped.getOperand();
+      const inner = unwrapped2.getOperand();
       if (import_ts_morph17.Node.isNumericLiteral(inner)) {
         const v3 = inner.getLiteralValue();
         const signed = op === import_ts_morph17.SyntaxKind.MinusToken ? -v3 : v3;
@@ -3910,10 +4109,10 @@ function extractShapeInner(node) {
       }
     }
   }
-  if (import_ts_morph17.Node.isBigIntLiteral(unwrapped)) {
+  if (import_ts_morph17.Node.isBigIntLiteral(unwrapped2)) {
     return { type: "ref", name: "bigint" };
   }
-  const kind = unwrapped.getKind();
+  const kind = unwrapped2.getKind();
   if (kind === import_ts_morph17.SyntaxKind.TrueKeyword) {
     return { type: "literal", value: true };
   }
@@ -3923,12 +4122,12 @@ function extractShapeInner(node) {
   if (kind === import_ts_morph17.SyntaxKind.NullKeyword) {
     return { type: "null" };
   }
-  if (import_ts_morph17.Node.isIdentifier(unwrapped) && unwrapped.getText() === "undefined") {
+  if (import_ts_morph17.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
     return { type: "undefined" };
   }
-  if (import_ts_morph17.Node.isConditionalExpression(unwrapped)) {
-    const whenTrue = extractShape(unwrapped.getWhenTrue());
-    const whenFalse = extractShape(unwrapped.getWhenFalse());
+  if (import_ts_morph17.Node.isConditionalExpression(unwrapped2)) {
+    const whenTrue = extractShape(unwrapped2.getWhenTrue());
+    const whenFalse = extractShape(unwrapped2.getWhenFalse());
     const variants = [];
     if (whenTrue) {
       variants.push(whenTrue);
@@ -3937,15 +4136,15 @@ function extractShapeInner(node) {
       variants.push(whenFalse);
     }
     if (variants.length === 0) {
-      return shapeFromNodeType(unwrapped);
+      return shapeFromNodeType(unwrapped2);
     }
     return collapseVariants2(variants);
   }
-  const astShape = resolveNodeFromAst(unwrapped, extractShape);
+  const astShape = resolveNodeFromAst(unwrapped2, extractShape);
   if (astShape !== null) {
     return astShape;
   }
-  return shapeFromNodeType(unwrapped);
+  return shapeFromNodeType(unwrapped2);
 }
 function numericLiteralShape(value, raw) {
   return { type: "literal", value, raw };
@@ -4103,15 +4302,15 @@ function matchConstructorCode(ctorText, codes) {
   return null;
 }
 function statusOf(value, ctx) {
-  const unwrapped = unwrapAs(value);
-  if (import_ts_morph18.Node.isNumericLiteral(unwrapped)) {
-    return { type: "literal", value: Number(unwrapped.getText()) };
+  const unwrapped2 = unwrapAs(value);
+  if (import_ts_morph18.Node.isNumericLiteral(unwrapped2)) {
+    return { type: "literal", value: Number(unwrapped2.getText()) };
   }
-  const resolved = ctx.resolveWrittenValue?.(unwrapped) ?? null;
+  const resolved = ctx.resolveWrittenValue?.(unwrapped2) ?? null;
   if (resolved !== null && import_ts_morph18.Node.isNumericLiteral(resolved)) {
     return { type: "literal", value: Number(resolved.getText()) };
   }
-  return { type: "dynamic", sourceText: unwrapped.getText() };
+  return { type: "dynamic", sourceText: unwrapped2.getText() };
 }
 function statusFromProperty(obj, name, ctx) {
   const prop = obj.getProperty(name);
@@ -4494,9 +4693,9 @@ function returnedObjects(fn) {
     if (expression === void 0) {
       continue;
     }
-    const unwrapped = peelParens(expression);
-    if (import_ts_morph19.Node.isObjectLiteralExpression(unwrapped)) {
-      found.push(unwrapped);
+    const unwrapped2 = peelParens(expression);
+    if (import_ts_morph19.Node.isObjectLiteralExpression(unwrapped2)) {
+      found.push(unwrapped2);
     }
   }
   return found;
@@ -7883,7 +8082,7 @@ function classDecoratorStandingFor(cls, names, modules, resolution) {
     return null;
   }
   for (const decorator of cls.getDecorators()) {
-    const applied = resolution.importedNamesOf(calleeOf(decorator), modules);
+    const applied = resolution.importedNamesOf(calleeOf2(decorator), modules);
     const standsFor = names.find((name) => applied.includes(name));
     if (standsFor === void 0) {
       continue;
@@ -7901,7 +8100,7 @@ function frameworkArgs(decorator, standsFor, modules, resolution) {
   if (atClass.length > 0) {
     return atClass;
   }
-  const wrapper = resolution.resolveCallable(calleeOf(decorator));
+  const wrapper = resolution.resolveCallable(calleeOf2(decorator));
   if (wrapper === null) {
     return atClass;
   }
@@ -7926,7 +8125,7 @@ function statesAValue(arg, wrapper) {
 function isWithin(node, container) {
   return node.getSourceFile() === container.getSourceFile() && node.getStart() >= container.getStart() && node.getEnd() <= container.getEnd();
 }
-function calleeOf(decorator) {
+function calleeOf2(decorator) {
   const call = decorator.getCallExpression();
   if (call !== void 0) {
     return call.getExpression();
@@ -9127,9 +9326,9 @@ function attributeValueOf(node, name) {
   return null;
 }
 function literalStringOf(value) {
-  const unwrapped = import_ts_morph43.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (import_ts_morph43.Node.isStringLiteral(unwrapped) || import_ts_morph43.Node.isNoSubstitutionTemplateLiteral(unwrapped)) {
-    return unwrapped.getLiteralValue();
+  const unwrapped2 = import_ts_morph43.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (import_ts_morph43.Node.isStringLiteral(unwrapped2) || import_ts_morph43.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+    return unwrapped2.getLiteralValue();
   }
   return null;
 }
@@ -9148,11 +9347,11 @@ function elementTargetOfValue(value) {
   if (value === null) {
     return { kind: "absent" };
   }
-  const unwrapped = import_ts_morph43.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (!import_ts_morph43.Node.isJsxSelfClosingElement(unwrapped) && !import_ts_morph43.Node.isJsxElement(unwrapped)) {
+  const unwrapped2 = import_ts_morph43.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (!import_ts_morph43.Node.isJsxSelfClosingElement(unwrapped2) && !import_ts_morph43.Node.isJsxElement(unwrapped2)) {
     return { kind: "unreadable" };
   }
-  const tag = tagNameOf(unwrapped);
+  const tag = tagNameOf(unwrapped2);
   if (tag === null) {
     return { kind: "unreadable" };
   }
@@ -10016,7 +10215,146 @@ function discoverPackageImports(sourceFile, match, kind) {
 }
 
 // src/discovery/registrationCall.ts
+var import_ts_morph49 = require("ts-morph");
+
+// src/resolve/routePath.ts
 var import_ts_morph48 = require("ts-morph");
+var import_behavioral_ir5 = require("@suss/behavioral-ir");
+var URL_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//;
+var URL_ORIGIN = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\/[^/]*/;
+var PROTOCOL_RELATIVE = /^\/\//;
+var PROTOCOL_RELATIVE_ORIGIN = /^\/\/[^/]*/;
+function isAbsoluteUrlLiteral(text) {
+  return URL_SCHEME.test(text) || PROTOCOL_RELATIVE.test(text);
+}
+function stripOriginManually(text) {
+  if (URL_SCHEME.test(text)) {
+    return text.replace(URL_ORIGIN, "");
+  }
+  if (PROTOCOL_RELATIVE.test(text)) {
+    return text.replace(PROTOCOL_RELATIVE_ORIGIN, "");
+  }
+  return text;
+}
+function stripQueryAndFragment(text) {
+  const idx = text.search(/[?#]/);
+  return idx === -1 ? text : text.slice(0, idx);
+}
+var SUBSTITUTION = "\uFFFF";
+var AUTHORITY_OPENER = /^(?:[-+.\uFFFFa-zA-Z0-9]+:\/\/|\/\/)/;
+function originEndOf(flattened) {
+  const opener = AUTHORITY_OPENER.exec(flattened);
+  if (opener === null) {
+    return 0;
+  }
+  const slash = flattened.indexOf("/", opener[0].length);
+  return slash === -1 ? flattened.length : slash;
+}
+function appendPathText(path12, text) {
+  const idx = text.search(/[?#]/);
+  if (idx === -1) {
+    return { path: path12 + text, stop: false };
+  }
+  return { path: path12 + text.slice(0, idx), stop: true };
+}
+function parseAbsoluteUrl(text) {
+  try {
+    return new URL(text);
+  } catch {
+  }
+  if (!PROTOCOL_RELATIVE.test(text)) {
+    return void 0;
+  }
+  try {
+    return new URL(`https:${text}`);
+  } catch {
+    return void 0;
+  }
+}
+function pathnameOfAbsoluteLiteral(text) {
+  const parsed = parseAbsoluteUrl(text);
+  if (parsed !== void 0) {
+    return parsed.pathname;
+  }
+  return stripQueryAndFragment(stripOriginManually(text));
+}
+function pathFromLiteralUrl(text) {
+  const path12 = isAbsoluteUrlLiteral(text) ? pathnameOfAbsoluteLiteral(text) : stripQueryAndFragment(text);
+  return path12 === "" ? void 0 : path12;
+}
+function pathFromTemplateUrl(arg, resolution) {
+  const headText = arg.getHead().getLiteralText();
+  const spans = arg.getTemplateSpans();
+  const tails = spans.map((span) => span.getLiteral().getLiteralText());
+  const originEnd = originEndOf([headText, ...tails].join(SUBSTITUTION));
+  const head = appendPathText("", headText.slice(originEnd));
+  let path12 = head.path;
+  let stop = head.stop;
+  let at = headText.length;
+  for (let i = 0; i < spans.length && !stop; i++) {
+    const span = spans[i];
+    const tailText = tails[i];
+    if (span === void 0 || tailText === void 0) {
+      continue;
+    }
+    if (at >= originEnd) {
+      path12 += holeText(span.getExpression(), resolution);
+    }
+    at += SUBSTITUTION.length;
+    const appended = appendPathText(
+      path12,
+      tailText.slice(Math.max(0, originEnd - at))
+    );
+    path12 = appended.path;
+    stop = appended.stop;
+    at += tailText.length;
+  }
+  return path12 === "" ? void 0 : path12;
+}
+function pathFromUrlNode(node, resolution) {
+  if (import_ts_morph48.Node.isStringLiteral(node)) {
+    return pathFromLiteralUrl(node.getLiteralValue());
+  }
+  if (import_ts_morph48.Node.isNoSubstitutionTemplateLiteral(node)) {
+    return pathFromLiteralUrl(node.getLiteralValue());
+  }
+  if (import_ts_morph48.Node.isTemplateExpression(node)) {
+    return pathFromTemplateUrl(node, resolution);
+  }
+  return void 0;
+}
+function placeholderName(expr) {
+  if (import_ts_morph48.Node.isIdentifier(expr)) {
+    return expr.getText();
+  }
+  if (import_ts_morph48.Node.isPropertyAccessExpression(expr)) {
+    return expr.getName();
+  }
+  return "param";
+}
+function holeText(expr, resolution) {
+  const written = resolution?.resolveWrittenValue(expr) ?? null;
+  if (written === null) {
+    return (0, import_behavioral_ir5.patternHole)(placeholderName(expr));
+  }
+  if (emptyStringLiteral(written)) {
+    return "";
+  }
+  return pathFromUrlNode(written, resolution) ?? (0, import_behavioral_ir5.patternHole)(placeholderName(expr));
+}
+function emptyStringLiteral(node) {
+  return (import_ts_morph48.Node.isStringLiteral(node) || import_ts_morph48.Node.isNoSubstitutionTemplateLiteral(node)) && node.getLiteralValue() === "";
+}
+function pathFromArgument(arg, resolution) {
+  const written = pathFromUrlNode(arg, resolution);
+  if (written !== void 0) {
+    return written;
+  }
+  const resolved = resolution?.resolveWrittenValue(arg) ?? null;
+  return resolved !== null ? pathFromUrlNode(resolved, resolution) : void 0;
+}
+
+// src/discovery/registrationCall.ts
 function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, resolution, mountPrefixes) {
   const results = [];
   const registrationSubjects = registrationSubjectsOf(
@@ -10031,11 +10369,11 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     (c) => c.startsWith(".") ? c.slice(1) : c
   );
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph48.Node.isCallExpression(node)) {
+    if (!import_ts_morph49.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph48.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph49.Node.isPropertyAccessExpression(callee)) {
       return;
     }
     const methodName = callee.getName();
@@ -10043,7 +10381,7 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
       return;
     }
     const subject = callee.getExpression();
-    const subjectName = import_ts_morph48.Node.isIdentifier(subject) ? subject.getText() : null;
+    const subjectName = import_ts_morph49.Node.isIdentifier(subject) ? subject.getText() : null;
     const subjectNode = subjectName === null ? void 0 : registrationSubjects.get(subjectName);
     if (subjectNode === void 0) {
       return;
@@ -10051,12 +10389,12 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
     const args = node.getArguments();
     let foundObjectArg = false;
     for (const arg of args) {
-      if (!import_ts_morph48.Node.isObjectLiteralExpression(arg)) {
+      if (!import_ts_morph49.Node.isObjectLiteralExpression(arg)) {
         continue;
       }
       foundObjectArg = true;
       for (const prop of arg.getProperties()) {
-        if (import_ts_morph48.Node.isMethodDeclaration(prop)) {
+        if (import_ts_morph49.Node.isMethodDeclaration(prop)) {
           results.push({
             func: prop,
             kind,
@@ -10064,7 +10402,7 @@ function discoverRegistrationCalls(sourceFile, match, kind, bindingExtraction, r
           });
           continue;
         }
-        if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
+        if (!import_ts_morph49.Node.isPropertyAssignment(prop)) {
           continue;
         }
         const propInit = prop.getInitializer();
@@ -10162,9 +10500,9 @@ function registrationSubjectsOf(sourceFile, importModule, importName) {
       continue;
     }
     let calleeText = null;
-    if (import_ts_morph48.Node.isCallExpression(init)) {
+    if (import_ts_morph49.Node.isCallExpression(init)) {
       calleeText = init.getExpression().getText();
-    } else if (import_ts_morph48.Node.isNewExpression(init)) {
+    } else if (import_ts_morph49.Node.isNewExpression(init)) {
       calleeText = init.getExpression().getText();
     }
     if (calleeText === importedLocalName) {
@@ -10172,7 +10510,7 @@ function registrationSubjectsOf(sourceFile, importModule, importName) {
     }
   }
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph48.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph49.Node.isParameterDeclaration(node)) {
       return;
     }
     const typeNode = node.getTypeNode();
@@ -10216,21 +10554,21 @@ function discoverMountEdges(sourceFile, match, mount, knownSubjectIds, resolutio
   }
   const edges = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph48.Node.isCallExpression(node)) {
+    if (!import_ts_morph49.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph48.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
+    if (!import_ts_morph49.Node.isPropertyAccessExpression(callee) || callee.getName() !== mount.method) {
       return;
     }
     const subject = callee.getExpression();
-    const subjectNode = import_ts_morph48.Node.isIdentifier(subject) ? subjects.get(subject.getText()) : void 0;
+    const subjectNode = import_ts_morph49.Node.isIdentifier(subject) ? subjects.get(subject.getText()) : void 0;
     if (subjectNode === void 0) {
       return;
     }
     const args = node.getArguments();
     const prefixArg = args[mount.prefixPosition];
-    if (prefixArg === void 0 || !(import_ts_morph48.Node.isStringLiteral(prefixArg) || import_ts_morph48.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
+    if (prefixArg === void 0 || !(import_ts_morph49.Node.isStringLiteral(prefixArg) || import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(prefixArg))) {
       return;
     }
     const targetNodes = mountTargetsAmong(
@@ -10264,15 +10602,15 @@ function mountTargetsAmong(args, targetPosition, knownSubjectIds, resolution) {
   return targets;
 }
 function stringProperty(obj, name) {
-  if (!import_ts_morph48.Node.isObjectLiteralExpression(obj)) {
+  if (!import_ts_morph49.Node.isObjectLiteralExpression(obj)) {
     return null;
   }
   const property = obj.getProperty(name);
-  if (property === void 0 || !import_ts_morph48.Node.isPropertyAssignment(property)) {
+  if (property === void 0 || !import_ts_morph49.Node.isPropertyAssignment(property)) {
     return null;
   }
   const value = property.getInitializer();
-  if (value !== void 0 && (import_ts_morph48.Node.isStringLiteral(value) || import_ts_morph48.Node.isNoSubstitutionTemplateLiteral(value))) {
+  if (value !== void 0 && (import_ts_morph49.Node.isStringLiteral(value) || import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(value))) {
     return value.getLiteralValue();
   }
   return null;
@@ -10288,40 +10626,37 @@ function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
       return null;
     }
     const method2 = stringProperty(routeObject, binding.method.property);
-    const path12 = stringProperty(routeObject, binding.path.property);
-    if (method2 === null || path12 === null) {
+    const path13 = stringProperty(routeObject, binding.path.property);
+    if (method2 === null || path13 === null) {
       return null;
     }
-    return { method: method2.toUpperCase(), path: path12 };
+    return { method: method2.toUpperCase(), path: path13 };
   }
-  if (binding.method.type !== "fromRegistration" || binding.path.type !== "fromRegistration") {
+  if (binding.method.type !== "fromRegistration" || binding.path.type !== "fromArgument") {
     return null;
   }
   let method;
   if (binding.method.position === "methodName") {
     method = binding.method.nameMap?.[methodName] ?? methodName.toUpperCase();
   } else {
-    const args2 = call.getArguments();
-    const arg = args2[binding.method.position];
-    if (arg === void 0 || !(import_ts_morph48.Node.isStringLiteral(arg) || import_ts_morph48.Node.isNoSubstitutionTemplateLiteral(arg))) {
+    const args = call.getArguments();
+    const arg = args[binding.method.position];
+    if (arg === void 0 || !(import_ts_morph49.Node.isStringLiteral(arg) || import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(arg))) {
       return null;
     }
     method = arg.getLiteralValue().toUpperCase();
   }
-  const args = call.getArguments();
-  const pathArg = args[binding.path.position];
-  if (pathArg === void 0 || !(import_ts_morph48.Node.isStringLiteral(pathArg) || import_ts_morph48.Node.isNoSubstitutionTemplateLiteral(pathArg))) {
-    return null;
-  }
-  return { method, path: pathArg.getLiteralValue() };
+  const pathArg = call.getArguments()[binding.path.position];
+  const path12 = pathArg === void 0 ? void 0 : pathFromArgument(pathArg, resolution);
+  return path12 === void 0 ? null : { method, path: path12 };
 }
 
 // src/discovery/registrationLoop.ts
-var import_ts_morph49 = require("ts-morph");
+var import_ts_morph50 = require("ts-morph");
 function discoverRegistrationLoops(sourceFile, match, kind, resolution) {
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph49.Node.isForOfStatement(node)) {
+    if (!import_ts_morph50.Node.isForOfStatement(node)) {
       return;
     }
     const expanded = tryExpandLoop(node, match, kind, resolution);
@@ -10364,13 +10699,13 @@ function tryExpandLoop(loop, match, kind, resolution) {
 }
 function loopVariableName(loop) {
   const initializer = loop.getInitializer();
-  if (import_ts_morph49.Node.isVariableDeclarationList(initializer)) {
+  if (import_ts_morph50.Node.isVariableDeclarationList(initializer)) {
     const decls = initializer.getDeclarations();
     if (decls.length !== 1) {
       return null;
     }
     const nameNode = decls[0]?.getNameNode();
-    if (nameNode !== void 0 && import_ts_morph49.Node.isIdentifier(nameNode)) {
+    if (nameNode !== void 0 && import_ts_morph50.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -10383,14 +10718,14 @@ function bodyReferencesLoopVar(loop, name) {
     if (referenced) {
       return;
     }
-    if (!import_ts_morph49.Node.isCallExpression(node)) {
+    if (!import_ts_morph50.Node.isCallExpression(node)) {
       return;
     }
     node.forEachDescendant((inner) => {
       if (referenced) {
         return;
       }
-      if (import_ts_morph49.Node.isIdentifier(inner) && inner.getText() === name) {
+      if (import_ts_morph50.Node.isIdentifier(inner) && inner.getText() === name) {
         referenced = true;
       }
     });
@@ -10402,11 +10737,11 @@ function readRouteSpec(element, shape, resolution) {
   let path12 = null;
   let handler = null;
   for (const prop of element.getProperties()) {
-    if (import_ts_morph49.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
+    if (import_ts_morph50.Node.isMethodDeclaration(prop) && prop.getName() === shape.handlerKey) {
       handler = { func: prop, name: shape.handlerKey };
       continue;
     }
-    if (!import_ts_morph49.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph50.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const name = prop.getName();
@@ -10429,17 +10764,17 @@ function readRouteSpec(element, shape, resolution) {
   return { method, path: path12, handler: handler.func, handlerName: handler.name };
 }
 function readStringLiteralValue(node) {
-  if (import_ts_morph49.Node.isStringLiteral(node) || import_ts_morph49.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph50.Node.isStringLiteral(node) || import_ts_morph50.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   return null;
 }
 function handlerName(value) {
-  return import_ts_morph49.Node.isIdentifier(value) ? value.getText() : value.getKindName();
+  return import_ts_morph50.Node.isIdentifier(value) ? value.getText() : value.getKindName();
 }
 
 // src/discovery/registrationTemplate.ts
-var import_ts_morph50 = require("ts-morph");
+var import_ts_morph51 = require("ts-morph");
 function discoverRegistrationTemplates(sourceFile, match, kind, resolution) {
   const localName = resolveImportedLocalName2(sourceFile, match);
   if (localName === null) {
@@ -10447,7 +10782,7 @@ function discoverRegistrationTemplates(sourceFile, match, kind, resolution) {
   }
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph50.Node.isCallExpression(node)) {
+    if (!import_ts_morph51.Node.isCallExpression(node)) {
       return;
     }
     if (!isCallToHelper(node, localName)) {
@@ -10498,7 +10833,7 @@ function resolveImportedLocalName2(sourceFile, match) {
 }
 function isCallToHelper(call, localName) {
   const callee = call.getExpression();
-  return import_ts_morph50.Node.isIdentifier(callee) && callee.getText() === localName;
+  return import_ts_morph51.Node.isIdentifier(callee) && callee.getText() === localName;
 }
 function substitutePath(template, args) {
   const re = /\{(\d+)\}/g;
@@ -10524,7 +10859,7 @@ function substitutePath(template, args) {
   return result;
 }
 function readStringLiteral(node) {
-  if (import_ts_morph50.Node.isStringLiteral(node) || import_ts_morph50.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph51.Node.isStringLiteral(node) || import_ts_morph51.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   return null;
@@ -10547,7 +10882,7 @@ function resolveHandler(template, args, resolution) {
   return readPropertyAsFunction(arg, prop, resolution);
 }
 function handlerName2(value) {
-  return import_ts_morph50.Node.isIdentifier(value) ? value.getText() : value.getKindName();
+  return import_ts_morph51.Node.isIdentifier(value) ? value.getText() : value.getKindName();
 }
 function readPropertyAsFunction(arg, prop, resolution) {
   const obj = objectLiteralOf(arg, resolution);
@@ -10558,7 +10893,7 @@ function readPropertyAsFunction(arg, prop, resolution) {
     if (propertyName2(property) !== prop) {
       continue;
     }
-    if (import_ts_morph50.Node.isMethodDeclaration(property)) {
+    if (import_ts_morph51.Node.isMethodDeclaration(property)) {
       return { func: property, name: prop };
     }
     const held = propertyValueOf(property);
@@ -10566,19 +10901,19 @@ function readPropertyAsFunction(arg, prop, resolution) {
       return null;
     }
     const func = functionValueOf(held, resolution);
-    return func === null ? null : { func, name: import_ts_morph50.Node.isIdentifier(held) ? held.getText() : prop };
+    return func === null ? null : { func, name: import_ts_morph51.Node.isIdentifier(held) ? held.getText() : prop };
   }
   return null;
 }
 function propertyName2(property) {
-  if (import_ts_morph50.Node.isPropertyAssignment(property) || import_ts_morph50.Node.isShorthandPropertyAssignment(property) || import_ts_morph50.Node.isMethodDeclaration(property)) {
+  if (import_ts_morph51.Node.isPropertyAssignment(property) || import_ts_morph51.Node.isShorthandPropertyAssignment(property) || import_ts_morph51.Node.isMethodDeclaration(property)) {
     return property.getName();
   }
   return null;
 }
 
 // src/discovery/resolverMap.ts
-var import_ts_morph51 = require("ts-morph");
+var import_ts_morph52 = require("ts-morph");
 function discoverResolverMaps(sourceFile, match, kind, resolution) {
   const localName = resolveImportedLocalName(
     sourceFile,
@@ -10592,15 +10927,15 @@ function discoverResolverMaps(sourceFile, match, kind, resolution) {
   const excludeTypes = new Set(match.excludeTypes ?? []);
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph51.Node.isCallExpression(node) && !import_ts_morph51.Node.isNewExpression(node)) {
+    if (!import_ts_morph52.Node.isCallExpression(node) && !import_ts_morph52.Node.isNewExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph51.Node.isIdentifier(callee) || callee.getText() !== localName) {
+    if (!import_ts_morph52.Node.isIdentifier(callee) || callee.getText() !== localName) {
       return;
     }
     const args = node.getArguments();
-    if (args.length === 0 || !import_ts_morph51.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length === 0 || !import_ts_morph52.Node.isObjectLiteralExpression(args[0])) {
       return;
     }
     const config = args[0];
@@ -10654,7 +10989,7 @@ function resolverMapObject(prop, resolution) {
   return held === null ? null : objectLiteralOf(held, resolution);
 }
 function extractTypeDefsSdl(config, resolution) {
-  if (!import_ts_morph51.Node.isObjectLiteralExpression(config)) {
+  if (!import_ts_morph52.Node.isObjectLiteralExpression(config)) {
     return null;
   }
   const prop = config.getProperty("typeDefs");
@@ -10676,15 +11011,15 @@ function schemaSdlOf(expr, resolution) {
   return resolved === null ? null : writtenSdl(resolved);
 }
 function writtenSdl(expr) {
-  if (import_ts_morph51.Node.isStringLiteral(expr) || import_ts_morph51.Node.isNoSubstitutionTemplateLiteral(expr)) {
+  if (import_ts_morph52.Node.isStringLiteral(expr) || import_ts_morph52.Node.isNoSubstitutionTemplateLiteral(expr)) {
     const value = expr.getLiteralValue();
     return value === "" ? null : value;
   }
-  if (import_ts_morph51.Node.isTaggedTemplateExpression(expr)) {
+  if (import_ts_morph52.Node.isTaggedTemplateExpression(expr)) {
     const tag = expr.getTag();
-    if (import_ts_morph51.Node.isIdentifier(tag) && tag.getText() === "gql") {
+    if (import_ts_morph52.Node.isIdentifier(tag) && tag.getText() === "gql") {
       const template = expr.getTemplate();
-      if (import_ts_morph51.Node.isNoSubstitutionTemplateLiteral(template)) {
+      if (import_ts_morph52.Node.isNoSubstitutionTemplateLiteral(template)) {
         return template.getLiteralValue();
       }
     }
@@ -10692,16 +11027,16 @@ function writtenSdl(expr) {
   return null;
 }
 function resolverPropertyName(prop) {
-  if (import_ts_morph51.Node.isPropertyAssignment(prop) || import_ts_morph51.Node.isMethodDeclaration(prop)) {
+  if (import_ts_morph52.Node.isPropertyAssignment(prop) || import_ts_morph52.Node.isMethodDeclaration(prop)) {
     return prop.getName();
   }
-  if (import_ts_morph51.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph52.Node.isShorthandPropertyAssignment(prop)) {
     return prop.getName();
   }
   return null;
 }
 function resolverPropertyFunction(prop, resolution) {
-  if (import_ts_morph51.Node.isMethodDeclaration(prop)) {
+  if (import_ts_morph52.Node.isMethodDeclaration(prop)) {
     return prop;
   }
   const held = propertyValueOf(prop);
@@ -10962,7 +11297,7 @@ function resolvePrefix(edgesByChild, memo, childId, visiting) {
 }
 
 // src/discoveryContext.ts
-var import_ts_morph52 = require("ts-morph");
+var import_ts_morph53 = require("ts-morph");
 function createTsDiscoveryContext(resolution) {
   return {
     getFilePath,
@@ -10994,7 +11329,7 @@ function exportedFunctions(sourceFile, resolution) {
   return out;
 }
 function exportedFunction(decl, resolution) {
-  const writtenAgain = import_ts_morph52.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
+  const writtenAgain = import_ts_morph53.Node.isVariableDeclaration(decl) && isWrittenAgain(decl);
   if (!writtenAgain) {
     const declared = resolveDeclarationToFunction(decl);
     if (declared !== null) {
@@ -11015,7 +11350,7 @@ function valueToAskAbout(decl, writtenAgain) {
   if (writtenAgain) {
     return decl;
   }
-  const value = import_ts_morph52.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
+  const value = import_ts_morph53.Node.isVariableDeclaration(decl) ? decl.getInitializer() ?? decl : decl;
   return couldStillNameAFunction(value) ? value : null;
 }
 function exportedCallConfigString(sourceFile, exportName, spec, resolution) {
@@ -11025,11 +11360,11 @@ function exportedCallConfigString(sourceFile, exportName, spec, resolution) {
   }
   const found = /* @__PURE__ */ new Set();
   for (const decl of declarations) {
-    if (!import_ts_morph52.Node.isVariableDeclaration(decl)) {
+    if (!import_ts_morph53.Node.isVariableDeclaration(decl)) {
       continue;
     }
     const init = peelExpression(decl.getInitializer());
-    if (init === void 0 || !import_ts_morph52.Node.isCallExpression(init)) {
+    if (init === void 0 || !import_ts_morph53.Node.isCallExpression(init)) {
       continue;
     }
     if (!calleeIsNamed(init.getExpression(), spec.callees)) {
@@ -11048,7 +11383,7 @@ function calleeIsNamed(callee, names) {
   if (names === void 0 || names.length === 0) {
     return true;
   }
-  return import_ts_morph52.Node.isIdentifier(callee) && names.includes(callee.getText());
+  return import_ts_morph53.Node.isIdentifier(callee) && names.includes(callee.getText());
 }
 function configArguments(args, argIndex) {
   if (argIndex === void 0) {
@@ -11063,18 +11398,18 @@ function configString(arg, property, resolution) {
     return null;
   }
   const prop = config.getProperty(property);
-  if (prop === void 0 || !import_ts_morph52.Node.isPropertyAssignment(prop)) {
+  if (prop === void 0 || !import_ts_morph53.Node.isPropertyAssignment(prop)) {
     return null;
   }
   const value = peelExpression(prop.getInitializer());
-  if (value !== void 0 && import_ts_morph52.Node.isStringLiteral(value)) {
+  if (value !== void 0 && import_ts_morph53.Node.isStringLiteral(value)) {
     return value.getLiteralValue();
   }
   return null;
 }
 function peelExpression(node) {
   let current2 = node;
-  while (current2 !== void 0 && (import_ts_morph52.Node.isAsExpression(current2) || import_ts_morph52.Node.isSatisfiesExpression(current2) || import_ts_morph52.Node.isParenthesizedExpression(current2) || import_ts_morph52.Node.isNonNullExpression(current2))) {
+  while (current2 !== void 0 && (import_ts_morph53.Node.isAsExpression(current2) || import_ts_morph53.Node.isSatisfiesExpression(current2) || import_ts_morph53.Node.isParenthesizedExpression(current2) || import_ts_morph53.Node.isNonNullExpression(current2))) {
     current2 = current2.getExpression();
   }
   return current2;
@@ -11084,14 +11419,14 @@ function toObjectLiteral(node, resolution) {
   if (peeled === void 0) {
     return null;
   }
-  if (import_ts_morph52.Node.isObjectLiteralExpression(peeled)) {
+  if (import_ts_morph53.Node.isObjectLiteralExpression(peeled)) {
     return peeled;
   }
   if (resolution === void 0) {
     return null;
   }
   const resolved = resolution.resolveObject(peeled);
-  if (resolved !== null && import_ts_morph52.Node.isObjectLiteralExpression(resolved)) {
+  if (resolved !== null && import_ts_morph53.Node.isObjectLiteralExpression(resolved)) {
     return resolved;
   }
   return null;
@@ -11101,18 +11436,18 @@ function resolveDeclarationToFunction(decl) {
   if (fn !== null) {
     return fn;
   }
-  if (import_ts_morph52.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph53.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph52.Node.isArrowFunction(init) || import_ts_morph52.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph53.Node.isArrowFunction(init) || import_ts_morph53.Node.isFunctionExpression(init))) {
       return init;
     }
   }
   return null;
 }
 function hasJsxReturn(func) {
-  if (import_ts_morph52.Node.isArrowFunction(func)) {
+  if (import_ts_morph53.Node.isArrowFunction(func)) {
     const body2 = func.getBody();
-    if (import_ts_morph52.Node.isExpression(body2) && isJsxOrFragment(body2)) {
+    if (import_ts_morph53.Node.isExpression(body2) && isJsxOrFragment(body2)) {
       return true;
     }
   }
@@ -11126,11 +11461,11 @@ function hasJsxReturn(func) {
       traversal.stop();
       return;
     }
-    if (node !== func && (import_ts_morph52.Node.isFunctionDeclaration(node) || import_ts_morph52.Node.isFunctionExpression(node) || import_ts_morph52.Node.isArrowFunction(node) || import_ts_morph52.Node.isMethodDeclaration(node))) {
+    if (node !== func && (import_ts_morph53.Node.isFunctionDeclaration(node) || import_ts_morph53.Node.isFunctionExpression(node) || import_ts_morph53.Node.isArrowFunction(node) || import_ts_morph53.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph52.Node.isReturnStatement(node)) {
+    if (import_ts_morph53.Node.isReturnStatement(node)) {
       const expr = node.getExpression();
       if (expr !== void 0 && isJsxOrFragment(expr)) {
         found = true;
@@ -11141,14 +11476,14 @@ function hasJsxReturn(func) {
 }
 function isJsxOrFragment(node) {
   let current2 = node;
-  while (import_ts_morph52.Node.isParenthesizedExpression(current2)) {
+  while (import_ts_morph53.Node.isParenthesizedExpression(current2)) {
     current2 = current2.getExpression();
   }
-  return import_ts_morph52.Node.isJsxElement(current2) || import_ts_morph52.Node.isJsxSelfClosingElement(current2) || import_ts_morph52.Node.isJsxFragment(current2);
+  return import_ts_morph53.Node.isJsxElement(current2) || import_ts_morph53.Node.isJsxSelfClosingElement(current2) || import_ts_morph53.Node.isJsxFragment(current2);
 }
 
 // src/facts/store.ts
-var import_ts_morph53 = require("ts-morph");
+var import_ts_morph54 = require("ts-morph");
 var import_datalog2 = require("@suss/datalog");
 var import_resolution = require("@suss/resolution");
 var JS_RULES = [
@@ -11393,7 +11728,7 @@ var ResolutionStore = class {
    * can be rooted anywhere, so the queried value gets its own facts.
    */
   seedValue(value) {
-    if (!import_ts_morph53.Node.isExpression(value)) {
+    if (!import_ts_morph54.Node.isExpression(value)) {
       return;
     }
     const id = nodeId(value);
@@ -11423,13 +11758,16 @@ var ResolutionStore = class {
    * Two candidates give null, since ambiguity is nothing. The value
    * itself is never a result either, or an identifier whose chain went
    * nowhere would come back as itself.
+   *
+   * An answer has to be an expression, which leaves out the class a
+   * construction makes an instance of. The README says why.
    */
   lookupWritten(value) {
     this.derive();
     const candidates = /* @__PURE__ */ new Set();
     for (const target of this.answersFor("wantedIsWrittenAs", nodeId(value))) {
       const node = this.table.byId.get(target);
-      if (node === void 0 || node === value) {
+      if (node === void 0 || node === value || !import_ts_morph54.Node.isExpression(node)) {
         continue;
       }
       candidates.add(node);
@@ -11520,7 +11858,7 @@ function namesPackage2(moduleKey, packages) {
   );
 }
 function declarationOf2(value) {
-  const nameNode = import_ts_morph53.Node.isPropertyAccessExpression(value) ? value.getNameNode() : value;
+  const nameNode = import_ts_morph54.Node.isPropertyAccessExpression(value) ? value.getNameNode() : value;
   return nameNode.getSymbol()?.getDeclarations()[0] ?? value;
 }
 
@@ -11766,14 +12104,14 @@ function deriveBoundaryEffects(summaries, facts) {
   }
   const closureByEntry = /* @__PURE__ */ new Map();
   for (const [entry, kind, target] of db.facts("boundaryEffect")) {
-    const entryKey = String(entry);
-    const bucket = closureByEntry.get(entryKey) ?? [];
+    const entryKey2 = String(entry);
+    const bucket = closureByEntry.get(entryKey2) ?? [];
     bucket.push({
       kind: String(kind),
       target: String(target),
-      transitive: !(ownByEntry.get(entryKey)?.has(`${kind}\0${target}`) ?? false)
+      transitive: !(ownByEntry.get(entryKey2)?.has(`${kind}\0${target}`) ?? false)
     });
-    closureByEntry.set(entryKey, bucket);
+    closureByEntry.set(entryKey2, bucket);
   }
   for (const summary of summaries) {
     const key = unitKeyBySummary.get(summary);
@@ -11793,13 +12131,13 @@ function deriveBoundaryEffects(summaries, facts) {
 }
 
 // src/resolve/reachableClosure.ts
-var import_ts_morph55 = require("ts-morph");
-var import_behavioral_ir5 = require("@suss/behavioral-ir");
+var import_ts_morph56 = require("ts-morph");
+var import_behavioral_ir6 = require("@suss/behavioral-ir");
 var import_datalog4 = require("@suss/datalog");
 var import_extractor4 = require("@suss/extractor");
 
 // src/resolve/unfollowedCall.ts
-var import_ts_morph54 = require("ts-morph");
+var import_ts_morph55 = require("ts-morph");
 function isInExternalCode(sourceFile) {
   if (sourceFile.isDeclarationFile()) {
     return true;
@@ -11807,38 +12145,38 @@ function isInExternalCode(sourceFile) {
   return sourceFile.getFilePath().includes("/node_modules/");
 }
 function hasBody(fn) {
-  if (import_ts_morph54.Node.isFunctionDeclaration(fn) || import_ts_morph54.Node.isMethodDeclaration(fn) || import_ts_morph54.Node.isFunctionExpression(fn)) {
+  if (import_ts_morph55.Node.isFunctionDeclaration(fn) || import_ts_morph55.Node.isMethodDeclaration(fn) || import_ts_morph55.Node.isFunctionExpression(fn)) {
     return fn.getBody?.() !== void 0;
   }
   return true;
 }
 function isDeclaredShape(declaration) {
-  return (import_ts_morph54.Node.isMethodSignature(declaration) || import_ts_morph54.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
+  return (import_ts_morph55.Node.isMethodSignature(declaration) || import_ts_morph55.Node.isPropertySignature(declaration)) && !isInExternalCode(declaration.getSourceFile());
 }
 function isExternalDeclaration(declaration) {
   if (isInExternalCode(declaration.getSourceFile())) {
     return true;
   }
-  if (import_ts_morph54.Node.isImportSpecifier(declaration) || import_ts_morph54.Node.isImportClause(declaration) || import_ts_morph54.Node.isNamespaceImport(declaration)) {
-    const target = declaration.getFirstAncestorByKind(import_ts_morph54.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
+  if (import_ts_morph55.Node.isImportSpecifier(declaration) || import_ts_morph55.Node.isImportClause(declaration) || import_ts_morph55.Node.isNamespaceImport(declaration)) {
+    const target = declaration.getFirstAncestorByKind(import_ts_morph55.SyntaxKind.ImportDeclaration)?.getModuleSpecifierSourceFile();
     return target === void 0 || isInExternalCode(target);
   }
   return declaresAnotherModule(declaration);
 }
 function declaresAnotherModule(declaration) {
   const module2 = declaration.getFirstAncestorByKind(
-    import_ts_morph54.SyntaxKind.ModuleDeclaration
+    import_ts_morph55.SyntaxKind.ModuleDeclaration
   );
-  return module2 !== void 0 && import_ts_morph54.Node.isStringLiteral(module2.getNameNode());
+  return module2 !== void 0 && import_ts_morph55.Node.isStringLiteral(module2.getNameNode());
 }
 function statesShapeOnly(declaration) {
   if (isExternalDeclaration(declaration)) {
     return false;
   }
-  if (import_ts_morph54.Node.isMethodSignature(declaration) || import_ts_morph54.Node.isPropertySignature(declaration)) {
+  if (import_ts_morph55.Node.isMethodSignature(declaration) || import_ts_morph55.Node.isPropertySignature(declaration)) {
     return true;
   }
-  if (import_ts_morph54.Node.isFunctionDeclaration(declaration) || import_ts_morph54.Node.isMethodDeclaration(declaration)) {
+  if (import_ts_morph55.Node.isFunctionDeclaration(declaration) || import_ts_morph55.Node.isMethodDeclaration(declaration)) {
     return declaration.getBody() === void 0;
   }
   return false;
@@ -11928,9 +12266,9 @@ function resolveDecl(decl, calleeName) {
     }
     return { func: fn, name: declName(decl) ?? calleeName };
   }
-  if (import_ts_morph55.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph56.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph55.Node.isArrowFunction(init) || import_ts_morph55.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph56.Node.isArrowFunction(init) || import_ts_morph56.Node.isFunctionExpression(init))) {
       return { func: init, name: decl.getName() };
     }
     return null;
@@ -11938,26 +12276,26 @@ function resolveDecl(decl, calleeName) {
   return null;
 }
 function declName(decl) {
-  if (import_ts_morph55.Node.isFunctionDeclaration(decl) || import_ts_morph55.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph56.Node.isFunctionDeclaration(decl) || import_ts_morph56.Node.isMethodDeclaration(decl)) {
     const n = decl.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph55.Node.isFunctionExpression(decl)) {
+  if (import_ts_morph56.Node.isFunctionExpression(decl)) {
     const n = decl.getName();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
   const parent = decl.getParent();
-  if (parent !== void 0 && import_ts_morph55.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph56.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return null;
 }
 function resolveCallee(call, calleeName, scan) {
-  if (!import_ts_morph55.Node.isCallExpression(call)) {
+  if (!import_ts_morph56.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -11970,7 +12308,7 @@ function resolveCallee(call, calleeName, scan) {
     }
   }
   const resolveSources = scan.resolveCallableSources;
-  if (resolveSources !== void 0 && import_ts_morph55.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
+  if (resolveSources !== void 0 && import_ts_morph56.Node.isPropertyAccessExpression(callee) && declarations.some(isDeclaredShape)) {
     const sources = resolveSources(callee, scan.reachedFrom);
     const only = sources.length === 1 ? sources[0] : void 0;
     const resolved = only === void 0 ? null : resolveDecl(only, calleeName);
@@ -11997,7 +12335,7 @@ function collectReachable(func, scan) {
   const stops = [];
   const seen = /* @__PURE__ */ new Set();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph55.Node.isCallExpression(node)) {
+    if (!import_ts_morph56.Node.isCallExpression(node)) {
       return;
     }
     const calleeText = normalizeCallee(node.getExpression().getText());
@@ -12039,7 +12377,7 @@ function extractReachableSummary(candidate, options, recognizers) {
     void 0,
     recognizers.resolveWrittenValue
   );
-  raw.boundaryBinding = (0, import_behavioral_ir5.functionCallBinding)({
+  raw.boundaryBinding = (0, import_behavioral_ir6.functionCallBinding)({
     transport: "in-process",
     recognition: "reachable"
   });
@@ -12183,7 +12521,7 @@ function recordStops(stopsByKey, summariesByKey, options) {
 }
 
 // src/resolve/rethrowEnrichment.ts
-var import_ts_morph56 = require("ts-morph");
+var import_ts_morph57 = require("ts-morph");
 var import_datalog5 = require("@suss/datalog");
 var RETHROW_RULES = [
   (0, import_datalog5.rule)(
@@ -12323,7 +12661,7 @@ function findBareRethrow(func, location) {
       traversal.stop();
       return;
     }
-    if (!import_ts_morph56.Node.isThrowStatement(node)) {
+    if (!import_ts_morph57.Node.isThrowStatement(node)) {
       return;
     }
     if (startLineOf(node) !== location.start) {
@@ -12333,7 +12671,7 @@ function findBareRethrow(func, location) {
       return;
     }
     const thrown = node.getExpression();
-    if (thrown !== void 0 && import_ts_morph56.Node.isIdentifier(thrown)) {
+    if (thrown !== void 0 && import_ts_morph57.Node.isIdentifier(thrown)) {
       found = node;
     }
   });
@@ -12343,13 +12681,13 @@ function enclosingTry(throwStmt) {
   let current2 = throwStmt.getParent();
   let sawCatchClause = false;
   while (current2 !== void 0) {
-    if (import_ts_morph56.Node.isCatchClause(current2)) {
+    if (import_ts_morph57.Node.isCatchClause(current2)) {
       sawCatchClause = true;
     }
-    if (import_ts_morph56.Node.isTryStatement(current2)) {
+    if (import_ts_morph57.Node.isTryStatement(current2)) {
       return sawCatchClause ? current2 : null;
     }
-    if (import_ts_morph56.Node.isFunctionDeclaration(current2) || import_ts_morph56.Node.isFunctionExpression(current2) || import_ts_morph56.Node.isArrowFunction(current2) || import_ts_morph56.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph57.Node.isFunctionDeclaration(current2) || import_ts_morph57.Node.isFunctionExpression(current2) || import_ts_morph57.Node.isArrowFunction(current2) || import_ts_morph57.Node.isMethodDeclaration(current2)) {
       return null;
     }
     current2 = current2.getParent();
@@ -12357,14 +12695,14 @@ function enclosingTry(throwStmt) {
   return null;
 }
 function collectTryBodyCallees(tryStmt, index, keyFor) {
-  if (!import_ts_morph56.Node.isTryStatement(tryStmt)) {
+  if (!import_ts_morph57.Node.isTryStatement(tryStmt)) {
     return [];
   }
   const tryBlock = tryStmt.getTryBlock();
   const callees = [];
   const seen = /* @__PURE__ */ new Set();
   tryBlock.forEachDescendant((node) => {
-    if (!import_ts_morph56.Node.isCallExpression(node)) {
+    if (!import_ts_morph57.Node.isCallExpression(node)) {
       return;
     }
     const calleeSummary = resolveCalleeSummary(node, index);
@@ -12381,7 +12719,7 @@ function collectTryBodyCallees(tryStmt, index, keyFor) {
   return callees;
 }
 function resolveCalleeSummary(call, index) {
-  if (!import_ts_morph56.Node.isCallExpression(call)) {
+  if (!import_ts_morph57.Node.isCallExpression(call)) {
     return null;
   }
   const callee = call.getExpression();
@@ -12407,12 +12745,12 @@ function resolveCalleeSummary(call, index) {
   return null;
 }
 function functionFromDecl(decl) {
-  if (import_ts_morph56.Node.isFunctionDeclaration(decl) || import_ts_morph56.Node.isFunctionExpression(decl) || import_ts_morph56.Node.isArrowFunction(decl) || import_ts_morph56.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph57.Node.isFunctionDeclaration(decl) || import_ts_morph57.Node.isFunctionExpression(decl) || import_ts_morph57.Node.isArrowFunction(decl) || import_ts_morph57.Node.isMethodDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph56.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph57.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
-    if (init !== void 0 && (import_ts_morph56.Node.isArrowFunction(init) || import_ts_morph56.Node.isFunctionExpression(init))) {
+    if (init !== void 0 && (import_ts_morph57.Node.isArrowFunction(init) || import_ts_morph57.Node.isFunctionExpression(init))) {
       return init;
     }
   }
@@ -12420,22 +12758,22 @@ function functionFromDecl(decl) {
 }
 
 // src/shapes/fieldAccesses.ts
-var import_ts_morph57 = require("ts-morph");
+var import_ts_morph58 = require("ts-morph");
 function findResponseAccessor(callExpr) {
   let current2 = callExpr;
   const parent1 = current2.getParent();
-  if (parent1 !== void 0 && import_ts_morph57.Node.isAwaitExpression(parent1)) {
+  if (parent1 !== void 0 && import_ts_morph58.Node.isAwaitExpression(parent1)) {
     current2 = parent1;
   }
   const parent2 = current2.getParent();
-  if (parent2 === void 0 || !import_ts_morph57.Node.isVariableDeclaration(parent2)) {
+  if (parent2 === void 0 || !import_ts_morph58.Node.isVariableDeclaration(parent2)) {
     return null;
   }
   const nameNode = parent2.getNameNode();
-  if (import_ts_morph57.Node.isIdentifier(nameNode)) {
+  if (import_ts_morph58.Node.isIdentifier(nameNode)) {
     return { kind: "identifier", name: nameNode.getText() };
   }
-  if (import_ts_morph57.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph58.Node.isObjectBindingPattern(nameNode)) {
     const bindings = /* @__PURE__ */ new Map();
     for (const element of nameNode.getElements()) {
       if (element.getDotDotDotToken() !== void 0) {
@@ -12456,11 +12794,11 @@ function findResponseAccessor(callExpr) {
 function buildThenChainAccessor(callExpr, func) {
   const bindings = /* @__PURE__ */ new Map();
   func.forEachDescendant((node) => {
-    if (!import_ts_morph57.Node.isParameterDeclaration(node)) {
+    if (!import_ts_morph58.Node.isParameterDeclaration(node)) {
       return;
     }
     const nameNode = node.getNameNode();
-    if (!import_ts_morph57.Node.isIdentifier(nameNode)) {
+    if (!import_ts_morph58.Node.isIdentifier(nameNode)) {
       return;
     }
     const prefix = prefixOfThenParam(node, callExpr, 0);
@@ -12492,7 +12830,7 @@ function prefixOfExpr(expr, responseCall, depth) {
   if (node === responseCall) {
     return [];
   }
-  if (import_ts_morph57.Node.isCallExpression(node)) {
+  if (import_ts_morph58.Node.isCallExpression(node)) {
     const hop = thenLikeCall(node);
     if (hop !== null) {
       if (hop.method === "catch") {
@@ -12524,14 +12862,14 @@ function prefixOfMemberExpr(expr, responseCall, depth) {
     return null;
   }
   const decl = chain.root.getSymbol()?.getDeclarations()?.[0];
-  if (decl === void 0 || !import_ts_morph57.Node.isParameterDeclaration(decl)) {
+  if (decl === void 0 || !import_ts_morph58.Node.isParameterDeclaration(decl)) {
     return null;
   }
   const base = prefixOfThenParam(decl, responseCall, depth + 1);
   return base === null ? null : [...base, ...chain.segments];
 }
 function firstCallbackParamName(callback) {
-  if (callback === void 0 || !(import_ts_morph57.Node.isArrowFunction(callback) || import_ts_morph57.Node.isFunctionExpression(callback))) {
+  if (callback === void 0 || !(import_ts_morph58.Node.isArrowFunction(callback) || import_ts_morph58.Node.isFunctionExpression(callback))) {
     return null;
   }
   const param = callback.getParameters()[0];
@@ -12539,11 +12877,11 @@ function firstCallbackParamName(callback) {
     return null;
   }
   const nameNode = param.getNameNode();
-  return import_ts_morph57.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+  return import_ts_morph58.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
 }
 function unwrap2(expr) {
   let node = expr;
-  while (import_ts_morph57.Node.isAwaitExpression(node) || import_ts_morph57.Node.isParenthesizedExpression(node) || import_ts_morph57.Node.isAsExpression(node)) {
+  while (import_ts_morph58.Node.isAwaitExpression(node) || import_ts_morph58.Node.isParenthesizedExpression(node) || import_ts_morph58.Node.isAsExpression(node)) {
     node = node.getExpression();
   }
   return node;
@@ -12553,15 +12891,15 @@ function chainRootedAt(expr, rootName) {
   if (chain === null) {
     return null;
   }
-  return import_ts_morph57.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
+  return import_ts_morph58.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
 }
 function memberChain(expr) {
-  let node = import_ts_morph57.Node.isExpression(expr) ? unwrap2(expr) : expr;
-  if (import_ts_morph57.Node.isCallExpression(node)) {
+  let node = import_ts_morph58.Node.isExpression(expr) ? unwrap2(expr) : expr;
+  if (import_ts_morph58.Node.isCallExpression(node)) {
     node = node.getExpression();
   }
   const segments = [];
-  while (import_ts_morph57.Node.isPropertyAccessExpression(node)) {
+  while (import_ts_morph58.Node.isPropertyAccessExpression(node)) {
     segments.unshift(node.getName());
     node = node.getExpression();
   }
@@ -12580,16 +12918,16 @@ function collectPropertyAccesses(subtree, accessor) {
   if (accessor.kind === "identifier") {
     const varName = accessor.name;
     subtree.forEachDescendant((node) => {
-      if (!import_ts_morph57.Node.isPropertyAccessExpression(node)) {
+      if (!import_ts_morph58.Node.isPropertyAccessExpression(node)) {
         return;
       }
       const chain = [];
       let current2 = node;
-      while (import_ts_morph57.Node.isPropertyAccessExpression(current2)) {
+      while (import_ts_morph58.Node.isPropertyAccessExpression(current2)) {
         chain.unshift(current2.getName());
         current2 = current2.getExpression();
       }
-      if (import_ts_morph57.Node.isIdentifier(current2) && current2.getText() === varName) {
+      if (import_ts_morph58.Node.isIdentifier(current2) && current2.getText() === varName) {
         pushChain(chain);
       }
     });
@@ -12600,7 +12938,7 @@ function collectPropertyAccesses(subtree, accessor) {
     return source === void 0 ? void 0 : [source];
   } : (name) => accessor.bindings.get(name);
   subtree.forEachDescendant((node) => {
-    if (!import_ts_morph57.Node.isIdentifier(node)) {
+    if (!import_ts_morph58.Node.isIdentifier(node)) {
       return;
     }
     const prefix = prefixOf(node.getText());
@@ -12612,13 +12950,13 @@ function collectPropertyAccesses(subtree, accessor) {
     }
     let chainTop = node;
     let parent = chainTop.getParent();
-    while (parent !== void 0 && import_ts_morph57.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
+    while (parent !== void 0 && import_ts_morph58.Node.isPropertyAccessExpression(parent) && parent.getExpression() === chainTop) {
       chainTop = parent;
       parent = chainTop.getParent();
     }
     const segments = [];
     let current2 = chainTop;
-    while (import_ts_morph57.Node.isPropertyAccessExpression(current2)) {
+    while (import_ts_morph58.Node.isPropertyAccessExpression(current2)) {
       segments.push(current2.getName());
       current2 = current2.getExpression();
     }
@@ -12632,15 +12970,15 @@ function isBindingDeclarationSite(node) {
     return true;
   }
   const parent = node.getParent();
-  return parent !== void 0 && import_ts_morph57.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
+  return parent !== void 0 && import_ts_morph58.Node.isParameterDeclaration(parent) && parent.getNameNode() === node;
 }
 function isInsideObjectBindingPattern(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph57.Node.isObjectBindingPattern(current2)) {
+    if (import_ts_morph58.Node.isObjectBindingPattern(current2)) {
       return true;
     }
-    if (import_ts_morph57.Node.isFunctionLikeDeclaration(current2) || import_ts_morph57.Node.isVariableStatement(current2)) {
+    if (import_ts_morph58.Node.isFunctionLikeDeclaration(current2) || import_ts_morph58.Node.isVariableStatement(current2)) {
       break;
     }
     current2 = current2.getParent();
@@ -12703,7 +13041,7 @@ function findBranchSubtree(func, byLineRange, terminalStartLine, terminalEndLine
     if (parent === void 0) {
       break;
     }
-    if (import_ts_morph57.Node.isIfStatement(parent)) {
+    if (import_ts_morph58.Node.isIfStatement(parent)) {
       const ifStmt = parent;
       const thenBlock = ifStmt.getThenStatement();
       const elseBlock = ifStmt.getElseStatement();
@@ -12765,7 +13103,7 @@ function buildNonBodyPropertySet(semantics) {
 }
 
 // src/subUnitContext.ts
-var import_ts_morph58 = require("ts-morph");
+var import_ts_morph59 = require("ts-morph");
 function createTsSubUnitContext() {
   return {
     findJsxAttributes,
@@ -12778,7 +13116,7 @@ function createTsSubUnitContext() {
 }
 function skipNestedFunctions(parent) {
   return (node, traversal) => {
-    if (node !== parent && (import_ts_morph58.Node.isFunctionDeclaration(node) || import_ts_morph58.Node.isFunctionExpression(node) || import_ts_morph58.Node.isArrowFunction(node) || import_ts_morph58.Node.isMethodDeclaration(node))) {
+    if (node !== parent && (import_ts_morph59.Node.isFunctionDeclaration(node) || import_ts_morph59.Node.isFunctionExpression(node) || import_ts_morph59.Node.isArrowFunction(node) || import_ts_morph59.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return true;
     }
@@ -12792,18 +13130,18 @@ function findJsxAttributes(parent) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph58.Node.isJsxOpeningElement(node) && !import_ts_morph58.Node.isJsxSelfClosingElement(node)) {
+    if (!import_ts_morph59.Node.isJsxOpeningElement(node) && !import_ts_morph59.Node.isJsxSelfClosingElement(node)) {
       return;
     }
     const tag = node.getTagNameNode().getText();
     for (const attr of node.getAttributes()) {
-      if (!import_ts_morph58.Node.isJsxAttribute(attr)) {
+      if (!import_ts_morph59.Node.isJsxAttribute(attr)) {
         continue;
       }
       const initializer = attr.getInitializer();
       let valueExpression = null;
       if (initializer !== void 0) {
-        if (import_ts_morph58.Node.isJsxExpression(initializer)) {
+        if (import_ts_morph59.Node.isJsxExpression(initializer)) {
           const inner = initializer.getExpression();
           valueExpression = inner ?? null;
         } else {
@@ -12826,11 +13164,11 @@ function findCallExpressionsByName(parent, name) {
     if (skip(node, traversal)) {
       return;
     }
-    if (!import_ts_morph58.Node.isCallExpression(node)) {
+    if (!import_ts_morph59.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (import_ts_morph58.Node.isIdentifier(callee) && callee.getText() === name) {
+    if (import_ts_morph59.Node.isIdentifier(callee) && callee.getText() === name) {
       out.push(node);
     }
   });
@@ -12841,10 +13179,10 @@ function resolveAttributeValueFunction(attr, parent) {
   if (expr === null) {
     return null;
   }
-  if (import_ts_morph58.Node.isArrowFunction(expr) || import_ts_morph58.Node.isFunctionExpression(expr)) {
+  if (import_ts_morph59.Node.isArrowFunction(expr) || import_ts_morph59.Node.isFunctionExpression(expr)) {
     return { func: expr, localName: null };
   }
-  if (import_ts_morph58.Node.isIdentifier(expr)) {
+  if (import_ts_morph59.Node.isIdentifier(expr)) {
     const symbol = expr.getSymbol();
     if (symbol === void 0) {
       return null;
@@ -12863,15 +13201,15 @@ function resolveAttributeValueFunction(attr, parent) {
   return null;
 }
 function tryExtractFunction(decl) {
-  if (import_ts_morph58.Node.isFunctionDeclaration(decl)) {
+  if (import_ts_morph59.Node.isFunctionDeclaration(decl)) {
     return decl;
   }
-  if (import_ts_morph58.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph59.Node.isVariableDeclaration(decl)) {
     const init = decl.getInitializer();
     if (init === void 0) {
       return null;
     }
-    if (import_ts_morph58.Node.isArrowFunction(init) || import_ts_morph58.Node.isFunctionExpression(init)) {
+    if (import_ts_morph59.Node.isArrowFunction(init) || import_ts_morph59.Node.isFunctionExpression(init)) {
       return init;
     }
   }
@@ -12892,7 +13230,7 @@ function getCallArgumentFunction(call, position) {
   if (arg === void 0) {
     return null;
   }
-  if (import_ts_morph58.Node.isArrowFunction(arg) || import_ts_morph58.Node.isFunctionExpression(arg)) {
+  if (import_ts_morph59.Node.isArrowFunction(arg) || import_ts_morph59.Node.isFunctionExpression(arg)) {
     return arg;
   }
   return null;
@@ -12904,7 +13242,7 @@ function readArrayLiteralText(node) {
   if (node === null) {
     return null;
   }
-  if (import_ts_morph58.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph59.Node.isArrayLiteralExpression(node)) {
     return node.getElements().map((e) => e.getText());
   }
   return [node.getText()];
@@ -12913,7 +13251,7 @@ function readArrayLiteralText(node) {
 // src/summaryIdentity.ts
 var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path7 = __toESM(require("path"), 1);
-var import_behavioral_ir6 = require("@suss/behavioral-ir");
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
 function workspaceRootFor(anchor) {
   return namedPackageDirAbove(anchor) ?? import_node_path7.default.resolve(anchor);
 }
@@ -12962,7 +13300,7 @@ function nameSummaries(summaries, args) {
     }
     summary.identity.id = idFor(args.workspace, file, summary);
   }
-  (0, import_behavioral_ir6.disambiguateSummaryIds)(summaries);
+  (0, import_behavioral_ir7.disambiguateSummaryIds)(summaries);
   nameWhatEachCallReaches(summaries);
 }
 function relativeFile(file, projectRoot) {
@@ -12973,7 +13311,7 @@ function relativeFile(file, projectRoot) {
   return relative.startsWith("..") ? file : relative;
 }
 function idFor(workspace, file, summary) {
-  return (0, import_behavioral_ir6.summaryIdFromParts)({
+  return (0, import_behavioral_ir7.summaryIdFromParts)({
     workspace: workspace ?? void 0,
     file,
     name: summary.identity.name,
@@ -13143,13 +13481,13 @@ var raise = (msg) => {
   throw new Error(msg);
 };
 function bindingPatternNames(nameNode) {
-  if (import_ts_morph59.Node.isObjectBindingPattern(nameNode)) {
+  if (import_ts_morph60.Node.isObjectBindingPattern(nameNode)) {
     return nameNode.getElements().map((e) => e.getName());
   }
-  if (import_ts_morph59.Node.isArrayBindingPattern(nameNode)) {
+  if (import_ts_morph60.Node.isArrayBindingPattern(nameNode)) {
     const names = [];
     for (const element of nameNode.getElements()) {
-      if (import_ts_morph59.Node.isOmittedExpression(element)) {
+      if (import_ts_morph60.Node.isOmittedExpression(element)) {
         continue;
       }
       names.push(element.getName());
@@ -13158,9 +13496,28 @@ function bindingPatternNames(nameNode) {
   }
   return null;
 }
+function objectParamInputs(param, position, mapping) {
+  const boundNames = bindingPatternNames(param.getNameNode());
+  if (boundNames === null) {
+    return [
+      {
+        name: param.getName(),
+        position,
+        role: mapping.wholeParamRole ?? "request",
+        typeText: null
+      }
+    ];
+  }
+  return boundNames.map((name) => ({
+    name,
+    position,
+    role: mapping.knownProperties[name] ?? name,
+    typeText: null
+  }));
+}
 function componentPropsParameters(param, mapping) {
   const nameNode = param.getNameNode();
-  if (!import_ts_morph59.Node.isObjectBindingPattern(nameNode)) {
+  if (!import_ts_morph60.Node.isObjectBindingPattern(nameNode)) {
     const type = param.getType();
     return [
       {
@@ -13198,34 +13555,11 @@ function extractParameters(func, inputMapping) {
         typeText: null
       });
     }
-  } else if (inputMapping.type === "singleObjectParam") {
-    const param = params[inputMapping.paramPosition];
+  } else if (inputMapping.type === "objectParam") {
+    const position = inputMapping.paramPosition ?? 0;
+    const param = params[position];
     if (param !== void 0) {
-      result.push({
-        name: param.getName(),
-        position: inputMapping.paramPosition,
-        role: "request",
-        typeText: null
-      });
-    }
-  } else if (inputMapping.type === "destructuredObject") {
-    const param = params[0];
-    if (param !== void 0) {
-      const nameNode = param.getNameNode();
-      const boundNames = bindingPatternNames(nameNode);
-      if (boundNames !== null) {
-        for (const name of boundNames) {
-          const role = inputMapping.knownProperties[name] ?? name;
-          result.push({ name, position: 0, role, typeText: null });
-        }
-      } else {
-        result.push({
-          name: param.getName(),
-          position: 0,
-          role: "request",
-          typeText: null
-        });
-      }
+      result.push(...objectParamInputs(param, position, inputMapping));
     }
   } else if (inputMapping.type === "allPositional") {
     for (let i = 0; i < params.length; i++) {
@@ -13286,11 +13620,11 @@ function extractParameters(func, inputMapping) {
 function extractDependencyCalls(func) {
   const results = [];
   func.forEachDescendant((node, traversal) => {
-    if (node !== func && (import_ts_morph59.Node.isFunctionDeclaration(node) || import_ts_morph59.Node.isFunctionExpression(node) || import_ts_morph59.Node.isArrowFunction(node) || import_ts_morph59.Node.isMethodDeclaration(node))) {
+    if (node !== func && (import_ts_morph60.Node.isFunctionDeclaration(node) || import_ts_morph60.Node.isFunctionExpression(node) || import_ts_morph60.Node.isArrowFunction(node) || import_ts_morph60.Node.isMethodDeclaration(node))) {
       traversal.skip();
       return;
     }
-    if (!import_ts_morph59.Node.isVariableDeclaration(node)) {
+    if (!import_ts_morph60.Node.isVariableDeclaration(node)) {
       return;
     }
     const init = node.getInitializer();
@@ -13299,19 +13633,19 @@ function extractDependencyCalls(func) {
     }
     let isAsync = false;
     let callExpr = init;
-    if (import_ts_morph59.Node.isAwaitExpression(init)) {
+    if (import_ts_morph60.Node.isAwaitExpression(init)) {
       isAsync = true;
       callExpr = init.getExpression();
     }
-    if (!import_ts_morph59.Node.isCallExpression(callExpr)) {
+    if (!import_ts_morph60.Node.isCallExpression(callExpr)) {
       return;
     }
     const calleeName = callExpr.getExpression().getText();
     const nameNode = node.getNameNode();
-    const assignedTo = import_ts_morph59.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
+    const assignedTo = import_ts_morph60.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
     const declList = node.getParent();
     const varStmt = declList?.getParent();
-    const locationNode = varStmt !== void 0 && import_ts_morph59.Node.isVariableStatement(varStmt) ? varStmt : node;
+    const locationNode = varStmt !== void 0 && import_ts_morph60.Node.isVariableStatement(varStmt) ? varStmt : node;
     results.push({
       name: calleeName,
       assignedTo,
@@ -13553,7 +13887,7 @@ function extractConsumerBinding(unit, pattern, pack, resolution) {
   }
   const method = extractBindingMethod(binding, callSite, pack, resolution);
   const path12 = extractBindingPath(binding, callSite, pack, resolution);
-  return (0, import_behavioral_ir7.restBinding)({
+  return (0, import_behavioral_ir8.restBinding)({
     transport: pack.protocol,
     method: method ?? null,
     path: path12 ?? null,
@@ -13572,7 +13906,7 @@ function fileRouteBinding(filePath, unit, binding, pack) {
   if (method === void 0) {
     return null;
   }
-  return (0, import_behavioral_ir7.restBinding)({
+  return (0, import_behavioral_ir8.restBinding)({
     transport: pack.protocol,
     recognition: pack.name,
     method,
@@ -13596,9 +13930,9 @@ function extractBindingMethod(binding, callSite, pack, resolution) {
   if (m.type === "fromArgumentProperty") {
     const args = callSite.callExpression.getArguments();
     const arg = args[m.position];
-    if (arg !== void 0 && import_ts_morph59.Node.isObjectLiteralExpression(arg)) {
+    if (arg !== void 0 && import_ts_morph60.Node.isObjectLiteralExpression(arg)) {
       const prop = arg.getProperty(m.property);
-      if (prop !== void 0 && import_ts_morph59.Node.isPropertyAssignment(prop)) {
+      if (prop !== void 0 && import_ts_morph60.Node.isPropertyAssignment(prop)) {
         const init = prop.getInitializer();
         if (init !== void 0) {
           const value = stringValueOf(init, resolution);
@@ -13615,138 +13949,17 @@ function extractBindingMethod(binding, callSite, pack, resolution) {
   }
   return void 0;
 }
-var URL_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//;
-var URL_ORIGIN = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\/[^/]*/;
-var PROTOCOL_RELATIVE = /^\/\//;
-var PROTOCOL_RELATIVE_ORIGIN = /^\/\/[^/]*/;
-function isAbsoluteUrlLiteral(text) {
-  return URL_SCHEME.test(text) || PROTOCOL_RELATIVE.test(text);
-}
-function stripOriginManually(text) {
-  if (URL_SCHEME.test(text)) {
-    return text.replace(URL_ORIGIN, "");
-  }
-  if (PROTOCOL_RELATIVE.test(text)) {
-    return text.replace(PROTOCOL_RELATIVE_ORIGIN, "");
-  }
-  return text;
-}
-function stripQueryAndFragment(text) {
-  const idx = text.search(/[?#]/);
-  return idx === -1 ? text : text.slice(0, idx);
-}
-var SUBSTITUTION = "\uFFFF";
-var AUTHORITY_OPENER = /^(?:[-+.\uFFFFa-zA-Z0-9]+:\/\/|\/\/)/;
-function originEndOf(flattened) {
-  const opener = AUTHORITY_OPENER.exec(flattened);
-  if (opener === null) {
-    return 0;
-  }
-  const slash = flattened.indexOf("/", opener[0].length);
-  return slash === -1 ? flattened.length : slash;
-}
-function appendPathText(path12, text) {
-  const idx = text.search(/[?#]/);
-  if (idx === -1) {
-    return { path: path12 + text, stop: false };
-  }
-  return { path: path12 + text.slice(0, idx), stop: true };
-}
-function parseAbsoluteUrl(text) {
-  try {
-    return new URL(text);
-  } catch {
-  }
-  if (!PROTOCOL_RELATIVE.test(text)) {
-    return void 0;
-  }
-  try {
-    return new URL(`https:${text}`);
-  } catch {
-    return void 0;
-  }
-}
-function pathnameOfAbsoluteLiteral(text) {
-  const parsed = parseAbsoluteUrl(text);
-  if (parsed !== void 0) {
-    return parsed.pathname;
-  }
-  return stripQueryAndFragment(stripOriginManually(text));
-}
-function pathFromLiteralUrl(text) {
-  const path12 = isAbsoluteUrlLiteral(text) ? pathnameOfAbsoluteLiteral(text) : stripQueryAndFragment(text);
-  return path12 === "" ? void 0 : path12;
-}
-function pathFromTemplateUrl(arg) {
-  const headText = arg.getHead().getLiteralText();
-  const spans = arg.getTemplateSpans();
-  const tails = spans.map((span) => span.getLiteral().getLiteralText());
-  const originEnd = originEndOf([headText, ...tails].join(SUBSTITUTION));
-  const head = appendPathText("", headText.slice(originEnd));
-  let path12 = head.path;
-  let stop = head.stop;
-  let at = headText.length;
-  for (let i = 0; i < spans.length && !stop; i++) {
-    const span = spans[i];
-    const tailText = tails[i];
-    if (span === void 0 || tailText === void 0) {
-      continue;
-    }
-    if (at >= originEnd) {
-      path12 += `{${placeholderName(span.getExpression())}}`;
-    }
-    at += SUBSTITUTION.length;
-    const appended = appendPathText(
-      path12,
-      tailText.slice(Math.max(0, originEnd - at))
-    );
-    path12 = appended.path;
-    stop = appended.stop;
-    at += tailText.length;
-  }
-  return path12 === "" ? void 0 : path12;
-}
 function extractBindingPath(binding, callSite, pack, resolution) {
   const p = binding.path;
   if (p.type === "fromClientMethod") {
     return resolveContractField(callSite, pack, "path");
   }
-  if (p.type === "fromArgumentLiteral") {
-    const args = callSite.callExpression.getArguments();
-    const arg = args[p.position];
-    if (arg === void 0) {
-      return void 0;
-    }
-    const written = pathFromUrlNode(arg);
-    if (written !== void 0) {
-      return written;
-    }
-    const resolved = resolution?.resolveWrittenValue(arg) ?? null;
-    return resolved !== null ? pathFromUrlNode(resolved) : void 0;
-  }
-  return void 0;
-}
-function pathFromUrlNode(node) {
-  if (import_ts_morph59.Node.isStringLiteral(node)) {
-    return pathFromLiteralUrl(node.getLiteralValue());
-  }
-  if (import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(node)) {
-    return pathFromLiteralUrl(node.getLiteralValue());
-  }
-  if (import_ts_morph59.Node.isTemplateExpression(node)) {
-    return pathFromTemplateUrl(node);
+  if (p.type === "fromArgument") {
+    const arg = callSite.callExpression.getArguments()[p.position];
+    return arg === void 0 ? void 0 : pathFromArgument(arg, resolution);
   }
   return void 0;
 }
-function placeholderName(expr) {
-  if (import_ts_morph59.Node.isIdentifier(expr)) {
-    return expr.getText();
-  }
-  if (import_ts_morph59.Node.isPropertyAccessExpression(expr)) {
-    return expr.getName();
-  }
-  return "param";
-}
 function resolveContractField(callSite, pack, field) {
   if (pack.contractReading === void 0 || callSite.methodName === null) {
     return void 0;
@@ -13934,7 +14147,7 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
       }
       const matchedPattern = unit.pattern ?? pack.discovery.find((d) => d.kind === unit.kind);
       if (unit.resolverInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir7.graphqlResolverBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir8.graphqlResolverBinding)({
           transport: pack.protocol,
           recognition: pack.name,
           typeName: unit.resolverInfo.typeName,
@@ -13961,20 +14174,20 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
           }
         }
       } else if (unit.routeInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir7.restBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir8.restBinding)({
           transport: pack.protocol,
           recognition: pack.name,
           method: unit.routeInfo.method,
           path: unit.routeInfo.path
         });
       } else if (unit.channelInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir7.messageBusBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir8.messageBusBinding)({
           recognition: pack.name,
           messageBus: unit.channelInfo.messageBus,
           channel: unit.channelInfo.channel
         });
       } else if (unit.operationInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir7.graphqlOperationBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir8.graphqlOperationBinding)({
           transport: pack.protocol,
           recognition: pack.name,
           operationType: unit.operationInfo.operationType,
@@ -14053,14 +14266,14 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
       }
       if (raw.boundaryBinding === null) {
         if (unit.packageExportInfo !== void 0) {
-          raw.boundaryBinding = (0, import_behavioral_ir7.packageExportBinding)({
+          raw.boundaryBinding = (0, import_behavioral_ir8.packageExportBinding)({
             transport: pack.protocol,
             recognition: pack.name,
             packageName: unit.packageExportInfo.packageName,
             exportPath: unit.packageExportInfo.exportPath
           });
         } else {
-          raw.boundaryBinding = (0, import_behavioral_ir7.functionCallBinding)({
+          raw.boundaryBinding = (0, import_behavioral_ir8.functionCallBinding)({
             transport: pack.protocol,
             recognition: pack.name
           });
@@ -14142,14 +14355,14 @@ function fileImporting(project, modulePrefix) {
 function liftSchemasOntoDocuments(summaries) {
   const sdlByDocument = /* @__PURE__ */ new Map();
   for (const summary of summaries) {
-    const label = (0, import_behavioral_ir7.readSourceDocumentMetadata)(summary)?.label;
-    const graphql = (0, import_behavioral_ir7.readGraphqlMetadata)(summary);
+    const label = (0, import_behavioral_ir8.readSourceDocumentMetadata)(summary)?.label;
+    const graphql = (0, import_behavioral_ir8.readGraphqlMetadata)(summary);
     if (label === void 0 || graphql?.schemaSdl === void 0) {
       continue;
     }
     sdlByDocument.set(label, graphql.schemaSdl);
     const { schemaSdl: _movedToTheDocument, ...rest } = graphql;
-    summary.metadata = (0, import_behavioral_ir7.withGraphqlMetadata)(summary.metadata, rest);
+    summary.metadata = (0, import_behavioral_ir8.withGraphqlMetadata)(summary.metadata, rest);
   }
   for (const [label, schemaSdl] of sdlByDocument) {
     summaries.push(schemaDocumentSummary(label, schemaSdl));
@@ -14164,8 +14377,8 @@ function schemaDocumentSummary(label, schemaSdl) {
     transitions: [],
     gaps: [],
     confidence: { source: "declared", level: "high" },
-    metadata: (0, import_behavioral_ir7.withGraphqlMetadata)(
-      (0, import_behavioral_ir7.withSourceDocumentMetadata)(void 0, { label }),
+    metadata: (0, import_behavioral_ir8.withGraphqlMetadata)(
+      (0, import_behavioral_ir8.withSourceDocumentMetadata)(void 0, { label }),
       { schemaSdl }
     )
   };
@@ -14177,7 +14390,7 @@ function libraryEnvReadMarker(pack, declared, importer) {
     identity: {
       name: `${declared.module} env reads`,
       exportPath: null,
-      boundaryBinding: (0, import_behavioral_ir7.functionCallBinding)({
+      boundaryBinding: (0, import_behavioral_ir8.functionCallBinding)({
         transport: "in-process",
         recognition: pack.name
       })
@@ -14214,7 +14427,7 @@ function internalImportsOf(project, file) {
   }
   return [...targets].sort();
 }
-function expandWrapperCallers(summaries, project, options) {
+function expandWrapperCallers(summaries, project, options, resolution) {
   const wrappers = [];
   let lookup = null;
   for (const s of summaries) {
@@ -14241,7 +14454,9 @@ function expandWrapperCallers(summaries, project, options) {
   }
   const derived = [];
   for (const wrapper of wrappers) {
-    derived.push(...synthesizeCallerSummaries(wrapper, project, options));
+    derived.push(
+      ...synthesizeCallerSummaries(wrapper, project, options, resolution)
+    );
   }
   return [...summaries, ...derived];
 }
@@ -14254,9 +14469,9 @@ function findWrapperPathParam(summary, lookup) {
   if (names.length === 0) {
     return null;
   }
-  for (const call of func.getDescendantsOfKind(import_ts_morph59.SyntaxKind.CallExpression)) {
+  for (const call of func.getDescendantsOfKind(import_ts_morph60.SyntaxKind.CallExpression)) {
     const first = call.getArguments()[0];
-    if (first === void 0 || !import_ts_morph59.Node.isIdentifier(first)) {
+    if (first === void 0 || !import_ts_morph60.Node.isIdentifier(first)) {
       continue;
     }
     const at = names.indexOf(first.getText());
@@ -14266,7 +14481,7 @@ function findWrapperPathParam(summary, lookup) {
   }
   return null;
 }
-function synthesizeCallerSummaries(wrapper, _project, options) {
+function synthesizeCallerSummaries(wrapper, _project, options, resolution) {
   const nameNode = wrapperNameNode(wrapper.func);
   if (nameNode === null) {
     return [];
@@ -14287,7 +14502,7 @@ function synthesizeCallerSummaries(wrapper, _project, options) {
     if (pathArg === void 0) {
       continue;
     }
-    const path12 = literalOrTemplate(pathArg);
+    const path12 = pathFromArgument(pathArg, resolution);
     if (path12 === void 0) {
       continue;
     }
@@ -14305,16 +14520,16 @@ function synthesizeCallerSummaries(wrapper, _project, options) {
   return out;
 }
 function wrapperNameNode(func) {
-  if (import_ts_morph59.Node.isFunctionDeclaration(func) || import_ts_morph59.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph60.Node.isFunctionDeclaration(func) || import_ts_morph60.Node.isMethodDeclaration(func)) {
     const name = func.getNameNode();
-    if (name !== void 0 && import_ts_morph59.Node.isIdentifier(name)) {
+    if (name !== void 0 && import_ts_morph60.Node.isIdentifier(name)) {
       return name;
     }
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph59.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph60.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph59.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph60.Node.isIdentifier(nameNode)) {
       return nameNode;
     }
   }
@@ -14323,10 +14538,10 @@ function wrapperNameNode(func) {
 function enclosingCall(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph59.Node.isCallExpression(current2)) {
+    if (import_ts_morph60.Node.isCallExpression(current2)) {
       return current2;
     }
-    if (import_ts_morph59.Node.isPropertyAccessExpression(current2)) {
+    if (import_ts_morph60.Node.isPropertyAccessExpression(current2)) {
       current2 = current2.getParent();
       continue;
     }
@@ -14337,38 +14552,21 @@ function enclosingCall(node) {
 function enclosingFunction(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph59.Node.isFunctionDeclaration(current2) || import_ts_morph59.Node.isFunctionExpression(current2) || import_ts_morph59.Node.isArrowFunction(current2) || import_ts_morph59.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph60.Node.isFunctionDeclaration(current2) || import_ts_morph60.Node.isFunctionExpression(current2) || import_ts_morph60.Node.isArrowFunction(current2) || import_ts_morph60.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
   }
   return null;
 }
-function literalOrTemplate(arg) {
-  if (import_ts_morph59.Node.isStringLiteral(arg)) {
-    return arg.getLiteralValue();
-  }
-  if (import_ts_morph59.Node.isNoSubstitutionTemplateLiteral(arg)) {
-    return arg.getLiteralValue();
-  }
-  if (import_ts_morph59.Node.isTemplateExpression(arg)) {
-    let path12 = arg.getHead().getLiteralText();
-    for (const span of arg.getTemplateSpans()) {
-      path12 += `{${placeholderName(span.getExpression())}}`;
-      path12 += span.getLiteral().getLiteralText();
-    }
-    return path12;
-  }
-  return void 0;
-}
 function callerName(func) {
-  if (import_ts_morph59.Node.isFunctionDeclaration(func) || import_ts_morph59.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph60.Node.isFunctionDeclaration(func) || import_ts_morph60.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "anonymous";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph59.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph60.Node.isVariableDeclaration(parent)) {
     const nameNode = parent.getNameNode();
-    if (import_ts_morph59.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph60.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
   }
@@ -14403,7 +14601,7 @@ function buildCallerSummary(wrapper, callerFunc, callExpr, path12, options) {
     }
   };
   const raw = extractCodeStructure(unit, syntheticPack);
-  raw.boundaryBinding = (0, import_behavioral_ir7.restBinding)({
+  raw.boundaryBinding = (0, import_behavioral_ir8.restBinding)({
     transport: wrapperBinding?.transport ?? "http",
     method: wrapperRest?.method ?? null,
     path: path12,
@@ -14473,7 +14671,7 @@ function loadRunFiles(project, candidatePaths, timer) {
   return { sourceFiles, deep };
 }
 function createTypeScriptAdapter(config) {
-  const project = config.project ?? new import_ts_morph59.Project(
+  const project = config.project ?? new import_ts_morph60.Project(
     config.tsConfigFilePath !== void 0 ? {
       tsConfigFilePath: config.tsConfigFilePath,
       skipAddingFilesFromTsConfig: true
@@ -14678,7 +14876,12 @@ function createTypeScriptAdapter(config) {
       const wrapperInput = reused === null ? summaries : [...summaries, ...reused.summaries];
       const withWrappers = timer.time(
         "expandWrapperCallers",
-        () => expandWrapperCallers(wrapperInput, project, config.extractorOptions)
+        () => expandWrapperCallers(
+          wrapperInput,
+          project,
+          config.extractorOptions,
+          resolution
+        )
       );
       const pipeline = reused === null ? withWrappers : [...summaries, ...withWrappers.slice(wrapperInput.length)];
       const withSubUnits = timer.time(
@@ -14934,10 +15137,10 @@ function mergeWithReused(reused, fresh, ownersBySummary) {
   return { summaries: [...reusedKept, ...fresh], reusedKept, reusedOwners };
 }
 function readsRunLevelJoins(summary) {
-  if ((0, import_behavioral_ir7.readSourceDocumentMetadata)(summary) !== void 0) {
+  if ((0, import_behavioral_ir8.readSourceDocumentMetadata)(summary) !== void 0) {
     return true;
   }
-  if ((0, import_behavioral_ir7.readGraphqlMetadata)(summary)?.client !== void 0) {
+  if ((0, import_behavioral_ir8.readGraphqlMetadata)(summary)?.client !== void 0) {
     return true;
   }
   const semantics = summary.identity.boundaryBinding?.semantics;
@@ -15120,7 +15323,7 @@ function buildSubUnitSummary(subUnit, parent, invocationRecognizers, accessRecog
 // src/bootstrap/noTsconfigProject.ts
 var import_node_fs6 = __toESM(require("fs"), 1);
 var import_node_path10 = __toESM(require("path"), 1);
-var import_ts_morph60 = require("ts-morph");
+var import_ts_morph61 = require("ts-morph");
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -15168,12 +15371,12 @@ function findSourceFiles(rootDir, depth = 0) {
   return found;
 }
 function createProjectWithoutTsconfig(rootDir) {
-  const project = new import_ts_morph60.Project({
+  const project = new import_ts_morph61.Project({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: {
-      target: import_ts_morph60.ScriptTarget.ES2022,
-      module: import_ts_morph60.ModuleKind.ESNext,
-      moduleResolution: import_ts_morph60.ModuleResolutionKind.Bundler,
+      target: import_ts_morph61.ScriptTarget.ES2022,
+      module: import_ts_morph61.ModuleKind.ESNext,
+      moduleResolution: import_ts_morph61.ModuleResolutionKind.Bundler,
       allowJs: true,
       checkJs: false,
       noEmit: true,
@@ -15214,7 +15417,7 @@ function findNearestTsconfig(startDir) {
 
 // src/facts/why.ts
 var import_node_path11 = __toESM(require("path"), 1);
-var import_ts_morph61 = require("ts-morph");
+var import_ts_morph62 = require("ts-morph");
 var import_resolution2 = require("@suss/resolution");
 var JS_PHRASES = {
   bind: ({ tuple, describe }) => ({
@@ -15228,7 +15431,7 @@ var WhySession = class {
   constructor(options) {
     this.root = import_node_path11.default.resolve(options.dir);
     const tsconfig = findNearestTsconfig(this.root);
-    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph61.Project({ tsConfigFilePath: tsconfig });
+    this.project = tsconfig === null ? createProjectWithoutTsconfig(this.root).project : new import_ts_morph62.Project({ tsConfigFilePath: tsconfig });
     this.store = new ResolutionStore();
   }
   /**
@@ -15243,7 +15446,7 @@ var WhySession = class {
     }
     let found = null;
     sourceFile.forEachDescendant((node) => {
-      if (import_ts_morph61.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
+      if (import_ts_morph62.Node.isExpression(node) && node.getStartLineNumber() === line && node.getText() === text && (found === null || node.getWidth() <= found.getWidth())) {
         found = node;
       }
     });
@@ -15261,7 +15464,7 @@ var WhySession = class {
       return null;
     }
     for (const call of sourceFile.getDescendantsOfKind(
-      import_ts_morph61.SyntaxKind.CallExpression
+      import_ts_morph62.SyntaxKind.CallExpression
     )) {
       const line = call.getStartLineNumber();
       if (line < startLine || line > endLine) {
@@ -15335,21 +15538,21 @@ var WhySession = class {
   }
 };
 function displayNameOf(node) {
-  if (import_ts_morph61.Node.isIdentifier(node) || import_ts_morph61.Node.isPropertyAccessExpression(node)) {
+  if (import_ts_morph62.Node.isIdentifier(node) || import_ts_morph62.Node.isPropertyAccessExpression(node)) {
     return node.getText();
   }
-  if (import_ts_morph61.Node.isCallExpression(node) || import_ts_morph61.Node.isNewExpression(node)) {
+  if (import_ts_morph62.Node.isCallExpression(node) || import_ts_morph62.Node.isNewExpression(node)) {
     return `${node.getExpression()?.getText() ?? "call"}(...)`;
   }
-  if (import_ts_morph61.Node.isFunctionDeclaration(node) || import_ts_morph61.Node.isClassDeclaration(node) || import_ts_morph61.Node.isMethodDeclaration(node) || import_ts_morph61.Node.isVariableDeclaration(node)) {
+  if (import_ts_morph62.Node.isFunctionDeclaration(node) || import_ts_morph62.Node.isClassDeclaration(node) || import_ts_morph62.Node.isMethodDeclaration(node) || import_ts_morph62.Node.isVariableDeclaration(node)) {
     const name = node.getName();
     if (name !== void 0) {
       return name;
     }
   }
-  if (import_ts_morph61.Node.isArrowFunction(node) || import_ts_morph61.Node.isFunctionExpression(node)) {
+  if (import_ts_morph62.Node.isArrowFunction(node) || import_ts_morph62.Node.isFunctionExpression(node)) {
     const parent = node.getParent();
-    if (parent !== void 0 && import_ts_morph61.Node.isVariableDeclaration(parent)) {
+    if (parent !== void 0 && import_ts_morph62.Node.isVariableDeclaration(parent)) {
       return parent.getName();
     }
   }
@@ -15550,6 +15753,7 @@ function formatPackHealth(checks, audiences) {
   ADAPTER_VERSION,
   ResolutionStore,
   WhySession,
+  accessContextFor,
   callOpsFor,
   collectAncestorBranches,
   collectClientFieldAccesses,
@@ -15567,6 +15771,7 @@ function formatPackHealth(checks, audiences) {
   findNearestTsconfig,
   findTerminals,
   formatPackHealth,
+  invocationContextFor,
   isImportedFrom,
   methodDeclaredIn,
   parseConditionExpression,