@suss/adapter-typescript 0.22.0 → 0.22.2

package/dist/index.js

@@ -3,7 +3,7 @@ import path10 from "path";
 import {
   Node as Node64,
   Project,
-  SyntaxKind as SyntaxKind11
+  SyntaxKind as SyntaxKind12
 } from "ts-morph";
 import {
   functionCallBinding as functionCallBinding2,
@@ -664,14 +664,14 @@ function parseConditionExpression(expr, depth = 0) {
     if (expr.getOperatorToken() !== SyntaxKind2.ExclamationToken) {
       return null;
     }
-    const operand = expr.getOperand();
-    const inner = parseConditionExpression(operand, depth);
+    const operand2 = expr.getOperand();
+    const inner = parseConditionExpression(operand2, depth);
     if (inner === null) {
       return {
         type: "negation",
         operand: {
           type: "opaque",
-          sourceText: operand.getText(),
+          sourceText: operand2.getText(),
           reason: "complexExpression"
         }
       };
@@ -735,8 +735,8 @@ function parseConditionExpression(expr, depth = 0) {
         const rightIsNull = isNullOrUndefined(right);
         if (leftIsNull || rightIsNull) {
           const subject = resolveSubject(leftIsNull ? right : left);
-          const negated = op === "neq";
-          return { type: "nullCheck", subject, negated };
+          const negated2 = op === "neq";
+          return { type: "nullCheck", subject, negated: negated2 };
         }
       }
       if (Node5.isTypeOfExpression(left) && Node5.isStringLiteral(right) && (opText === "===" || opText === "==")) {
@@ -2583,7 +2583,7 @@ function isNotYetPlaceholder(value) {
   return value.getKind() === SyntaxKind3.NullKeyword || Node13.isIdentifier(value) && value.getText() === "undefined";
 }
 function isConstruction(value) {
-  return Node13.isCallExpression(value) || Node13.isNewExpression(value);
+  return Node13.isCallExpression(value) || Node13.isNewExpression(value) || Node13.isObjectLiteralExpression(value) || Node13.isArrayLiteralExpression(value);
 }
 function sourceOf(node) {
   return node.getText().replace(/\s+/g, " ").trim();
@@ -3054,10 +3054,10 @@ function emitValue(db, table, value) {
     }
     return id;
   }
-  const fallback = asFallbackExpression(expression);
-  if (fallback !== null) {
-    fact(db, "fallbackBranch", id, emitValue(db, table, fallback.getLeft()));
-    fact(db, "fallbackBranch", id, emitValue(db, table, fallback.getRight()));
+  const fallback2 = asFallbackExpression(expression);
+  if (fallback2 !== null) {
+    fact(db, "fallbackBranch", id, emitValue(db, table, fallback2.getLeft()));
+    fact(db, "fallbackBranch", id, emitValue(db, table, fallback2.getRight()));
     return id;
   }
   if (Node14.isCallExpression(expression) || Node14.isNewExpression(expression)) {
@@ -3145,9 +3145,9 @@ function emitBindingElementFacts(db, table, element) {
       property.getText()
     );
   }
-  const fallback = element.getInitializer();
-  if (fallback !== void 0) {
-    fact(db, "binds", id, emitValue(db, table, fallback));
+  const fallback2 = element.getInitializer();
+  if (fallback2 !== void 0) {
+    fact(db, "binds", id, emitValue(db, table, fallback2));
   }
   return id;
 }
@@ -4352,7 +4352,7 @@ function declarationOf(value) {
 }
 
 // src/discovery/clientCall.ts
-import { Node as Node17 } from "ts-morph";
+import { Node as Node18 } from "ts-morph";
 
 // src/discovery/importScan.ts
 import path3 from "path";
@@ -4381,8 +4381,8 @@ function commonDirectoryOf(files) {
     }
     shared = shared.slice(0, i);
   }
-  const joined = shared.join(path2.sep);
-  return joined.length > 1 ? joined : void 0;
+  const joined2 = shared.join(path2.sep);
+  return joined2.length > 1 ? joined2 : void 0;
 }
 var DEFAULT_RESOLUTION = {
   moduleResolution: ts3.ModuleResolutionKind.Bundler,
@@ -4649,15 +4649,609 @@ function resolveImportedLocalName(sourceFile, importModule, importName) {
 }
 
 // src/discovery/resolveValue.ts
-import { Node as Node16 } from "ts-morph";
+import { Node as Node17 } from "ts-morph";
+import { force as force2, literalOf } from "@suss/values";
+
+// src/values/evaluator.ts
+import { Evaluator, force } from "@suss/values";
+
+// src/values/lowering.ts
+import { Node as Node16, SyntaxKind as SyntaxKind5 } from "ts-morph";
+var ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([
+  "=",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "??=",
+  "||=",
+  "&&="
+]);
+var MUTATING_METHODS = /* @__PURE__ */ new Set([
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin"
+]);
+function typescriptLowering(options) {
+  const { resolution, rows } = options;
+  const rowModules = [
+    ...new Set(
+      rows.flatMap((row) => row.kind === "callee" ? [row.origin.module] : [])
+    )
+  ];
+  const mutatedByRoot = /* @__PURE__ */ new Map();
+  const originOf = (callee) => {
+    const chain = memberChainOf(callee);
+    if (chain === null) {
+      return null;
+    }
+    const name = chain.names[chain.names.length - 1] ?? null;
+    if (name === null) {
+      return null;
+    }
+    const origins = resolution?.importOriginsOf(chain.root, rowModules) ?? [];
+    const first = origins[0];
+    if (first !== void 0) {
+      return { module: first.module, name };
+    }
+    const local = resolution !== void 0 && resolution.resolveCallable(callee) !== null;
+    if (chain.names.length > 1 || local) {
+      return null;
+    }
+    return { module: "global", name };
+  };
+  return {
+    expression: (node) => expressionOf(peelValue(node), originOf),
+    statement: statementOf2,
+    siteOf,
+    functionOf,
+    writtenTo: (node) => {
+      if (resolution === void 0) {
+        return null;
+      }
+      const target = peelValue(node);
+      return resolution.resolveWrittenValue(target) ?? resolution.resolveObject(target);
+    },
+    callable: (node) => {
+      const call = peelValue(node);
+      if (resolution === void 0 || !Node16.isCallExpression(call) && !Node16.isNewExpression(call)) {
+        return null;
+      }
+      const target = resolution.resolveCallable(call.getExpression());
+      return target !== null && Node16.isFunctionLikeDeclaration(target) ? target : null;
+    },
+    mutatedInNestedFunction: (root, name) => {
+      let mutated = mutatedByRoot.get(root);
+      if (mutated === void 0) {
+        mutated = namesMutatedInNestedFunctions(root);
+        mutatedByRoot.set(root, mutated);
+      }
+      return mutated.has(name);
+    },
+    freeNamesOf,
+    holeNameOf: placeholderName,
+    rows
+  };
+}
+function placeholderName(expr) {
+  if (Node16.isIdentifier(expr)) {
+    return expr.getText();
+  }
+  if (Node16.isPropertyAccessExpression(expr)) {
+    return expr.getName();
+  }
+  return "param";
+}
+function expressionOf(node, originOf) {
+  if (Node16.isStringLiteral(node) || Node16.isNoSubstitutionTemplateLiteral(node)) {
+    return { kind: "literal", value: node.getLiteralValue() };
+  }
+  if (Node16.isNumericLiteral(node)) {
+    return { kind: "literal", value: node.getLiteralValue() };
+  }
+  if (Node16.isTrueLiteral(node)) {
+    return { kind: "literal", value: true };
+  }
+  if (Node16.isFalseLiteral(node)) {
+    return { kind: "literal", value: false };
+  }
+  if (Node16.isNullLiteral(node)) {
+    return { kind: "literal", value: null };
+  }
+  if (Node16.isIdentifier(node)) {
+    return node.getText() === "undefined" ? { kind: "literal", value: void 0 } : { kind: "name", text: node.getText() };
+  }
+  if (Node16.isTemplateExpression(node)) {
+    return {
+      kind: "template",
+      parts: [
+        { text: node.getHead().getLiteralText() },
+        ...node.getTemplateSpans().flatMap((span) => [
+          { expression: span.getExpression() },
+          { text: span.getLiteral().getLiteralText() }
+        ])
+      ]
+    };
+  }
+  if (Node16.isPropertyAccessExpression(node)) {
+    return {
+      kind: "member",
+      object: node.getExpression(),
+      name: node.getName()
+    };
+  }
+  if (Node16.isElementAccessExpression(node)) {
+    const index = node.getArgumentExpression();
+    return index === void 0 ? { kind: "opaque" } : { kind: "element", object: node.getExpression(), index };
+  }
+  if (Node16.isArrayLiteralExpression(node)) {
+    return { kind: "array", items: node.getElements().map(elementOf) };
+  }
+  if (Node16.isObjectLiteralExpression(node)) {
+    return { kind: "record", fields: node.getProperties().flatMap(fieldOf) };
+  }
+  if (Node16.isCallExpression(node) || Node16.isNewExpression(node)) {
+    return {
+      kind: "call",
+      callee: calleeOf(node.getExpression(), originOf),
+      args: node.getArguments().map(elementOf),
+      constructs: Node16.isNewExpression(node)
+    };
+  }
+  if (Node16.isBinaryExpression(node)) {
+    const operator = node.getOperatorToken().getText();
+    return ASSIGNMENT_OPERATORS.has(operator) ? { kind: "opaque" } : {
+      kind: "operator",
+      operator,
+      operands: [node.getLeft(), node.getRight()]
+    };
+  }
+  if (Node16.isPrefixUnaryExpression(node)) {
+    const operator = node.getOperatorToken();
+    return operator === SyntaxKind5.ExclamationToken ? { kind: "operator", operator: "!", operands: [node.getOperand()] } : { kind: "opaque" };
+  }
+  if (Node16.isConditionalExpression(node)) {
+    return {
+      kind: "conditional",
+      condition: node.getCondition(),
+      whenTrue: node.getWhenTrue(),
+      whenFalse: node.getWhenFalse()
+    };
+  }
+  if (Node16.isArrowFunction(node) || Node16.isFunctionExpression(node)) {
+    return { kind: "function", node };
+  }
+  return { kind: "opaque" };
+}
+function elementOf(node) {
+  return Node16.isSpreadElement(node) ? { kind: "spread", node: node.getExpression() } : { kind: "value", node };
+}
+function fieldOf(property) {
+  if (Node16.isSpreadAssignment(property)) {
+    return [{ kind: "spread", node: property.getExpression() }];
+  }
+  if (Node16.isShorthandPropertyAssignment(property)) {
+    const nameNode2 = property.getNameNode();
+    return [{ kind: "field", name: nameNode2.getText(), value: nameNode2 }];
+  }
+  if (!Node16.isPropertyAssignment(property)) {
+    return [];
+  }
+  const value = property.getInitializer();
+  if (value === void 0) {
+    return [];
+  }
+  const nameNode = property.getNameNode();
+  if (Node16.isComputedPropertyName(nameNode)) {
+    return [{ kind: "computed", name: nameNode.getExpression(), value }];
+  }
+  const name = Node16.isStringLiteral(nameNode) || Node16.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
+  return [{ kind: "field", name, value }];
+}
+function calleeOf(expression, originOf) {
+  const callee = peelValue(expression);
+  if (Node16.isPropertyAccessExpression(callee)) {
+    return {
+      receiver: callee.getExpression(),
+      name: callee.getName(),
+      origin: () => originOf(callee)
+    };
+  }
+  if (Node16.isIdentifier(callee)) {
+    return {
+      receiver: null,
+      name: callee.getText(),
+      origin: () => originOf(callee)
+    };
+  }
+  return { receiver: null, name: null, origin: () => null };
+}
+function memberChainOf(node) {
+  const names = [];
+  let current2 = peelValue(node);
+  while (Node16.isPropertyAccessExpression(current2)) {
+    names.unshift(current2.getName());
+    current2 = peelValue(current2.getExpression());
+  }
+  if (!Node16.isIdentifier(current2)) {
+    return null;
+  }
+  return { root: current2, names: [current2.getText(), ...names] };
+}
+function statementOf2(node) {
+  if (Node16.isVariableStatement(node)) {
+    return {
+      kind: "declare",
+      bindings: node.getDeclarationList().getDeclarations().flatMap(
+        (declaration) => declarationsOf2(
+          declaration.getNameNode(),
+          declaration.getInitializer() ?? null
+        )
+      )
+    };
+  }
+  if (Node16.isExpressionStatement(node)) {
+    const expression = peelValue(node.getExpression());
+    if (Node16.isBinaryExpression(expression)) {
+      const operator = expression.getOperatorToken().getText();
+      if (ASSIGNMENT_OPERATORS.has(operator)) {
+        return {
+          kind: "assign",
+          target: expression.getLeft(),
+          operator: operator === "=" ? null : operator.slice(0, -1),
+          value: expression.getRight()
+        };
+      }
+    }
+    return { kind: "expression", value: node.getExpression() };
+  }
+  if (Node16.isIfStatement(node)) {
+    const otherwise = node.getElseStatement();
+    return {
+      kind: "branch",
+      condition: node.getExpression(),
+      arms: [
+        armOf(node.getThenStatement()),
+        otherwise === void 0 ? [] : armOf(otherwise)
+      ]
+    };
+  }
+  if (Node16.isSwitchStatement(node)) {
+    return {
+      kind: "branch",
+      condition: null,
+      arms: node.getClauses().map((clause) => clause.getStatements())
+    };
+  }
+  if (Node16.isIterationStatement(node)) {
+    return { kind: "loop", body: armOf(node.getStatement()) };
+  }
+  if (Node16.isReturnStatement(node)) {
+    return { kind: "return", value: node.getExpression() ?? null };
+  }
+  if (Node16.isBlock(node)) {
+    return { kind: "block", body: node.getStatements() };
+  }
+  if (Node16.isTryStatement(node)) {
+    return {
+      kind: "block",
+      body: [
+        ...node.getTryBlock().getStatements(),
+        ...node.getFinallyBlock()?.getStatements() ?? []
+      ]
+    };
+  }
+  return { kind: "opaque" };
+}
+function armOf(statement) {
+  return Node16.isBlock(statement) ? statement.getStatements() : [statement];
+}
+function declarationsOf2(nameNode, value) {
+  if (Node16.isIdentifier(nameNode)) {
+    return [{ name: nameNode.getText(), value }];
+  }
+  if (Node16.isObjectBindingPattern(nameNode) || Node16.isArrayBindingPattern(nameNode)) {
+    return nameNode.getElements().flatMap(
+      (element) => Node16.isBindingElement(element) ? declarationsOf2(element.getNameNode(), null) : []
+    );
+  }
+  return [];
+}
+function isRoot(node) {
+  return Node16.isSourceFile(node) || Node16.isFunctionLikeDeclaration(node);
+}
+function isStandaloneBlock(node) {
+  const parent = node.getParent();
+  return parent !== void 0 && (Node16.isBlock(parent) || Node16.isSourceFile(parent) || Node16.isModuleBlock(parent) || Node16.isCaseClause(parent) || Node16.isDefaultClause(parent));
+}
+function isPathStatement(node) {
+  if (Node16.isBlock(node)) {
+    return isStandaloneBlock(node);
+  }
+  return Node16.isStatement(node) && !Node16.isFunctionDeclaration(node);
+}
+function siteOf(node) {
+  const path14 = [];
+  let current2 = node;
+  for (; ; ) {
+    const parent = current2.getParent();
+    if (parent === void 0) {
+      return null;
+    }
+    if (isPathStatement(current2)) {
+      path14.unshift(current2);
+    }
+    if (isRoot(parent)) {
+      return { root: parent, path: path14 };
+    }
+    current2 = parent;
+  }
+}
+function functionOf(node) {
+  if (Node16.isSourceFile(node)) {
+    return { parameters: [], body: node.getStatements() };
+  }
+  if (!Node16.isFunctionLikeDeclaration(node)) {
+    return null;
+  }
+  const parameters = node.getParameters().flatMap((parameter) => {
+    const nameNode = parameter.getNameNode();
+    return Node16.isIdentifier(nameNode) ? [
+      {
+        name: nameNode.getText(),
+        default: parameter.getInitializer() ?? null
+      }
+    ] : [];
+  });
+  const body = Node16.isBodied(node) ? node.getBody() : Node16.isBodyable(node) ? node.getBody() : void 0;
+  if (body === void 0) {
+    return { parameters, body: [] };
+  }
+  return Node16.isBlock(body) ? { parameters, body: body.getStatements() } : { parameters, body: { expression: body } };
+}
+function namesMutatedInNestedFunctions(root) {
+  const mutated = /* @__PURE__ */ new Set();
+  root.forEachDescendant((descendant) => {
+    const written = writtenNameOf(descendant);
+    if (written !== null && enclosingRootOf(descendant) !== root) {
+      mutated.add(written);
+    }
+  });
+  return mutated;
+}
+function writtenNameOf(node) {
+  if (Node16.isBinaryExpression(node)) {
+    const target = peelValue(node.getLeft());
+    return ASSIGNMENT_OPERATORS.has(node.getOperatorToken().getText()) && Node16.isIdentifier(target) ? target.getText() : null;
+  }
+  if (Node16.isPostfixUnaryExpression(node) || Node16.isPrefixUnaryExpression(node)) {
+    const operand2 = peelValue(node.getOperand());
+    return Node16.isIdentifier(operand2) ? operand2.getText() : null;
+  }
+  if (Node16.isCallExpression(node)) {
+    const callee = peelValue(node.getExpression());
+    if (!Node16.isPropertyAccessExpression(callee)) {
+      return null;
+    }
+    const receiver = peelValue(callee.getExpression());
+    return MUTATING_METHODS.has(callee.getName()) && Node16.isIdentifier(receiver) ? receiver.getText() : null;
+  }
+  return null;
+}
+function enclosingRootOf(node) {
+  let current2 = node.getParent();
+  while (current2 !== void 0 && !isRoot(current2)) {
+    current2 = current2.getParent();
+  }
+  return current2;
+}
+function freeNamesOf(fn) {
+  const declared = /* @__PURE__ */ new Set();
+  const read2 = /* @__PURE__ */ new Set();
+  fn.forEachDescendant((descendant) => {
+    if (!Node16.isIdentifier(descendant)) {
+      return;
+    }
+    const parent = descendant.getParent();
+    if (Node16.isPropertyAccessExpression(parent) && parent.getNameNode() === descendant) {
+      return;
+    }
+    if (Node16.isVariableDeclaration(parent) || Node16.isParameterDeclaration(parent) || Node16.isBindingElement(parent) || Node16.isFunctionDeclaration(parent)) {
+      declared.add(descendant.getText());
+      return;
+    }
+    if (Node16.isPropertyAssignment(parent) && parent.getNameNode() === descendant) {
+      return;
+    }
+    read2.add(descendant.getText());
+  });
+  return [...read2].filter((name) => !declared.has(name));
+}
+
+// src/values/rows.ts
+import {
+  appended,
+  concat,
+  constant,
+  equals,
+  extended,
+  fallback,
+  isPresent,
+  joined,
+  joinedPath,
+  negated,
+  operand,
+  plus,
+  readableFallback,
+  truthOf
+} from "@suss/values";
+var PATH_MODULES = ["path", "node:path", "path/posix", "node:path/posix"];
+var operatorRows = [
+  {
+    kind: "operator",
+    operator: "+",
+    arity: 2,
+    apply: ([a, b]) => plus(operand(a), operand(b))
+  },
+  {
+    kind: "operator",
+    operator: "===",
+    arity: 2,
+    apply: ([a, b]) => equals(operand(a), operand(b))
+  },
+  {
+    kind: "operator",
+    operator: "==",
+    arity: 2,
+    apply: ([a, b]) => equals(operand(a), operand(b))
+  },
+  {
+    kind: "operator",
+    operator: "!==",
+    arity: 2,
+    apply: ([a, b]) => negated(equals(operand(a), operand(b)))
+  },
+  {
+    kind: "operator",
+    operator: "!=",
+    arity: 2,
+    apply: ([a, b]) => negated(equals(operand(a), operand(b)))
+  },
+  {
+    kind: "operator",
+    operator: "!",
+    arity: 1,
+    apply: ([a]) => negated(operand(a))
+  },
+  {
+    kind: "operator",
+    operator: "??",
+    arity: 2,
+    apply: ([a, b]) => readableFallback(operand(a), operand(b), isPresent)
+  },
+  {
+    kind: "operator",
+    operator: "||",
+    arity: 2,
+    apply: ([a, b]) => readableFallback(operand(a), operand(b), truthOf)
+  },
+  {
+    kind: "operator",
+    operator: "&&",
+    arity: 2,
+    apply: ([a, b]) => fallback(operand(a), operand(b), (left) => {
+      const truth = truthOf(left);
+      return truth === null ? null : !truth;
+    })
+  }
+];
+var stringRows = [
+  {
+    kind: "method",
+    method: "toString",
+    on: "string",
+    apply: () => ({ result: "receiver" })
+  },
+  {
+    kind: "method",
+    method: "toString",
+    on: "constant",
+    apply: ({ receiver }) => ({ result: concat([operand(receiver)]) })
+  },
+  {
+    kind: "method",
+    method: "concat",
+    on: "string",
+    apply: ({ receiver, args }) => ({
+      result: concat([operand(receiver), ...args])
+    })
+  }
+];
+var sequenceRows = ["sequence", "unbounded"].flatMap((on) => [
+  {
+    kind: "method",
+    method: "push",
+    on,
+    apply: ({ receiver, args }) => ({
+      result: constant(0),
+      receiver: appended(operand(receiver), args)
+    })
+  },
+  {
+    kind: "method",
+    method: "concat",
+    on,
+    apply: ({ receiver, args, contentOf }) => ({
+      result: args.reduce(
+        (sequence, other) => extended(sequence, contentOf(other)),
+        operand(receiver)
+      )
+    })
+  },
+  {
+    kind: "method",
+    method: "join",
+    on,
+    apply: ({ receiver, args }) => ({
+      result: joined(operand(receiver), args[0])
+    })
+  }
+]);
+var calleeRows = [
+  {
+    kind: "callee",
+    origin: { module: "global", name: "String" },
+    apply: ({ args }) => ({ result: concat([operand(args[0])]) })
+  },
+  ...PATH_MODULES.map(
+    (module) => ({
+      kind: "callee",
+      origin: { module, name: "join" },
+      apply: ({ args }) => ({ result: joinedPath(args) })
+    })
+  )
+];
+var typescriptRows = [
+  ...operatorRows,
+  ...stringRows,
+  ...sequenceRows,
+  ...calleeRows
+];
+
+// src/values/evaluator.ts
+var evaluators = /* @__PURE__ */ new WeakMap();
+function evaluatorFor(node, resolution) {
+  const key = resolution ?? node.getProject();
+  let evaluator = evaluators.get(key);
+  if (evaluator === void 0) {
+    evaluator = new Evaluator(
+      typescriptLowering(
+        resolution === void 0 ? { rows: typescriptRows } : { resolution, rows: typescriptRows }
+      )
+    );
+    evaluators.set(key, evaluator);
+  }
+  return evaluator;
+}
+function evaluatedValue(node, resolution) {
+  return force(evaluatorFor(node, resolution).evaluate(node));
+}
+
+// src/discovery/resolveValue.ts
 function couldNameAValue(value) {
-  return Node16.isIdentifier(value) || Node16.isPropertyAccessExpression(value) || Node16.isElementAccessExpression(value) || Node16.isCallExpression(value);
+  return Node17.isIdentifier(value) || Node17.isPropertyAccessExpression(value) || Node17.isElementAccessExpression(value) || Node17.isCallExpression(value);
 }
 function propertyValueOf(property) {
-  if (Node16.isPropertyAssignment(property)) {
+  if (Node17.isPropertyAssignment(property)) {
     return property.getInitializer() ?? null;
   }
-  if (Node16.isShorthandPropertyAssignment(property)) {
+  if (Node17.isShorthandPropertyAssignment(property)) {
     return property.getNameNode();
   }
   return null;
@@ -4678,7 +5272,7 @@ function objectLiteralOf(value, resolution) {
   return literalValueOf(
     value,
     resolution,
-    (node) => Node16.isObjectLiteralExpression(node)
+    (node) => Node17.isObjectLiteralExpression(node)
   );
 }
 function propertiesOf(object, resolution) {
@@ -4690,7 +5284,7 @@ function propertiesReached(object, resolution, seen) {
   }
   seen.add(object);
   return object.getProperties().flatMap((property) => {
-    if (!Node16.isSpreadAssignment(property)) {
+    if (!Node17.isSpreadAssignment(property)) {
       return [property];
     }
     const spread = objectLiteralOf(property.getExpression(), resolution);
@@ -4699,17 +5293,17 @@ function propertiesReached(object, resolution, seen) {
 }
 function writtenNodeOf(value, resolution) {
   const written = factKeyOf(value);
-  if (Node16.isNewExpression(written)) {
+  if (Node17.isNewExpression(written)) {
     return written;
   }
-  if (Node16.isCallExpression(written)) {
+  if (Node17.isCallExpression(written)) {
     return writtenThroughCall(written, resolution);
   }
   if (resolution === void 0 || !couldNameAValue(written)) {
     return null;
   }
   const resolved = resolution.resolveWrittenValue(written);
-  return resolved !== null && Node16.isCallExpression(resolved) ? writtenThroughCall(resolved, resolution) : resolved;
+  return resolved !== null && Node17.isCallExpression(resolved) ? writtenThroughCall(resolved, resolution) : resolved;
 }
 function writtenThroughCall(call, resolution) {
   if (resolution !== void 0 && resolution.resolveCallable(call.getExpression()) !== null) {
@@ -4721,24 +5315,21 @@ function writtenThroughCall(call, resolution) {
   return call;
 }
 function stringValueOf(value, resolution) {
-  const written = factKeyOf(value);
-  if (isStringNode(written)) {
-    return written.getLiteralValue();
-  }
-  if (resolution === void 0 || !couldNameAValue(written)) {
+  return literalOf(evaluatedValue(value, resolution));
+}
+function stringPropertyOf(object, name, resolution) {
+  const record2 = evaluatedValue(object, resolution);
+  if (record2.kind !== "record") {
     return null;
   }
-  const resolved = resolution.resolveWrittenValue(written);
-  return resolved !== null && isStringNode(resolved) ? resolved.getLiteralValue() : null;
-}
-function isStringNode(node) {
-  return Node16.isStringLiteral(node) || Node16.isNoSubstitutionTemplateLiteral(node);
+  const field = record2.fields.get(name);
+  return field === void 0 ? null : literalOf(force2(field.value));
 }
 function arrayLiteralOf(value, resolution) {
   return literalValueOf(
     value,
     resolution,
-    (node) => Node16.isArrayLiteralExpression(node)
+    (node) => Node17.isArrayLiteralExpression(node)
   );
 }
 function literalValueOf(value, resolution, isWanted) {
@@ -4761,26 +5352,26 @@ function discoverClientCalls(sourceFile, match, kind, resolution) {
   if (!isGlobal) {
     for (const varDecl of sourceFile.getVariableDeclarations()) {
       const init = varDecl.getInitializer();
-      if (init !== void 0 && (Node17.isCallExpression(init) || Node17.isNewExpression(init)) && isCreationCall(init, match, resolution)) {
+      if (init !== void 0 && (Node18.isCallExpression(init) || Node18.isNewExpression(init)) && isCreationCall(init, match, resolution)) {
         clientVarNames.add(varDecl.getName());
       }
     }
   }
   const methodFilter = match.methodFilter !== void 0 ? new Set(match.methodFilter) : null;
   sourceFile.forEachDescendant((node) => {
-    if (!Node17.isCallExpression(node)) {
+    if (!Node18.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
     let methodName = null;
     let matched = false;
-    if (isGlobal && Node17.isIdentifier(callee)) {
+    if (isGlobal && Node18.isIdentifier(callee)) {
       if (callee.getText() === match.importName) {
         matched = true;
       }
-    } else if (Node17.isPropertyAccessExpression(callee)) {
+    } else if (Node18.isPropertyAccessExpression(callee)) {
       const subject = callee.getExpression();
-      if (Node17.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution)) {
+      if (Node18.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution)) {
         methodName = callee.getName();
         if (methodFilter === null || methodFilter.has(methodName)) {
           matched = true;
@@ -4814,16 +5405,16 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
   );
   const constructedHere = /* @__PURE__ */ new Set();
   sourceFile.forEachDescendant((node) => {
-    if (Node17.isVariableDeclaration(node)) {
+    if (Node18.isVariableDeclaration(node)) {
       const init = node.getInitializer();
-      if (init !== void 0 && (Node17.isCallExpression(init) || Node17.isNewExpression(init)) && isCreationCall(init, match, resolution) || localName !== null && typedAsClient(node.getTypeNode(), localName)) {
+      if (init !== void 0 && (Node18.isCallExpression(init) || Node18.isNewExpression(init)) && isCreationCall(init, match, resolution) || localName !== null && typedAsClient(node.getTypeNode(), localName)) {
         constructedHere.add(node.getName());
       }
       return;
     }
-    if (Node17.isParameterDeclaration(node) && localName !== null && typedAsClient(node.getTypeNode(), localName)) {
+    if (Node18.isParameterDeclaration(node) && localName !== null && typedAsClient(node.getTypeNode(), localName)) {
       const written = node.getNameNode();
-      if (Node17.isIdentifier(written)) {
+      if (Node18.isIdentifier(written)) {
         constructedHere.add(written.getText());
       }
     }
@@ -4834,10 +5425,10 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
     importName: match.importName,
     ...match.factoryMethods === void 0 ? {} : { factoryMethods: match.factoryMethods }
   };
-  return (subject) => isClientImport(subject, match, resolution, true) || Node17.isIdentifier(subject) && constructedHere.has(subject.getText()) || resolvesToKnownInstance(subject, full, resolution);
+  return (subject) => isClientImport(subject, match, resolution, true) || Node18.isIdentifier(subject) && constructedHere.has(subject.getText()) || resolvesToKnownInstance(subject, full, resolution);
 }
 function typedAsClient(typeNode, localName) {
-  if (typeNode === void 0 || !Node17.isTypeReference(typeNode)) {
+  if (typeNode === void 0 || !Node18.isTypeReference(typeNode)) {
     return false;
   }
   return typeNode.getTypeName().getText() === localName;
@@ -4847,27 +5438,27 @@ function resolvesToKnownInstance(subject, match, resolution) {
     return false;
   }
   const written = writtenNodeOf(subject, resolution);
-  if (written === null || !Node17.isCallExpression(written) && !Node17.isNewExpression(written)) {
+  if (written === null || !Node18.isCallExpression(written) && !Node18.isNewExpression(written)) {
     return false;
   }
   return isCreationCall(written, match, resolution);
 }
 function isCreationCall(call, match, resolution) {
   const callee = call.getExpression();
-  if (Node17.isIdentifier(callee)) {
+  if (Node18.isIdentifier(callee)) {
     return isClientImport(callee, match, resolution, false);
   }
-  if (!Node17.isPropertyAccessExpression(callee)) {
+  if (!Node18.isPropertyAccessExpression(callee)) {
     return false;
   }
   const base = callee.getExpression();
-  return Node17.isIdentifier(base) && (match.factoryMethods?.includes(callee.getName()) ?? false) && isClientImport(base, match, resolution, false);
+  return Node18.isIdentifier(base) && (match.factoryMethods?.includes(callee.getName()) ?? false) && isClientImport(base, match, resolution, false);
 }
 function isPathShaped(specifier) {
   return specifier.startsWith(".") || specifier.startsWith("/");
 }
 function isClientImport(subject, match, resolution, strictDefaultName) {
-  if (!Node17.isIdentifier(subject)) {
+  if (!Node18.isIdentifier(subject)) {
     return false;
   }
   if (resolution === void 0) {
@@ -4915,27 +5506,27 @@ function resolvedImportLocalName(sourceFile, importModule, importName, strictDef
   return null;
 }
 function clientUnitName(enclosingFunc, methodName) {
-  if (Node17.isFunctionDeclaration(enclosingFunc)) {
+  if (Node18.isFunctionDeclaration(enclosingFunc)) {
     return enclosingFunc.getName() ?? methodName ?? "anonymous";
   }
-  if (Node17.isMethodDeclaration(enclosingFunc)) {
+  if (Node18.isMethodDeclaration(enclosingFunc)) {
     return enclosingFunc.getName();
   }
   const parent = enclosingFunc.getParent();
-  if (parent !== void 0 && Node17.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && Node18.isVariableDeclaration(parent)) {
     return parent.getName();
   }
-  if (parent !== void 0 && Node17.isPropertyAssignment(parent)) {
+  if (parent !== void 0 && Node18.isPropertyAssignment(parent)) {
     return parent.getName();
   }
   return methodName ?? "anonymous";
 }
 
 // src/discovery/decoratedMethod.ts
-import { Node as Node20 } from "ts-morph";
+import { Node as Node21 } from "ts-morph";
 
 // src/discovery/decoratedMembers.ts
-import { Node as Node18 } from "ts-morph";
+import { Node as Node19 } from "ts-morph";
 function importedDecoratorLocals(sourceFile, acceptedModules, canonicalNames) {
   const localToCanonical = /* @__PURE__ */ new Map();
   for (const importDecl of sourceFile.getImportDeclarations()) {
@@ -4955,7 +5546,7 @@ function importedDecoratorLocals(sourceFile, acceptedModules, canonicalNames) {
 function decoratedCallablesOf(cls, decoratorNames) {
   const callables = [];
   for (const member of cls.getMembers()) {
-    if (!Node18.isMethodDeclaration(member) && !Node18.isPropertyDeclaration(member)) {
+    if (!Node19.isMethodDeclaration(member) && !Node19.isPropertyDeclaration(member)) {
       continue;
     }
     const func = callableOf(member);
@@ -4979,7 +5570,7 @@ function decoratedCallablesOf(cls, decoratorNames) {
   return callables;
 }
 function callableOf(member) {
-  if (Node18.isMethodDeclaration(member)) {
+  if (Node19.isMethodDeclaration(member)) {
     return toFunctionRoot(member);
   }
   const held = member.getInitializer();
@@ -4987,7 +5578,7 @@ function callableOf(member) {
 }
 
 // src/discovery/decoratorComposition.ts
-import { Node as Node19, SyntaxKind as SyntaxKind5 } from "ts-morph";
+import { Node as Node20, SyntaxKind as SyntaxKind6 } from "ts-morph";
 function classDecoratorStandingFor(cls, names, modules, resolution) {
   for (const candidate of names) {
     const decorator = cls.getDecorator(candidate);
@@ -5003,7 +5594,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;
@@ -5021,11 +5612,11 @@ 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;
   }
-  for (const call of wrapper.getDescendantsOfKind(SyntaxKind5.CallExpression)) {
+  for (const call of wrapper.getDescendantsOfKind(SyntaxKind6.CallExpression)) {
     const names = resolution.importedNamesOf(call.getExpression(), modules);
     if (!names.includes(standsFor)) {
       continue;
@@ -5036,17 +5627,17 @@ function frameworkArgs(decorator, standsFor, modules, resolution) {
   return atClass;
 }
 function statesAValue(arg, wrapper) {
-  const identifiers = Node19.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(SyntaxKind5.Identifier);
+  const identifiers = Node20.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(SyntaxKind6.Identifier);
   return !identifiers.some(
     (identifier) => identifier.getSymbol()?.getDeclarations().some(
-      (declaration) => Node19.isParameterDeclaration(declaration) && isWithin(declaration, wrapper)
+      (declaration) => Node20.isParameterDeclaration(declaration) && isWithin(declaration, 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();
@@ -5059,39 +5650,39 @@ function resolverTypeName(args) {
   return args.typeMap[args.decoratorName] ?? args.classTypeName ?? null;
 }
 function resolveResolverClassTypeName(decoratorArg) {
-  if (Node20.isArrowFunction(decoratorArg)) {
+  if (Node21.isArrowFunction(decoratorArg)) {
     const body = decoratorArg.getBody();
-    if (Node20.isIdentifier(body)) {
+    if (Node21.isIdentifier(body)) {
       return body.getText();
     }
     return null;
   }
-  if (Node20.isStringLiteral(decoratorArg)) {
+  if (Node21.isStringLiteral(decoratorArg)) {
     return decoratorArg.getLiteralValue();
   }
-  if (Node20.isIdentifier(decoratorArg)) {
+  if (Node21.isIdentifier(decoratorArg)) {
     return decoratorArg.getText();
   }
   return null;
 }
 function resolveOperationNameOverride(decorator) {
-  if (!Node20.isDecorator(decorator)) {
+  if (!Node21.isDecorator(decorator)) {
     return null;
   }
   const args = decorator.getArguments();
   for (const arg of args) {
-    if (!Node20.isObjectLiteralExpression(arg)) {
+    if (!Node21.isObjectLiteralExpression(arg)) {
       continue;
     }
     const prop = arg.getProperty("name");
-    if (prop === void 0 || !Node20.isPropertyAssignment(prop)) {
+    if (prop === void 0 || !Node21.isPropertyAssignment(prop)) {
       continue;
     }
     const init = prop.getInitializer();
     if (init === void 0) {
       continue;
     }
-    if (Node20.isStringLiteral(init) || Node20.isNoSubstitutionTemplateLiteral(init)) {
+    if (Node21.isStringLiteral(init) || Node21.isNoSubstitutionTemplateLiteral(init)) {
       return init.getLiteralValue();
     }
   }
@@ -5144,9 +5735,9 @@ function discoverDecoratedMethods(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/decoratedRoute.ts
-import { Node as Node21 } from "ts-morph";
+import { Node as Node22 } from "ts-morph";
 function resolveRoutePathArg(decorator, resolution) {
-  if (!Node21.isDecorator(decorator)) {
+  if (!Node22.isDecorator(decorator)) {
     return "";
   }
   return routePathOf(decorator.getArguments(), resolution);
@@ -5174,7 +5765,7 @@ function declaredChannelOf(source, decorator, resolution) {
   if (source.from === "unstated") {
     return null;
   }
-  if (!Node21.isDecorator(decorator)) {
+  if (!Node22.isDecorator(decorator)) {
     return null;
   }
   const arg = decorator.getArguments()[source.position];
@@ -5185,7 +5776,7 @@ function declaredChannelOf(source, decorator, resolution) {
   return text === null || text === "" ? null : text;
 }
 function literalStringOf(node, resolution) {
-  if (Node21.isStringLiteral(node) || Node21.isNoSubstitutionTemplateLiteral(node)) {
+  if (Node22.isStringLiteral(node) || Node22.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   const written = resolution?.resolveWrittenValue(node) ?? null;
@@ -5256,32 +5847,32 @@ import picomatch from "picomatch";
 
 // src/discovery/namedExport.ts
 import {
-  Node as Node22
+  Node as Node23
 } from "ts-morph";
 function nameWrittenAt(expression) {
-  if (Node22.isIdentifier(expression)) {
+  if (Node23.isIdentifier(expression)) {
     return expression.getText();
   }
-  if (Node22.isPropertyAccessExpression(expression)) {
+  if (Node23.isPropertyAccessExpression(expression)) {
     return expression.getName();
   }
   return null;
 }
 function resolveDefaultExportName(decl, fn) {
-  if (Node22.isFunctionDeclaration(fn) || Node22.isFunctionExpression(fn)) {
+  if (Node23.isFunctionDeclaration(fn) || Node23.isFunctionExpression(fn)) {
     const n = fn.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (Node22.isVariableDeclaration(decl)) {
+  if (Node23.isVariableDeclaration(decl)) {
     const name = decl.getName();
     if (name.length > 0) {
       return name;
     }
   }
   const binding = fn.getParent();
-  if (binding !== void 0 && Node22.isVariableDeclaration(binding)) {
+  if (binding !== void 0 && Node23.isVariableDeclaration(binding)) {
     const name = binding.getName();
     if (name.length > 0) {
       return name;
@@ -5336,7 +5927,7 @@ function discoverNamedExports(sourceFile, match, kind, resolution) {
       }
       continue;
     }
-    if (Node22.isArrowFunction(init) || Node22.isFunctionExpression(init)) {
+    if (Node23.isArrowFunction(init) || Node23.isFunctionExpression(init)) {
       results.push({
         func: init,
         kind,
@@ -5445,7 +6036,7 @@ function discoverFileConventions(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/graphqlHookCall.ts
-import { Node as Node25 } from "ts-morph";
+import { Node as Node26 } from "ts-morph";
 
 // src/discovery/graphqlShared.ts
 import fs2 from "fs";
@@ -5455,7 +6046,7 @@ import {
   parse as graphqlParse,
   print as graphqlPrint
 } from "graphql";
-import { Node as Node23 } from "ts-morph";
+import { Node as Node24 } from "ts-morph";
 var DOCUMENT_TAGS = /* @__PURE__ */ new Set(["gql", "graphql"]);
 var UNQUALIFIED_DOCUMENT_TAG = "gql";
 function parseGraphqlOperation(source) {
@@ -5521,10 +6112,10 @@ function startAssembly(resolution) {
   };
 }
 function assembledTemplateText(template, assembly) {
-  if (Node23.isNoSubstitutionTemplateLiteral(template)) {
+  if (Node24.isNoSubstitutionTemplateLiteral(template)) {
     return innerTemplateText(template);
   }
-  if (!Node23.isTemplateExpression(template)) {
+  if (!Node24.isTemplateExpression(template)) {
     return null;
   }
   let text = template.getHead().getLiteralText();
@@ -5660,7 +6251,7 @@ function collectDanglingSpreads(selectionSet, defined, dangling) {
   }
 }
 function documentTextFromExpression(node, assembly) {
-  if (Node23.isTaggedTemplateExpression(node)) {
+  if (Node24.isTaggedTemplateExpression(node)) {
     if (!isDocumentTag(node.getTag())) {
       return null;
     }
@@ -5670,7 +6261,7 @@ function documentTextFromExpression(node, assembly) {
     assembly.seen.add(node);
     return assembledTemplateText(node.getTemplate(), assembly);
   }
-  if (!Node23.isCallExpression(node)) {
+  if (!Node24.isCallExpression(node)) {
     return null;
   }
   if (!isDocumentTag(node.getExpression())) {
@@ -5681,7 +6272,7 @@ function documentTextFromExpression(node, assembly) {
     return null;
   }
   const template = stripDocumentNodeCasts(first);
-  if (!Node23.isNoSubstitutionTemplateLiteral(template) && !Node23.isTemplateExpression(template)) {
+  if (!Node24.isNoSubstitutionTemplateLiteral(template) && !Node24.isTemplateExpression(template)) {
     return null;
   }
   if (assembly.seen.has(node)) {
@@ -5691,7 +6282,7 @@ function documentTextFromExpression(node, assembly) {
   return assembledTemplateText(template, assembly);
 }
 function isDocumentTag(tag) {
-  if (!Node23.isIdentifier(tag)) {
+  if (!Node24.isIdentifier(tag)) {
     return false;
   }
   if (tag.getText() === UNQUALIFIED_DOCUMENT_TAG) {
@@ -5702,14 +6293,14 @@ function isDocumentTag(tag) {
     return false;
   }
   for (const declaration of symbol.getDeclarations()) {
-    if (Node23.isImportSpecifier(declaration) && DOCUMENT_TAGS.has(declaration.getName())) {
+    if (Node24.isImportSpecifier(declaration) && DOCUMENT_TAGS.has(declaration.getName())) {
       return true;
     }
   }
   return false;
 }
 function resolveThroughFacts(arg, assembly) {
-  if (assembly.resolution === void 0 || !Node23.isIdentifier(arg)) {
+  if (assembly.resolution === void 0 || !Node24.isIdentifier(arg)) {
     return null;
   }
   const written = assembly.resolution.resolveWrittenValue(arg);
@@ -5758,7 +6349,7 @@ function singleLine(text) {
   return collapsed.length > 80 ? `${collapsed.slice(0, 79)}\u2026` : collapsed;
 }
 function importedVariableInitializers(identifier) {
-  if (!Node23.isIdentifier(identifier)) {
+  if (!Node24.isIdentifier(identifier)) {
     return [];
   }
   const symbol = identifier.getSymbol();
@@ -5768,7 +6359,7 @@ function importedVariableInitializers(identifier) {
   const resolved = resolveAliasedSymbol(symbol) ?? symbol;
   const inits = [];
   for (const decl of resolved.getDeclarations()) {
-    if (Node23.isVariableDeclaration(decl)) {
+    if (Node24.isVariableDeclaration(decl)) {
       const init = decl.getInitializer();
       if (init !== void 0) {
         inits.push(init);
@@ -5782,7 +6373,7 @@ function resolveGqlTemplateText(arg, assembly) {
   if (direct !== null) {
     return direct;
   }
-  if (!Node23.isIdentifier(arg)) {
+  if (!Node24.isIdentifier(arg)) {
     return null;
   }
   const symbol = arg.getSymbol();
@@ -5790,7 +6381,7 @@ function resolveGqlTemplateText(arg, assembly) {
     return null;
   }
   for (const decl of symbol.getDeclarations()) {
-    if (Node23.isImportClause(decl) || Node23.isImportSpecifier(decl)) {
+    if (Node24.isImportClause(decl) || Node24.isImportSpecifier(decl)) {
       const fromGraphqlFile = resolveGraphqlFileImport(decl);
       if (fromGraphqlFile !== null) {
         return fromGraphqlFile;
@@ -5809,7 +6400,7 @@ function resolveGqlTemplateText(arg, assembly) {
   return null;
 }
 function resolveTypedDocumentSource(arg) {
-  if (!Node23.isIdentifier(arg)) {
+  if (!Node24.isIdentifier(arg)) {
     return null;
   }
   for (const init of importedVariableInitializers(arg)) {
@@ -5822,7 +6413,7 @@ function resolveTypedDocumentSource(arg) {
 }
 function typedDocumentSourceOf(node) {
   const inner = stripDocumentNodeCasts(node);
-  if (!Node23.isObjectLiteralExpression(inner)) {
+  if (!Node24.isObjectLiteralExpression(inner)) {
     return null;
   }
   const evaluated = evaluateObjectLiteralAsJson(inner);
@@ -5840,7 +6431,7 @@ function typedDocumentSourceOf(node) {
   }
 }
 function resolveTypedDocumentHeader(arg) {
-  if (!Node23.isIdentifier(arg)) {
+  if (!Node24.isIdentifier(arg)) {
     return null;
   }
   const reference = arg.getText();
@@ -5850,7 +6441,7 @@ function resolveTypedDocumentHeader(arg) {
   }
   const resolved = resolveAliasedSymbol(symbol) ?? symbol;
   for (const decl of resolved.getDeclarations()) {
-    if (!Node23.isVariableDeclaration(decl)) {
+    if (!Node24.isVariableDeclaration(decl)) {
       continue;
     }
     const init = decl.getInitializer();
@@ -5883,10 +6474,10 @@ function resolveTypedDocumentHeader(arg) {
 }
 function documentNodeCastTypeArgs(node) {
   let current2 = node;
-  while (Node23.isAsExpression(current2) || Node23.isParenthesizedExpression(current2)) {
-    if (Node23.isAsExpression(current2)) {
+  while (Node24.isAsExpression(current2) || Node24.isParenthesizedExpression(current2)) {
+    if (Node24.isAsExpression(current2)) {
       const typeNode = current2.getTypeNode();
-      if (typeNode !== void 0 && Node23.isTypeReference(typeNode)) {
+      if (typeNode !== void 0 && Node24.isTypeReference(typeNode)) {
         const name = typeNode.getTypeName().getText();
         const simpleName = name.includes(".") ? name.split(".").pop() ?? name : name;
         if (simpleName === "TypedDocumentNode" || simpleName === "DocumentNode") {
@@ -5899,7 +6490,7 @@ function documentNodeCastTypeArgs(node) {
   return null;
 }
 function operationHeaderFromResultType(typeNode) {
-  if (typeNode === void 0 || !Node23.isTypeReference(typeNode)) {
+  if (typeNode === void 0 || !Node24.isTypeReference(typeNode)) {
     return null;
   }
   const name = typeNode.getTypeName().getText();
@@ -5920,16 +6511,16 @@ function operationHeaderFromResultType(typeNode) {
 }
 function stripDocumentNodeCasts(node) {
   let current2 = node;
-  while (Node23.isAsExpression(current2) || Node23.isParenthesizedExpression(current2)) {
+  while (Node24.isAsExpression(current2) || Node24.isParenthesizedExpression(current2)) {
     current2 = current2.getExpression();
   }
   return current2;
 }
 function evaluateObjectLiteralAsJson(node) {
-  if (Node23.isStringLiteral(node) || Node23.isNoSubstitutionTemplateLiteral(node)) {
+  if (Node24.isStringLiteral(node) || Node24.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
-  if (Node23.isNumericLiteral(node)) {
+  if (Node24.isNumericLiteral(node)) {
     return Number(node.getText());
   }
   const kind = node.getText();
@@ -5942,17 +6533,17 @@ function evaluateObjectLiteralAsJson(node) {
   if (kind === "null") {
     return null;
   }
-  if (Node23.isObjectLiteralExpression(node)) {
+  if (Node24.isObjectLiteralExpression(node)) {
     const out = {};
     for (const prop of node.getProperties()) {
-      if (!Node23.isPropertyAssignment(prop)) {
+      if (!Node24.isPropertyAssignment(prop)) {
         return null;
       }
       const nameNode = prop.getNameNode();
       let name;
-      if (Node23.isIdentifier(nameNode)) {
+      if (Node24.isIdentifier(nameNode)) {
         name = nameNode.getText();
-      } else if (Node23.isStringLiteral(nameNode) || Node23.isNoSubstitutionTemplateLiteral(nameNode)) {
+      } else if (Node24.isStringLiteral(nameNode) || Node24.isNoSubstitutionTemplateLiteral(nameNode)) {
         name = nameNode.getLiteralValue();
       } else {
         return null;
@@ -5969,7 +6560,7 @@ function evaluateObjectLiteralAsJson(node) {
     }
     return out;
   }
-  if (Node23.isArrayLiteralExpression(node)) {
+  if (Node24.isArrayLiteralExpression(node)) {
     const out = [];
     for (const el of node.getElements()) {
       const value = evaluateObjectLiteralAsJson(el);
@@ -5983,8 +6574,8 @@ function evaluateObjectLiteralAsJson(node) {
   return void 0;
 }
 function resolveGraphqlFileImport(decl) {
-  const importDecl = Node23.isImportSpecifier(decl) ? decl.getImportDeclaration() : Node23.isImportClause(decl) ? decl.getParent() : null;
-  if (importDecl === null || importDecl === void 0 || !Node23.isImportDeclaration(importDecl)) {
+  const importDecl = Node24.isImportSpecifier(decl) ? decl.getImportDeclaration() : Node24.isImportClause(decl) ? decl.getParent() : null;
+  if (importDecl === null || importDecl === void 0 || !Node24.isImportDeclaration(importDecl)) {
     return null;
   }
   const specifier = importDecl.getModuleSpecifierValue();
@@ -6003,7 +6594,7 @@ function resolveGraphqlFileImport(decl) {
 function enclosingFunctionRoot(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (Node23.isFunctionDeclaration(current2) || Node23.isFunctionExpression(current2) || Node23.isArrowFunction(current2) || Node23.isMethodDeclaration(current2)) {
+    if (Node24.isFunctionDeclaration(current2) || Node24.isFunctionExpression(current2) || Node24.isArrowFunction(current2) || Node24.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -6011,18 +6602,18 @@ function enclosingFunctionRoot(node) {
   return null;
 }
 function functionNameOrAnon(func) {
-  if (Node23.isFunctionDeclaration(func) || Node23.isMethodDeclaration(func)) {
+  if (Node24.isFunctionDeclaration(func) || Node24.isMethodDeclaration(func)) {
     return func.getName() ?? "<anon>";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && Node23.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && Node24.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return "<anon>";
 }
 
 // src/discovery/importedCalls.ts
-import { Node as Node24 } from "ts-morph";
+import { Node as Node25 } from "ts-morph";
 function callsResolvingTo(sourceFile, resolution, spec) {
   return [
     ...callsByOriginName(
@@ -6036,11 +6627,11 @@ function callsResolvingTo(sourceFile, resolution, spec) {
 function callsByOriginName(sourceFile, resolution, module, names) {
   const candidates = [];
   sourceFile.forEachDescendant((node) => {
-    if (!Node24.isCallExpression(node) && !Node24.isNewExpression(node)) {
+    if (!Node25.isCallExpression(node) && !Node25.isNewExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (Node24.isIdentifier(callee) && !declaredLocally(callee)) {
+    if (Node25.isIdentifier(callee) && !declaredLocally(callee)) {
       candidates.push(node);
     }
   });
@@ -6066,7 +6657,7 @@ function callsByOriginName(sourceFile, resolution, module, names) {
 function declaredLocally(callee) {
   const declarations = callee.getSymbol()?.getDeclarations() ?? [];
   return declarations.length > 0 && declarations.every(
-    (declaration) => (Node24.isFunctionDeclaration(declaration) || Node24.isClassDeclaration(declaration)) && !declaration.getSourceFile().isInNodeModules()
+    (declaration) => (Node25.isFunctionDeclaration(declaration) || Node25.isClassDeclaration(declaration)) && !declaration.getSourceFile().isInNodeModules()
   );
 }
 
@@ -6084,7 +6675,7 @@ function discoverGraphqlHookCalls(sourceFile, match, kind, resolution) {
   );
   const results = [];
   for (const [node, canonical] of hookCalls) {
-    if (!Node25.isCallExpression(node)) {
+    if (!Node26.isCallExpression(node)) {
       continue;
     }
     const operationType = operationTypeByHook.get(canonical);
@@ -6121,7 +6712,7 @@ function discoverGraphqlHookCalls(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/graphqlImperativeCall.ts
-import { Node as Node26 } from "ts-morph";
+import { Node as Node27 } from "ts-morph";
 function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   const isTheClient = clientReceiverCheckFor(sourceFile, match, resolution);
   const methodSpec = /* @__PURE__ */ new Map();
@@ -6133,11 +6724,11 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   }
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!Node26.isCallExpression(node)) {
+    if (!Node27.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!Node26.isPropertyAccessExpression(callee)) {
+    if (!Node27.isPropertyAccessExpression(callee)) {
       return;
     }
     const methodName = callee.getName();
@@ -6149,7 +6740,7 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
       return;
     }
     const args = node.getArguments();
-    if (args.length === 0 || !Node26.isObjectLiteralExpression(args[0])) {
+    if (args.length === 0 || !Node27.isObjectLiteralExpression(args[0])) {
       return;
     }
     const config = args[0];
@@ -6185,16 +6776,16 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   return results;
 }
 function imperativeConfigValue(prop) {
-  if (Node26.isPropertyAssignment(prop)) {
+  if (Node27.isPropertyAssignment(prop)) {
     return prop.getInitializer() ?? null;
   }
-  if (Node26.isShorthandPropertyAssignment(prop)) {
+  if (Node27.isShorthandPropertyAssignment(prop)) {
     const valueSymbol = prop.getValueSymbol();
     if (valueSymbol === void 0) {
       return null;
     }
     for (const decl of valueSymbol.getDeclarations()) {
-      if (Node26.isVariableDeclaration(decl)) {
+      if (Node27.isVariableDeclaration(decl)) {
         const init = decl.getInitializer();
         if (init !== void 0) {
           return init;
@@ -6207,7 +6798,7 @@ function imperativeConfigValue(prop) {
 }
 
 // src/discovery/jsxElementRoute.ts
-import { Node as Node27 } from "ts-morph";
+import { Node as Node28 } from "ts-morph";
 var PATH_NOT_LITERAL = "The path this route declares is not written as a string literal, so no path is claimed and this route pairs with nothing";
 var ENCLOSING_PATH_NOT_LITERAL = "A route this one is nested under declares its path as something other than a string literal, so the full path is not claimed and this route pairs with nothing";
 var SPREAD_NOT_ENUMERATED = "A spread stands in for routes declared elsewhere in this array, and they are not read here, so no path is claimed for any of them";
@@ -6239,7 +6830,7 @@ function discoverJsxElementRoutes(sourceFile, match, kind, resolution) {
       }
       return;
     }
-    if (Node27.isCallExpression(node) && callsAFactory(node, factoryNames)) {
+    if (Node28.isCallExpression(node) && callsAFactory(node, factoryNames)) {
       results.push(
         ...unitsForRouteArray(node, match, elementsNames, kind, resolution)
       );
@@ -6261,7 +6852,7 @@ function localNamesFor(sourceFile, match, exported) {
   return local;
 }
 function asRouteJsx(node, routeNames) {
-  if (!Node27.isJsxSelfClosingElement(node) && !Node27.isJsxElement(node)) {
+  if (!Node28.isJsxSelfClosingElement(node) && !Node28.isJsxElement(node)) {
     return null;
   }
   return isRouteJsx(node, routeNames) ? node : null;
@@ -6271,15 +6862,15 @@ function isRouteJsx(node, routeNames) {
   return tag !== null && routeNames.has(tag.getText());
 }
 function tagNameOf(node) {
-  const tag = Node27.isJsxElement(node) ? node.getOpeningElement().getTagNameNode() : node.getTagNameNode();
-  return Node27.isIdentifier(tag) ? tag : null;
+  const tag = Node28.isJsxElement(node) ? node.getOpeningElement().getTagNameNode() : node.getTagNameNode();
+  return Node28.isIdentifier(tag) ? tag : null;
 }
 function attributesOf(node) {
-  return Node27.isJsxElement(node) ? node.getOpeningElement().getAttributes() : node.getAttributes();
+  return Node28.isJsxElement(node) ? node.getOpeningElement().getAttributes() : node.getAttributes();
 }
 function attributeValueOf(node, name) {
   for (const attribute of attributesOf(node)) {
-    if (!Node27.isJsxAttribute(attribute)) {
+    if (!Node28.isJsxAttribute(attribute)) {
       continue;
     }
     if (attribute.getNameNode().getText() !== name) {
@@ -6290,8 +6881,8 @@ function attributeValueOf(node, name) {
   return null;
 }
 function literalStringOf2(value) {
-  const unwrapped2 = Node27.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (Node27.isStringLiteral(unwrapped2) || Node27.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  const unwrapped2 = Node28.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (Node28.isStringLiteral(unwrapped2) || Node28.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return unwrapped2.getLiteralValue();
   }
   return null;
@@ -6311,8 +6902,8 @@ function elementTargetOfValue(value) {
   if (value === null) {
     return { kind: "absent" };
   }
-  const unwrapped2 = Node27.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (!Node27.isJsxSelfClosingElement(unwrapped2) && !Node27.isJsxElement(unwrapped2)) {
+  const unwrapped2 = Node28.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (!Node28.isJsxSelfClosingElement(unwrapped2) && !Node28.isJsxElement(unwrapped2)) {
     return { kind: "unreadable" };
   }
   const tag = tagNameOf(unwrapped2);
@@ -6324,7 +6915,7 @@ function elementTargetOfValue(value) {
 function composedPrefixOf(node, match, routeNames) {
   const enclosing = [];
   for (const ancestor of node.getAncestors()) {
-    if (Node27.isJsxElement(ancestor) && isRouteJsx(ancestor, routeNames)) {
+    if (Node28.isJsxElement(ancestor) && isRouteJsx(ancestor, routeNames)) {
       enclosing.push(ancestor);
     }
   }
@@ -6440,14 +7031,14 @@ function abstention(at, kind, sentence, label) {
 }
 function callsAFactory(call, factoryNames) {
   const callee = call.getExpression();
-  return Node27.isIdentifier(callee) && factoryNames.has(callee.getText());
+  return Node28.isIdentifier(callee) && factoryNames.has(callee.getText());
 }
 function unitsForRouteArray(call, match, elementsNames, kind, resolution) {
   const first = call.getArguments()[0];
   if (first === void 0) {
     return [];
   }
-  if (Node27.isJsxElement(first) || Node27.isJsxSelfClosingElement(first) || Node27.isCallExpression(first) && callsAFactory(first, elementsNames)) {
+  if (Node28.isJsxElement(first) || Node28.isJsxSelfClosingElement(first) || Node28.isCallExpression(first) && callsAFactory(first, elementsNames)) {
     return [];
   }
   const array = arrayLiteralOf(first, resolution);
@@ -6472,7 +7063,7 @@ function unitsOfArrayElements(array, match, kind, resolution, prefix, ancestry)
   const nestedIn = new Set(ancestry).add(array);
   const results = [];
   for (const element of array.getElements()) {
-    if (Node27.isSpreadElement(element)) {
+    if (Node28.isSpreadElement(element)) {
       results.push(
         abstention(
           element,
@@ -6483,7 +7074,7 @@ function unitsOfArrayElements(array, match, kind, resolution, prefix, ancestry)
       );
       continue;
     }
-    if (!Node27.isObjectLiteralExpression(element)) {
+    if (!Node28.isObjectLiteralExpression(element)) {
       results.push(
         abstention(
           element,
@@ -6572,7 +7163,7 @@ function ownPathOfObject(object, match) {
   }
   if (match.indexAttribute !== void 0) {
     const indexValue = routePropertyOf(object, match.indexAttribute);
-    if (indexValue !== null && Node27.isTrueLiteral(indexValue)) {
+    if (indexValue !== null && Node28.isTrueLiteral(indexValue)) {
       return { kind: "inherited" };
     }
   }
@@ -6586,17 +7177,17 @@ function objectLabelOf(target) {
   return target.kind === "named" ? target.identifier.getText() : "declaration";
 }
 function labelOfExpression(node) {
-  if (Node27.isIdentifier(node)) {
+  if (Node28.isIdentifier(node)) {
     return node.getText();
   }
-  if (Node27.isCallExpression(node)) {
+  if (Node28.isCallExpression(node)) {
     return node.getExpression().getText();
   }
   return node.getKindName();
 }
 
 // src/discovery/packageExports.ts
-import { Node as Node29 } from "ts-morph";
+import { Node as Node30 } from "ts-morph";
 
 // src/packageExports.ts
 import fs3 from "fs";
@@ -6788,13 +7379,13 @@ function sameDeclaration(a, b) {
 }
 
 // src/discovery/factorySurface.ts
-import { Node as Node28, SyntaxKind as SyntaxKind6 } from "ts-morph";
+import { Node as Node29, SyntaxKind as SyntaxKind7 } from "ts-morph";
 var MAX_BUILDER_HOPS = 2;
 function surfaceMethods(decl) {
-  if (Node28.isClassDeclaration(decl)) {
+  if (Node29.isClassDeclaration(decl)) {
     return surfaceClassMethods(decl);
   }
-  if (Node28.isFunctionDeclaration(decl) || Node28.isFunctionExpression(decl) || Node28.isArrowFunction(decl) || Node28.isMethodDeclaration(decl)) {
+  if (Node29.isFunctionDeclaration(decl) || Node29.isFunctionExpression(decl) || Node29.isArrowFunction(decl) || Node29.isMethodDeclaration(decl)) {
     return surfaceFactoryReturnMethods(decl);
   }
   return [];
@@ -6803,7 +7394,7 @@ function surfaceClassMethods(cls) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const method of cls.getInstanceMethods()) {
-    if (method.hasModifier(SyntaxKind6.PrivateKeyword)) {
+    if (method.hasModifier(SyntaxKind7.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -6814,7 +7405,7 @@ function surfaceClassMethods(cls) {
     out.push({ func: method, name });
   }
   for (const method of cls.getStaticMethods()) {
-    if (method.hasModifier(SyntaxKind6.PrivateKeyword)) {
+    if (method.hasModifier(SyntaxKind7.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -6833,9 +7424,9 @@ function surfaceFactoryReturnMethods(fn) {
   return out;
 }
 function collectFromFunctionReturns(fn, out, seen, depth) {
-  if (Node28.isArrowFunction(fn)) {
+  if (Node29.isArrowFunction(fn)) {
     const body2 = fn.getBody();
-    if (Node28.isExpression(body2)) {
+    if (Node29.isExpression(body2)) {
       collectFromReturnValue(body2, out, seen, depth);
       return;
     }
@@ -6846,11 +7437,11 @@ function collectFromFunctionReturns(fn, out, seen, depth) {
   }
   const returns = [];
   body.forEachDescendant((node, traversal) => {
-    if (Node28.isFunctionDeclaration(node) || Node28.isFunctionExpression(node) || Node28.isArrowFunction(node) || Node28.isMethodDeclaration(node) || Node28.isConstructorDeclaration(node) || Node28.isGetAccessorDeclaration(node) || Node28.isSetAccessorDeclaration(node)) {
+    if (Node29.isFunctionDeclaration(node) || Node29.isFunctionExpression(node) || Node29.isArrowFunction(node) || Node29.isMethodDeclaration(node) || Node29.isConstructorDeclaration(node) || Node29.isGetAccessorDeclaration(node) || Node29.isSetAccessorDeclaration(node)) {
       traversal.skip();
       return;
     }
-    if (Node28.isReturnStatement(node)) {
+    if (Node29.isReturnStatement(node)) {
       returns.push(node);
     }
   });
@@ -6864,15 +7455,15 @@ function collectFromFunctionReturns(fn, out, seen, depth) {
 }
 function collectFromReturnValue(node, out, seen, depth) {
   const expr = peelParens(node);
-  if (Node28.isObjectLiteralExpression(expr)) {
+  if (Node29.isObjectLiteralExpression(expr)) {
     collectFromObjectLiteral(expr, out, seen);
     return;
   }
-  if (depth >= MAX_BUILDER_HOPS || !Node28.isCallExpression(expr)) {
+  if (depth >= MAX_BUILDER_HOPS || !Node29.isCallExpression(expr)) {
     return;
   }
   const callee = expr.getExpression();
-  if (!Node28.isIdentifier(callee)) {
+  if (!Node29.isIdentifier(callee)) {
     return;
   }
   const helper = sameFileFunctionBehind(callee);
@@ -6895,12 +7486,12 @@ function functionAmong(declarations, filePath) {
     if (decl.getSourceFile().getFilePath() !== filePath) {
       continue;
     }
-    if (Node28.isFunctionDeclaration(decl)) {
+    if (Node29.isFunctionDeclaration(decl)) {
       return decl;
     }
-    if (Node28.isVariableDeclaration(decl)) {
+    if (Node29.isVariableDeclaration(decl)) {
       const init = decl.getInitializer();
-      if (init !== void 0 && (Node28.isArrowFunction(init) || Node28.isFunctionExpression(init))) {
+      if (init !== void 0 && (Node29.isArrowFunction(init) || Node29.isFunctionExpression(init))) {
         return init;
       }
     }
@@ -6909,11 +7500,11 @@ function functionAmong(declarations, filePath) {
 }
 function collectFromObjectLiteral(node, out, seen) {
   const e = peelParens(node);
-  if (!Node28.isObjectLiteralExpression(e)) {
+  if (!Node29.isObjectLiteralExpression(e)) {
     return;
   }
   for (const prop of e.getProperties()) {
-    if (Node28.isMethodDeclaration(prop)) {
+    if (Node29.isMethodDeclaration(prop)) {
       const name = prop.getName();
       if (seen.has(name)) {
         continue;
@@ -6922,16 +7513,16 @@ function collectFromObjectLiteral(node, out, seen) {
       out.push({ func: prop, name });
       continue;
     }
-    if (Node28.isPropertyAssignment(prop)) {
+    if (Node29.isPropertyAssignment(prop)) {
       const init = prop.getInitializer();
       if (init === void 0) {
         continue;
       }
       let v3 = init;
-      while (Node28.isParenthesizedExpression(v3)) {
+      while (Node29.isParenthesizedExpression(v3)) {
         v3 = v3.getExpression();
       }
-      if (Node28.isArrowFunction(v3) || Node28.isFunctionExpression(v3)) {
+      if (Node29.isArrowFunction(v3) || Node29.isFunctionExpression(v3)) {
         const name = prop.getName();
         if (seen.has(name)) {
           continue;
@@ -6940,7 +7531,7 @@ function collectFromObjectLiteral(node, out, seen) {
         out.push({ func: v3, name });
       }
     }
-    if (Node28.isShorthandPropertyAssignment(prop)) {
+    if (Node29.isShorthandPropertyAssignment(prop)) {
       collectShorthandFunction(prop, out, seen);
     }
   }
@@ -7003,9 +7594,9 @@ function discoverPackageExports(sourceFile, match, kind, resolution) {
         (decl) => sourceDeclarationsBehind(decl, resolution)
       );
       for (const decl of candidates) {
-        if (Node29.isVariableDeclaration(decl)) {
+        if (Node30.isVariableDeclaration(decl)) {
           const init = decl.getInitializer();
-          if (init !== void 0 && (Node29.isArrowFunction(init) || Node29.isFunctionExpression(init))) {
+          if (init !== void 0 && (Node30.isArrowFunction(init) || Node30.isFunctionExpression(init))) {
             results.push(buildUnit(init, kind, exportName, entry));
             for (const m of surfaceMethods(init)) {
               results.push(buildSurfacedUnit(m, kind, exportName, entry));
@@ -7015,7 +7606,7 @@ function discoverPackageExports(sourceFile, match, kind, resolution) {
           }
           continue;
         }
-        if (Node29.isClassDeclaration(decl)) {
+        if (Node30.isClassDeclaration(decl)) {
           for (const m of surfaceMethods(decl)) {
             results.push(buildSurfacedUnit(m, kind, exportName, entry));
           }
@@ -7061,7 +7652,7 @@ function buildSurfacedUnit(m, kind, parentExportName, entry) {
 
 // src/discovery/packageImport.ts
 import {
-  Node as Node30
+  Node as Node31
 } from "ts-morph";
 function isLanguageLib(file) {
   return /[\\/]typescript[\\/]lib[\\/]lib\..*\.d\.ts$/.test(file.getFilePath());
@@ -7083,13 +7674,13 @@ function splitPackageSpec(spec) {
   };
 }
 function enclosingFunctionName(func) {
-  if (Node30.isFunctionDeclaration(func) || Node30.isMethodDeclaration(func)) {
+  if (Node31.isFunctionDeclaration(func) || Node31.isMethodDeclaration(func)) {
     const n = func.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (Node30.isFunctionExpression(func)) {
+  if (Node31.isFunctionExpression(func)) {
     const n = func.getName();
     if (typeof n === "string" && n.length > 0) {
       return n;
@@ -7097,10 +7688,10 @@ function enclosingFunctionName(func) {
   }
   const parent = func.getParent();
   if (parent !== void 0) {
-    if (Node30.isVariableDeclaration(parent)) {
+    if (Node31.isVariableDeclaration(parent)) {
       return parent.getName();
     }
-    if (Node30.isPropertyAssignment(parent)) {
+    if (Node31.isPropertyAssignment(parent)) {
       return parent.getName();
     }
   }
@@ -7119,7 +7710,7 @@ function attributedCalls(sourceFile, packages, resolution) {
   const calls = [];
   const candidates = /* @__PURE__ */ new Set();
   sourceFile.forEachDescendant((node) => {
-    if (!Node30.isCallExpression(node)) {
+    if (!Node31.isCallExpression(node)) {
       return;
     }
     calls.push(node);
@@ -7127,7 +7718,7 @@ function attributedCalls(sourceFile, packages, resolution) {
     if (couldBePackageLinked(callee, packages)) {
       candidates.add(callee);
     }
-    if (Node30.isPropertyAccessExpression(callee) && couldBePackageLinked(callee.getExpression(), packages)) {
+    if (Node31.isPropertyAccessExpression(callee) && couldBePackageLinked(callee.getExpression(), packages)) {
       candidates.add(callee.getExpression());
     }
   });
@@ -7149,7 +7740,7 @@ function attributedCalls(sourceFile, packages, resolution) {
     if (direct !== null) {
       return direct;
     }
-    if (!Node30.isPropertyAccessExpression(callee)) {
+    if (!Node31.isPropertyAccessExpression(callee)) {
       return null;
     }
     const subject = originOf(callee.getExpression());
@@ -7174,7 +7765,7 @@ function attributedCalls(sourceFile, packages, resolution) {
   return results;
 }
 function couldBePackageLinked(value, packages) {
-  if (!Node30.isIdentifier(value)) {
+  if (!Node31.isIdentifier(value)) {
     return true;
   }
   const declarations = value.getSymbol()?.getDeclarations() ?? [];
@@ -7182,7 +7773,7 @@ function couldBePackageLinked(value, packages) {
     return true;
   }
   return !declarations.every(
-    (declaration) => Node30.isFunctionDeclaration(declaration) || Node30.isMethodDeclaration(declaration) || Node30.isClassDeclaration(declaration) || Node30.isImportSpecifier(declaration) && importAimsElsewhere(declaration, packages)
+    (declaration) => Node31.isFunctionDeclaration(declaration) || Node31.isMethodDeclaration(declaration) || Node31.isClassDeclaration(declaration) || Node31.isImportSpecifier(declaration) && importAimsElsewhere(declaration, packages)
   );
 }
 function importAimsElsewhere(declaration, packages) {
@@ -7239,156 +7830,9 @@ import { Node as Node32 } from "ts-morph";
 import { joinMountedPath } from "@suss/resolution";
 
 // src/resolve/routePath.ts
-import { Node as Node31 } from "ts-morph";
-import { patternHole } from "@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(path14, text) {
-  const idx = text.search(/[?#]/);
-  if (idx === -1) {
-    return { path: path14 + text, stop: false };
-  }
-  return { path: path14 + 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 path14 = isAbsoluteUrlLiteral(text) ? pathnameOfAbsoluteLiteral(text) : stripQueryAndFragment(text);
-  return path14 === "" ? void 0 : path14;
-}
-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 path14 = 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) {
-      path14 += holeText(span.getExpression(), resolution);
-    }
-    at += SUBSTITUTION.length;
-    const appended = appendPathText(
-      path14,
-      tailText.slice(Math.max(0, originEnd - at))
-    );
-    path14 = appended.path;
-    stop = appended.stop;
-    at += tailText.length;
-  }
-  return path14 === "" ? void 0 : path14;
-}
-function pathFromUrlNode(node, resolution) {
-  if (Node31.isStringLiteral(node)) {
-    return pathFromLiteralUrl(node.getLiteralValue());
-  }
-  if (Node31.isNoSubstitutionTemplateLiteral(node)) {
-    return pathFromLiteralUrl(node.getLiteralValue());
-  }
-  if (Node31.isTemplateExpression(node)) {
-    return pathFromTemplateUrl(node, resolution);
-  }
-  if (Node31.isBinaryExpression(node)) {
-    const joined = joinedStringOf(node, resolution);
-    return joined === void 0 ? void 0 : pathFromLiteralUrl(joined);
-  }
-  return void 0;
-}
-function joinedStringOf(node, resolution) {
-  if (Node31.isStringLiteral(node) || Node31.isNoSubstitutionTemplateLiteral(node)) {
-    return node.getLiteralValue();
-  }
-  if (Node31.isBinaryExpression(node) && node.getOperatorToken().getText() === "+") {
-    const left = joinedStringOf(node.getLeft(), resolution);
-    const right = joinedStringOf(node.getRight(), resolution);
-    return left === void 0 || right === void 0 ? void 0 : left + right;
-  }
-  const written = resolution?.resolveWrittenValue(node) ?? null;
-  return written === null || written === node ? void 0 : joinedStringOf(written, resolution);
-}
-function placeholderName(expr) {
-  if (Node31.isIdentifier(expr)) {
-    return expr.getText();
-  }
-  if (Node31.isPropertyAccessExpression(expr)) {
-    return expr.getName();
-  }
-  return "param";
-}
-function holeText(expr, resolution) {
-  const written = resolution?.resolveWrittenValue(expr) ?? null;
-  if (written === null) {
-    return patternHole(placeholderName(expr));
-  }
-  if (emptyStringLiteral(written)) {
-    return "";
-  }
-  return pathFromUrlNode(written, resolution) ?? patternHole(placeholderName(expr));
-}
-function emptyStringLiteral(node) {
-  return (Node31.isStringLiteral(node) || Node31.isNoSubstitutionTemplateLiteral(node)) && node.getLiteralValue() === "";
-}
+import { pathOf } from "@suss/values";
 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;
+  return pathOf(evaluatedValue(arg, resolution));
 }
 
 // src/discovery/registrationCall.ts
@@ -7801,32 +8245,14 @@ function mountTargetsAmong(args, targetPosition, knownSubjectIds, resolution) {
   }
   return targets;
 }
-function stringProperty(obj, name) {
-  if (!Node32.isObjectLiteralExpression(obj)) {
-    return null;
-  }
-  const property = obj.getProperty(name);
-  if (property === void 0 || !Node32.isPropertyAssignment(property)) {
-    return null;
-  }
-  const value = property.getInitializer();
-  if (value !== void 0 && (Node32.isStringLiteral(value) || Node32.isNoSubstitutionTemplateLiteral(value))) {
-    return value.getLiteralValue();
-  }
-  return null;
-}
 function extractRouteInfoFromBinding(call, methodName, binding, resolution) {
   if (binding.method.type === "fromArgumentProperty" && binding.path.type === "fromArgumentProperty" && binding.method.position === binding.path.position) {
     const arg = call.getArguments()[binding.method.position];
     if (arg === void 0) {
       return null;
     }
-    const routeObject = objectLiteralOf(arg, resolution);
-    if (routeObject === null) {
-      return null;
-    }
-    const method2 = stringProperty(routeObject, binding.method.property);
-    const path15 = stringProperty(routeObject, binding.path.property);
+    const method2 = stringPropertyOf(arg, binding.method.property, resolution);
+    const path15 = stringPropertyOf(arg, binding.path.property, resolution);
     if (method2 === null || path15 === null) {
       return null;
     }
@@ -8027,7 +8453,7 @@ import { joinMountedPath as joinMountedPath2 } from "@suss/resolution";
 // src/resolve/unfollowedCall.ts
 import {
   Node as Node34,
-  SyntaxKind as SyntaxKind7
+  SyntaxKind as SyntaxKind8
 } from "ts-morph";
 import {
   unfollowedCallGap,
@@ -8053,14 +8479,14 @@ function isExternalDeclaration(declaration) {
     return true;
   }
   if (Node34.isImportSpecifier(declaration) || Node34.isImportClause(declaration) || Node34.isNamespaceImport(declaration)) {
-    const target = declaration.getFirstAncestorByKind(SyntaxKind7.ImportDeclaration)?.getModuleSpecifierSourceFile();
+    const target = declaration.getFirstAncestorByKind(SyntaxKind8.ImportDeclaration)?.getModuleSpecifierSourceFile();
     return target === void 0 || isInExternalCode(target);
   }
   return declaresAnotherModule(declaration);
 }
 function declaresAnotherModule(declaration) {
   const module = declaration.getFirstAncestorByKind(
-    SyntaxKind7.ModuleDeclaration
+    SyntaxKind8.ModuleDeclaration
   );
   return module !== void 0 && Node34.isStringLiteral(module.getNameNode());
 }
@@ -8686,8 +9112,8 @@ function parameterReads(func, parameterNames2, barriers = NO_BARRIERS) {
 }
 
 // src/resolve/readName.ts
-import { Node as Node39, SyntaxKind as SyntaxKind8 } from "ts-morph";
-import { patternHole as patternHole2, referenceName } from "@suss/behavioral-ir";
+import { Node as Node39, SyntaxKind as SyntaxKind9 } from "ts-morph";
+import { patternHole, referenceName } from "@suss/behavioral-ir";
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
 function readName(expr, options = {}) {
@@ -8787,7 +9213,7 @@ function isFallbackBranch(node) {
     return false;
   }
   const operator = step.getOperatorToken().getKind();
-  return operator === SyntaxKind8.BarBarToken || operator === SyntaxKind8.QuestionQuestionToken;
+  return operator === SyntaxKind9.BarBarToken || operator === SyntaxKind9.QuestionQuestionToken;
 }
 function fromTemplate(expr, ctx) {
   if (!Node39.isTemplateExpression(expr)) {
@@ -8805,10 +9231,10 @@ function fromBinary(expr, ctx) {
     return null;
   }
   const operator = expr.getOperatorToken().getKind();
-  if (operator === SyntaxKind8.BarBarToken || operator === SyntaxKind8.QuestionQuestionToken) {
+  if (operator === SyntaxKind9.BarBarToken || operator === SyntaxKind9.QuestionQuestionToken) {
     return ctx.insideHole ? null : read(expr.getRight(), ctx);
   }
-  if (operator !== SyntaxKind8.PlusToken) {
+  if (operator !== SyntaxKind9.PlusToken) {
     return null;
   }
   const parts = { ...ctx, insideHole: true };
@@ -8951,7 +9377,7 @@ function boundOnce(expr, ctx) {
 }
 function readOrHole(expr, ctx) {
   const name = read(expr, ctx);
-  return name ?? patternHole2(holeName(expr, ctx));
+  return name ?? patternHole(holeName(expr, ctx));
 }
 function holeName(expr, ctx) {
   const bound = boundOnce(expr, ctx);
@@ -9018,7 +9444,7 @@ function madeExpression(receiver) {
 }
 function callOpsFor(call, resolveWrittenValue, originatesFrom, anchorCallsOf) {
   const resolve2 = resolveWrittenValue ?? (() => null);
-  const expression = calleeOf2(call);
+  const expression = calleeOf3(call);
   const callee = Node40.isPropertyAccessExpression(expression) ? expression : null;
   let args = null;
   const argumentsOf = () => {
@@ -9070,7 +9496,7 @@ function anchorCallBehind(subject, origin, resolve2, originatesFrom, anchorCalls
     if (!Node40.isCallExpression(candidate) && !Node40.isNewExpression(candidate)) {
       return false;
     }
-    const candidateCallee = calleeOf2(candidate);
+    const candidateCallee = calleeOf3(candidate);
     if (origin.named !== void 0 && !origin.named.includes(constructorName(candidate))) {
       return false;
     }
@@ -9204,7 +9630,7 @@ function opsOverCall(value, resolve2) {
 function isCalled(value) {
   return Node40.isCallExpression(value) || Node40.isNewExpression(value) || Node40.isTaggedTemplateExpression(value);
 }
-function calleeOf2(call) {
+function calleeOf3(call) {
   return Node40.isTaggedTemplateExpression(call) ? call.getTag() : call.getExpression();
 }
 function argumentsIn(call) {
@@ -9983,7 +10409,7 @@ import {
 // src/shapes/shapes.ts
 import {
   Node as Node45,
-  SyntaxKind as SyntaxKind9
+  SyntaxKind as SyntaxKind10
 } from "ts-morph";
 
 // src/shapes/typeShapes.ts
@@ -10469,13 +10895,13 @@ function extractShapeInner(node) {
   }
   if (Node45.isPrefixUnaryExpression(unwrapped2)) {
     const op = unwrapped2.getOperatorToken();
-    if (op === SyntaxKind9.MinusToken || op === SyntaxKind9.PlusToken) {
+    if (op === SyntaxKind10.MinusToken || op === SyntaxKind10.PlusToken) {
       const inner = unwrapped2.getOperand();
       if (Node45.isNumericLiteral(inner)) {
         const v3 = inner.getLiteralValue();
-        const signed = op === SyntaxKind9.MinusToken ? -v3 : v3;
+        const signed = op === SyntaxKind10.MinusToken ? -v3 : v3;
         const rawBody = inner.getText();
-        const raw = op === SyntaxKind9.MinusToken ? `-${rawBody}` : rawBody;
+        const raw = op === SyntaxKind10.MinusToken ? `-${rawBody}` : rawBody;
         return numericLiteralShape(signed, raw);
       }
     }
@@ -10484,13 +10910,13 @@ function extractShapeInner(node) {
     return { type: "ref", name: "bigint" };
   }
   const kind = unwrapped2.getKind();
-  if (kind === SyntaxKind9.TrueKeyword) {
+  if (kind === SyntaxKind10.TrueKeyword) {
     return { type: "literal", value: true };
   }
-  if (kind === SyntaxKind9.FalseKeyword) {
+  if (kind === SyntaxKind10.FalseKeyword) {
     return { type: "literal", value: false };
   }
-  if (kind === SyntaxKind9.NullKeyword) {
+  if (kind === SyntaxKind10.NullKeyword) {
     return { type: "null" };
   }
   if (Node45.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
@@ -10619,6 +11045,7 @@ function collapseVariants2(shapes) {
 import {
   Node as Node46
 } from "ts-morph";
+import { constantOf } from "@suss/values";
 function unwrapAs(node) {
   return peelSyntax(node);
 }
@@ -10675,15 +11102,11 @@ function matchConstructorCode(ctorText, codes) {
   return null;
 }
 function statusOf(value, ctx) {
-  const unwrapped2 = unwrapAs(value);
-  if (Node46.isNumericLiteral(unwrapped2)) {
-    return { type: "literal", value: Number(unwrapped2.getText()) };
-  }
-  const resolved = ctx.resolveWrittenValue?.(unwrapped2) ?? null;
-  if (resolved !== null && Node46.isNumericLiteral(resolved)) {
-    return { type: "literal", value: Number(resolved.getText()) };
+  const status = constantOf(evaluatedValue(value, ctx.resolution));
+  if (typeof status === "number") {
+    return { type: "literal", value: status };
   }
-  return { type: "dynamic", sourceText: unwrapped2.getText() };
+  return { type: "dynamic", sourceText: unwrapAs(value).getText() };
 }
 function statusFromProperty(obj, name, ctx) {
   const prop = obj.getProperty(name);
@@ -10863,7 +11286,7 @@ function extractBody(ctx) {
 }
 
 // src/terminals/helperResolution.ts
-import { Node as Node47, SyntaxKind as SyntaxKind10 } from "ts-morph";
+import { Node as Node47, SyntaxKind as SyntaxKind11 } from "ts-morph";
 function resolveHelperReturn(call, resolveCallee2) {
   const callee = call.getExpression();
   if (!Node47.isIdentifier(callee)) {
@@ -11075,7 +11498,7 @@ function returnedObjects(fn) {
   }
   const found = [];
   for (const statement of body.getDescendantsOfKind(
-    SyntaxKind10.ReturnStatement
+    SyntaxKind11.ReturnStatement
   )) {
     if (enclosingFunctionOf(statement) !== body) {
       continue;
@@ -11114,13 +11537,14 @@ function bindArguments(callArgs, params) {
 
 // src/terminals/statusBranches.ts
 import { Node as Node48 } from "ts-morph";
-function statusChoicesOf(argument) {
+import { constantOf as constantOf2 } from "@suss/values";
+function statusChoicesOf(argument, resolution) {
   const chosen = asConditional(argument);
   if (chosen === null) {
     return null;
   }
-  const whenTrue = numberOf(chosen.getWhenTrue());
-  const whenFalse = numberOf(chosen.getWhenFalse());
+  const whenTrue = numberOf(chosen.getWhenTrue(), resolution);
+  const whenFalse = numberOf(chosen.getWhenFalse(), resolution);
   if (whenTrue === null || whenFalse === null) {
     return null;
   }
@@ -11151,20 +11575,14 @@ function asConditional(node) {
   return only === void 0 ? null : toConditional(only);
 }
 var toConditional = (node) => Node48.isConditionalExpression(node) ? node : null;
-function numberOf(node) {
-  const inner = unwrap(node);
-  if (!Node48.isNumericLiteral(inner)) {
-    return null;
-  }
-  const value = Number(inner.getText());
-  return Number.isFinite(value) ? value : null;
-}
-function unwrap(node) {
-  return peelSyntax(node);
+function numberOf(node, resolution) {
+  const value = constantOf2(evaluatedValue(node, resolution));
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
 // src/terminals/returns.ts
-function unwrapMethodChain(call, methodChain, func, paramPos) {
+function unwrapMethodChain(call, match, func) {
+  const { methodChain, parameterPosition: paramPos } = match;
   if (methodChain.length === 0) {
     return null;
   }
@@ -11180,7 +11598,10 @@ function unwrapMethodChain(call, methodChain, func, paramPos) {
       return null;
     }
     collected.unshift(current2);
-    const subject = callee.getExpression();
+    const subject = withoutPassThroughCalls(
+      callee.getExpression(),
+      match.passThroughMethods ?? []
+    );
     if (i === 0) {
       if (parameterPositionOf(subject, func) !== paramPos) {
         return null;
@@ -11194,11 +11615,22 @@ function unwrapMethodChain(call, methodChain, func, paramPos) {
   }
   return { calls: collected };
 }
+function withoutPassThroughCalls(subject, passThrough) {
+  let current2 = subject;
+  while (Node49.isCallExpression(current2)) {
+    const callee = current2.getExpression();
+    if (!Node49.isPropertyAccessExpression(callee) || !passThrough.includes(callee.getName())) {
+      break;
+    }
+    current2 = callee.getExpression();
+  }
+  return current2;
+}
 function returnedValueOf(returnStatement) {
   const written = returnStatement.getExpression();
   return written === void 0 ? null : unwrapValue(written);
 }
-function tryMatchReturnShape(node, pattern, match, resolveWrittenValue, resolveCallee2) {
+function tryMatchReturnShape(node, pattern, match, resolution, resolveCallee2) {
   if (Node49.isObjectLiteralExpression(node)) {
     const source = returnPositionOf(node);
     if (source === null) {
@@ -11213,7 +11645,7 @@ function tryMatchReturnShape(node, pattern, match, resolveWrittenValue, resolveC
       pattern,
       match,
       void 0,
-      resolveWrittenValue
+      resolution
     );
     return terminal === null ? [] : [{ ...terminal, source }];
   }
@@ -11231,7 +11663,7 @@ function tryMatchReturnShape(node, pattern, match, resolveWrittenValue, resolveC
       pattern,
       match,
       void 0,
-      resolveWrittenValue
+      resolution
     );
     return terminal === null ? [] : [terminal];
   }
@@ -11259,7 +11691,7 @@ function tryMatchReturnShape(node, pattern, match, resolveWrittenValue, resolveC
       pattern,
       match,
       resolved.substitutions,
-      resolveWrittenValue
+      resolution
     );
     if (terminal !== null) {
       terminals.push(terminal);
@@ -11267,7 +11699,7 @@ function tryMatchReturnShape(node, pattern, match, resolveWrittenValue, resolveC
   }
   return terminals;
 }
-function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions, resolveWrittenValue) {
+function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions, resolution) {
   const required = match.requiredProperties;
   if (required !== void 0 && required.length > 0) {
     const presentNames = /* @__PURE__ */ new Set();
@@ -11286,7 +11718,7 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
     extraction: pattern.extraction,
     returnedObj: obj,
     ...substitutions !== void 0 ? { substitutions } : {},
-    ...resolveWrittenValue !== void 0 ? { resolveWrittenValue } : {}
+    ...resolution !== void 0 ? { resolution } : {}
   };
   const statusCode = extractStatusCode(ctx);
   let body = extractBody(ctx);
@@ -11316,16 +11748,11 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
     }
   };
 }
-function tryMatchParameterMethodCall(node, func, pattern, match, resolveWrittenValue) {
+function tryMatchParameterMethodCall(node, func, pattern, match, resolution) {
   if (!Node49.isCallExpression(node)) {
     return [];
   }
-  const result = unwrapMethodChain(
-    node,
-    match.methodChain,
-    func,
-    match.parameterPosition
-  );
+  const result = unwrapMethodChain(node, match, func);
   if (result === null) {
     return [];
   }
@@ -11334,7 +11761,7 @@ function tryMatchParameterMethodCall(node, func, pattern, match, resolveWrittenV
   const ctx = {
     extraction: pattern.extraction,
     calls,
-    ...resolveWrittenValue !== void 0 ? { resolveWrittenValue } : {}
+    ...resolution !== void 0 ? { resolution } : {}
   };
   const statusCode = extractStatusCode(ctx);
   const body = extractBody(ctx);
@@ -11355,7 +11782,7 @@ function tryMatchParameterMethodCall(node, func, pattern, match, resolveWrittenV
   };
   const base = { node, ...source !== null ? { source } : {} };
   const argument = statusArgument(calls, pattern.extraction);
-  const choices = argument === null ? null : statusChoicesOf(argument);
+  const choices = argument === null ? null : statusChoicesOf(argument, resolution);
   if (choices === null) {
     return [{ ...base, terminal }];
   }
@@ -11389,12 +11816,7 @@ function returnCoveredByParameterMethodCall(expr, func, patterns) {
     if (pattern.match.type !== "parameterMethodCall") {
       continue;
     }
-    const result = unwrapMethodChain(
-      current2,
-      pattern.match.methodChain,
-      func,
-      pattern.match.parameterPosition
-    );
+    const result = unwrapMethodChain(current2, pattern.match, func);
     if (result !== null) {
       return true;
     }
@@ -11492,7 +11914,7 @@ function calleeSubject(callee) {
   }
   return null;
 }
-function tryMatchFunctionCall(node, pattern, match, resolveWrittenValue, originatesFrom) {
+function tryMatchFunctionCall(node, pattern, match, resolution, originatesFrom) {
   if (!Node49.isCallExpression(node) && !Node49.isNewExpression(node)) {
     return null;
   }
@@ -11511,7 +11933,7 @@ function tryMatchFunctionCall(node, pattern, match, resolveWrittenValue, origina
   const ctx = {
     extraction: pattern.extraction,
     throwCallArgs: callArgs,
-    ...resolveWrittenValue !== void 0 ? { resolveWrittenValue } : {}
+    ...resolution !== void 0 ? { resolution } : {}
   };
   const statusCode = extractStatusCode(ctx);
   const body = extractBody(ctx);
@@ -11536,7 +11958,7 @@ function tryMatchFunctionCall(node, pattern, match, resolveWrittenValue, origina
 
 // src/terminals/throws.ts
 import { Node as Node50 } from "ts-morph";
-function tryMatchThrowExpression(node, pattern, match, resolveWrittenValue) {
+function tryMatchThrowExpression(node, pattern, match, resolution) {
   if (!Node50.isThrowStatement(node)) {
     return null;
   }
@@ -11551,7 +11973,7 @@ function tryMatchThrowExpression(node, pattern, match, resolveWrittenValue) {
     extraction: pattern.extraction,
     ...callArgs !== null ? { throwCallArgs: callArgs } : {},
     ...exceptionType !== null ? { exceptionType } : {},
-    ...resolveWrittenValue !== void 0 ? { resolveWrittenValue } : {}
+    ...resolution !== void 0 ? { resolution } : {}
   };
   const statusCode = extractStatusCode(ctx);
   const body = extractBody(ctx);
@@ -11607,7 +12029,7 @@ function classifyThrownExpression(thrown, constructorPattern) {
 
 // src/terminals/index.ts
 var NESTED_ESCAPING_MATCH_TYPES = /* @__PURE__ */ new Set(["parameterMethodCall"]);
-function findTerminals(func, patterns, barriers = NO_BARRIERS, resolveWrittenValue, originatesFrom, resolveCallee2) {
+function findTerminals(func, patterns, barriers = NO_BARRIERS, resolution, originatesFrom, resolveCallee2) {
   const results = [];
   func.forEachDescendant((node, traversal) => {
     if (isDescentStop(node, func, barriers)) {
@@ -11625,7 +12047,7 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolveWrittenVal
           node,
           pattern,
           pattern.match,
-          resolveWrittenValue,
+          resolution,
           resolveCallee2
         );
         if (matches.length > 0) {
@@ -11640,7 +12062,7 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolveWrittenVal
           func,
           pattern,
           pattern.match,
-          resolveWrittenValue
+          resolution
         );
         if (matches.length > 0) {
           results.push(...matches);
@@ -11657,14 +12079,14 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolveWrittenVal
           node,
           pattern,
           pattern.match,
-          resolveWrittenValue
+          resolution
         );
       } else if (pattern.match.type === "functionCall") {
         found = tryMatchFunctionCall(
           node,
           pattern,
           pattern.match,
-          resolveWrittenValue,
+          resolution,
           originatesFrom
         );
       } else if (pattern.match.type === "parameterCall") {
@@ -11820,15 +12242,16 @@ function countUnmatchedReturns(func, terminals, barriers = NO_BARRIERS) {
   });
   return unmatched;
 }
-function extractRawBranches(func, terminalPatterns, invocationRecognizers = [], accessRecognizers = [], barriers = NO_BARRIERS, resolveWrittenValue, originatesFrom, anchorCallsOf, resolveCallee2) {
+function extractRawBranches(func, terminalPatterns, invocationRecognizers = [], accessRecognizers = [], barriers = NO_BARRIERS, resolution, originatesFrom, anchorCallsOf, resolveCallee2) {
   const terminals = findTerminals(
     func,
     terminalPatterns,
     barriers,
-    resolveWrittenValue,
+    resolution,
     originatesFrom,
     resolveCallee2
   );
+  const resolveWrittenValue = resolution === void 0 ? void 0 : (value) => resolution.resolveWrittenValue(value);
   const invocations = extractInvocationEffects(func, barriers);
   const recognized = [
     ...runInvocationRecognizers(
@@ -13793,7 +14216,7 @@ function extractReachableSummary(candidate, options, recognizers) {
     recognizers.invocation,
     recognizers.access,
     void 0,
-    recognizers.resolveWrittenValue
+    recognizers.resolution
   );
   raw.boundaryBinding = functionCallBinding({
     transport: "in-process",
@@ -14398,7 +14821,7 @@ function prefixOfExpr(expr, responseCall, depth) {
   if (depth >= MAX_PREFIX_DEPTH) {
     return null;
   }
-  const node = unwrap2(expr);
+  const node = unwrap(expr);
   if (node === responseCall) {
     return [];
   }
@@ -14451,7 +14874,7 @@ function firstCallbackParamName(callback) {
   const nameNode = param.getNameNode();
   return Node62.isIdentifier(nameNode) ? nameNode.getText() : null;
 }
-function unwrap2(expr) {
+function unwrap(expr) {
   let node = expr;
   while (Node62.isAwaitExpression(node) || Node62.isParenthesizedExpression(node) || Node62.isAsExpression(node)) {
     node = node.getExpression();
@@ -14466,7 +14889,7 @@ function chainRootedAt(expr, rootName) {
   return Node62.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
 }
 function memberChain(expr) {
-  let node = Node62.isExpression(expr) ? unwrap2(expr) : expr;
+  let node = Node62.isExpression(expr) ? unwrap(expr) : expr;
   if (Node62.isCallExpression(node)) {
     node = node.getExpression();
   }
@@ -15369,7 +15792,7 @@ function announcedBoundaryStructure(unit) {
     declaredContract: null
   };
 }
-function extractCodeStructure(unit, pack, invocationRecognizers = [], accessRecognizers = [], barriers = NO_BARRIERS, resolveWrittenValue, originatesFrom, anchorCallsOf, resolveCallee2) {
+function extractCodeStructure(unit, pack, invocationRecognizers = [], accessRecognizers = [], barriers = NO_BARRIERS, resolution, originatesFrom, anchorCallsOf, resolveCallee2) {
   const read2 = withDefinitions(
     () => readCodeStructure(
       unit,
@@ -15377,7 +15800,7 @@ function extractCodeStructure(unit, pack, invocationRecognizers = [], accessReco
       invocationRecognizers,
       accessRecognizers,
       barriers,
-      resolveWrittenValue,
+      resolution,
       originatesFrom,
       anchorCallsOf,
       resolveCallee2
@@ -15462,7 +15885,7 @@ function terminalsFor(unit, pack) {
   }
   return [...declared, FUNCTION_FALLTHROUGH_TERMINAL];
 }
-function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers, barriers, resolveWrittenValue, originatesFrom, anchorCallsOf, resolveCallee2) {
+function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers, barriers, resolution, originatesFrom, anchorCallsOf, resolveCallee2) {
   const { func, kind, name } = unit;
   if (func === null) {
     return announcedBoundaryStructure(unit);
@@ -15477,7 +15900,7 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
     invocationRecognizers,
     accessRecognizers,
     barriers,
-    resolveWrittenValue,
+    resolution,
     originatesFrom,
     anchorCallsOf,
     resolveCallee2
@@ -15599,21 +16022,9 @@ function extractBindingMethod(binding, callSite, pack, resolution) {
     return resolveContractField(callSite, pack, "method", resolution);
   }
   if (m.type === "fromArgumentProperty") {
-    const args = callSite.callExpression.getArguments();
-    const arg = args[m.position];
-    if (arg !== void 0 && Node64.isObjectLiteralExpression(arg)) {
-      const prop = arg.getProperty(m.property);
-      if (prop !== void 0 && Node64.isPropertyAssignment(prop)) {
-        const init = prop.getInitializer();
-        if (init !== void 0) {
-          const value = stringValueOf(init, resolution);
-          if (value !== null) {
-            return value;
-          }
-        }
-      }
-    }
-    return m.default;
+    const arg = callSite.callExpression.getArguments()[m.position];
+    const value = arg === void 0 ? null : stringPropertyOf(arg, m.property, resolution);
+    return value ?? m.default;
   }
   if (m.type === "literal") {
     return m.value;
@@ -15816,7 +16227,7 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
         allInvocationRecognizers,
         allAccessRecognizers,
         barriers,
-        resolution === void 0 ? void 0 : (value) => resolution.resolveWrittenValue(value),
+        resolution,
         resolution === void 0 ? void 0 : (value, module) => resolution.importOriginsOf(value, [module]).length > 0,
         resolution === void 0 ? void 0 : (value, matches) => resolution.anchorCallsOf(value, matches),
         resolution === void 0 ? void 0 : (value) => resolution.resolveCallable(value)
@@ -16178,7 +16589,7 @@ function findWrapperPathParam(summary, lookup) {
   if (names.length === 0) {
     return null;
   }
-  for (const call of func.getDescendantsOfKind(SyntaxKind11.CallExpression)) {
+  for (const call of func.getDescendantsOfKind(SyntaxKind12.CallExpression)) {
     const first = call.getArguments()[0];
     if (first === void 0 || !Node64.isIdentifier(first)) {
       continue;
@@ -16650,7 +17061,7 @@ function createTypeScriptAdapter(suppliedConfig) {
               ...projectHelpers.contributedRecognizers()
             ],
             access: collectAccessRecognizers(config.frameworks, tallies),
-            resolveWrittenValue: (value) => resolution.resolveWrittenValue(value),
+            resolution,
             resolveCallableSources: (value, alsoFrom) => resolution.resolveCallableSources(value, alsoFrom),
             sourceDeclarationsBehind: (declaration) => sourceDeclarationsBehind(declaration, resolution)
           },
@@ -17189,7 +17600,7 @@ function findNearestTsconfig(startDir) {
 
 // src/facts/why.ts
 import path12 from "path";
-import { Node as Node65, Project as Project3, SyntaxKind as SyntaxKind12 } from "ts-morph";
+import { Node as Node65, Project as Project3, SyntaxKind as SyntaxKind13 } from "ts-morph";
 import { explainResolutionProof, renderExplanation } from "@suss/resolution";
 var JS_PHRASES = {
   bind: ({ tuple, describe }) => ({
@@ -17236,7 +17647,7 @@ var TypeScriptWhySession = class {
       return null;
     }
     for (const call of sourceFile.getDescendantsOfKind(
-      SyntaxKind12.CallExpression
+      SyntaxKind13.CallExpression
     )) {
       const line = call.getStartLineNumber();
       if (line < startLine || line > endLine) {