@suss/adapter-typescript 0.22.1 → 0.22.3

package/dist/index.cjs

@@ -75,7 +75,7 @@ module.exports = __toCommonJS(index_exports);
 // src/adapter.ts
 var import_node_path10 = __toESM(require("path"), 1);
 var import_ts_morph66 = require("ts-morph");
-var import_behavioral_ir9 = require("@suss/behavioral-ir");
+var import_behavioral_ir8 = require("@suss/behavioral-ir");
 var import_datalog6 = require("@suss/datalog");
 var import_extractor11 = require("@suss/extractor");
 
@@ -712,14 +712,14 @@ function parseConditionExpression(expr, depth = 0) {
     if (expr.getOperatorToken() !== import_ts_morph5.SyntaxKind.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"
         }
       };
@@ -783,8 +783,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 (import_ts_morph5.Node.isTypeOfExpression(left) && import_ts_morph5.Node.isStringLiteral(right) && (opText === "===" || opText === "==")) {
@@ -2599,7 +2599,7 @@ function isNotYetPlaceholder(value) {
   return value.getKind() === import_ts_morph14.SyntaxKind.NullKeyword || import_ts_morph14.Node.isIdentifier(value) && value.getText() === "undefined";
 }
 function isConstruction(value) {
-  return import_ts_morph14.Node.isCallExpression(value) || import_ts_morph14.Node.isNewExpression(value);
+  return import_ts_morph14.Node.isCallExpression(value) || import_ts_morph14.Node.isNewExpression(value) || import_ts_morph14.Node.isObjectLiteralExpression(value) || import_ts_morph14.Node.isArrayLiteralExpression(value);
 }
 function sourceOf(node) {
   return node.getText().replace(/\s+/g, " ").trim();
@@ -3070,10 +3070,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 (import_ts_morph15.Node.isCallExpression(expression) || import_ts_morph15.Node.isNewExpression(expression)) {
@@ -3161,9 +3161,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;
 }
@@ -4368,7 +4368,7 @@ function declarationOf(value) {
 }
 
 // src/discovery/clientCall.ts
-var import_ts_morph19 = require("ts-morph");
+var import_ts_morph20 = require("ts-morph");
 
 // src/discovery/importScan.ts
 var import_node_path3 = __toESM(require("path"), 1);
@@ -4392,8 +4392,8 @@ function commonDirectoryOf(files) {
     }
     shared = shared.slice(0, i);
   }
-  const joined = shared.join(import_node_path2.default.sep);
-  return joined.length > 1 ? joined : void 0;
+  const joined2 = shared.join(import_node_path2.default.sep);
+  return joined2.length > 1 ? joined2 : void 0;
 }
 var DEFAULT_RESOLUTION = {
   moduleResolution: import_ts_morph17.ts.ModuleResolutionKind.Bundler,
@@ -4658,17 +4658,616 @@ function resolveImportedLocalName(sourceFile, importModule, importName) {
   }
   return null;
 }
+function importedReferenceSpellings(sourceFile, importModule, importName) {
+  const spellings = [];
+  const localName = resolveImportedLocalName(
+    sourceFile,
+    importModule,
+    importName
+  );
+  if (localName !== null) {
+    spellings.push(localName);
+  }
+  if (!sourceFile.getFullText().includes(`.${importName}`)) {
+    return spellings;
+  }
+  for (const root of importedRootsOf(sourceFile, [importModule])) {
+    if (root !== importName) {
+      spellings.push(`${root}.${importName}`);
+    }
+  }
+  return spellings;
+}
 
 // src/discovery/resolveValue.ts
+var import_ts_morph19 = require("ts-morph");
+var import_values3 = require("@suss/values");
+
+// src/values/evaluator.ts
+var import_values2 = require("@suss/values");
+
+// src/values/lowering.ts
 var import_ts_morph18 = require("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 || !import_ts_morph18.Node.isCallExpression(call) && !import_ts_morph18.Node.isNewExpression(call)) {
+        return null;
+      }
+      const target = resolution.resolveCallable(call.getExpression());
+      return target !== null && import_ts_morph18.Node.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 (import_ts_morph18.Node.isIdentifier(expr)) {
+    return expr.getText();
+  }
+  if (import_ts_morph18.Node.isPropertyAccessExpression(expr)) {
+    return expr.getName();
+  }
+  return "param";
+}
+function expressionOf(node, originOf) {
+  if (import_ts_morph18.Node.isStringLiteral(node) || import_ts_morph18.Node.isNoSubstitutionTemplateLiteral(node)) {
+    return { kind: "literal", value: node.getLiteralValue() };
+  }
+  if (import_ts_morph18.Node.isNumericLiteral(node)) {
+    return { kind: "literal", value: node.getLiteralValue() };
+  }
+  if (import_ts_morph18.Node.isTrueLiteral(node)) {
+    return { kind: "literal", value: true };
+  }
+  if (import_ts_morph18.Node.isFalseLiteral(node)) {
+    return { kind: "literal", value: false };
+  }
+  if (import_ts_morph18.Node.isNullLiteral(node)) {
+    return { kind: "literal", value: null };
+  }
+  if (import_ts_morph18.Node.isIdentifier(node)) {
+    return node.getText() === "undefined" ? { kind: "literal", value: void 0 } : { kind: "name", text: node.getText() };
+  }
+  if (import_ts_morph18.Node.isTemplateExpression(node)) {
+    return {
+      kind: "template",
+      parts: [
+        { text: node.getHead().getLiteralText() },
+        ...node.getTemplateSpans().flatMap((span) => [
+          { expression: span.getExpression() },
+          { text: span.getLiteral().getLiteralText() }
+        ])
+      ]
+    };
+  }
+  if (import_ts_morph18.Node.isPropertyAccessExpression(node)) {
+    return {
+      kind: "member",
+      object: node.getExpression(),
+      name: node.getName()
+    };
+  }
+  if (import_ts_morph18.Node.isElementAccessExpression(node)) {
+    const index = node.getArgumentExpression();
+    return index === void 0 ? { kind: "opaque" } : { kind: "element", object: node.getExpression(), index };
+  }
+  if (import_ts_morph18.Node.isArrayLiteralExpression(node)) {
+    return { kind: "array", items: node.getElements().map(elementOf) };
+  }
+  if (import_ts_morph18.Node.isObjectLiteralExpression(node)) {
+    return { kind: "record", fields: node.getProperties().flatMap(fieldOf) };
+  }
+  if (import_ts_morph18.Node.isCallExpression(node) || import_ts_morph18.Node.isNewExpression(node)) {
+    return {
+      kind: "call",
+      callee: calleeOf(node.getExpression(), originOf),
+      args: node.getArguments().map(elementOf),
+      constructs: import_ts_morph18.Node.isNewExpression(node)
+    };
+  }
+  if (import_ts_morph18.Node.isBinaryExpression(node)) {
+    const operator = node.getOperatorToken().getText();
+    return ASSIGNMENT_OPERATORS.has(operator) ? { kind: "opaque" } : {
+      kind: "operator",
+      operator,
+      operands: [node.getLeft(), node.getRight()]
+    };
+  }
+  if (import_ts_morph18.Node.isPrefixUnaryExpression(node)) {
+    const operator = node.getOperatorToken();
+    return operator === import_ts_morph18.SyntaxKind.ExclamationToken ? { kind: "operator", operator: "!", operands: [node.getOperand()] } : { kind: "opaque" };
+  }
+  if (import_ts_morph18.Node.isConditionalExpression(node)) {
+    return {
+      kind: "conditional",
+      condition: node.getCondition(),
+      whenTrue: node.getWhenTrue(),
+      whenFalse: node.getWhenFalse()
+    };
+  }
+  if (import_ts_morph18.Node.isArrowFunction(node) || import_ts_morph18.Node.isFunctionExpression(node)) {
+    return { kind: "function", node };
+  }
+  return { kind: "opaque" };
+}
+function elementOf(node) {
+  return import_ts_morph18.Node.isSpreadElement(node) ? { kind: "spread", node: node.getExpression() } : { kind: "value", node };
+}
+function fieldOf(property) {
+  if (import_ts_morph18.Node.isSpreadAssignment(property)) {
+    return [{ kind: "spread", node: property.getExpression() }];
+  }
+  if (import_ts_morph18.Node.isShorthandPropertyAssignment(property)) {
+    const nameNode2 = property.getNameNode();
+    return [{ kind: "field", name: nameNode2.getText(), value: nameNode2 }];
+  }
+  if (!import_ts_morph18.Node.isPropertyAssignment(property)) {
+    return [];
+  }
+  const value = property.getInitializer();
+  if (value === void 0) {
+    return [];
+  }
+  const nameNode = property.getNameNode();
+  if (import_ts_morph18.Node.isComputedPropertyName(nameNode)) {
+    return [{ kind: "computed", name: nameNode.getExpression(), value }];
+  }
+  const name = import_ts_morph18.Node.isStringLiteral(nameNode) || import_ts_morph18.Node.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
+  return [{ kind: "field", name, value }];
+}
+function calleeOf(expression, originOf) {
+  const callee = peelValue(expression);
+  if (import_ts_morph18.Node.isPropertyAccessExpression(callee)) {
+    return {
+      receiver: callee.getExpression(),
+      name: callee.getName(),
+      origin: () => originOf(callee)
+    };
+  }
+  if (import_ts_morph18.Node.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 (import_ts_morph18.Node.isPropertyAccessExpression(current2)) {
+    names.unshift(current2.getName());
+    current2 = peelValue(current2.getExpression());
+  }
+  if (!import_ts_morph18.Node.isIdentifier(current2)) {
+    return null;
+  }
+  return { root: current2, names: [current2.getText(), ...names] };
+}
+function statementOf2(node) {
+  if (import_ts_morph18.Node.isVariableStatement(node)) {
+    return {
+      kind: "declare",
+      bindings: node.getDeclarationList().getDeclarations().flatMap(
+        (declaration) => declarationsOf2(
+          declaration.getNameNode(),
+          declaration.getInitializer() ?? null
+        )
+      )
+    };
+  }
+  if (import_ts_morph18.Node.isExpressionStatement(node)) {
+    const expression = peelValue(node.getExpression());
+    if (import_ts_morph18.Node.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 (import_ts_morph18.Node.isIfStatement(node)) {
+    const otherwise = node.getElseStatement();
+    return {
+      kind: "branch",
+      condition: node.getExpression(),
+      arms: [
+        armOf(node.getThenStatement()),
+        otherwise === void 0 ? [] : armOf(otherwise)
+      ]
+    };
+  }
+  if (import_ts_morph18.Node.isSwitchStatement(node)) {
+    return {
+      kind: "branch",
+      condition: null,
+      arms: node.getClauses().map((clause) => clause.getStatements())
+    };
+  }
+  if (import_ts_morph18.Node.isIterationStatement(node)) {
+    return { kind: "loop", body: armOf(node.getStatement()) };
+  }
+  if (import_ts_morph18.Node.isReturnStatement(node)) {
+    return { kind: "return", value: node.getExpression() ?? null };
+  }
+  if (import_ts_morph18.Node.isBlock(node)) {
+    return { kind: "block", body: node.getStatements() };
+  }
+  if (import_ts_morph18.Node.isTryStatement(node)) {
+    return {
+      kind: "block",
+      body: [
+        ...node.getTryBlock().getStatements(),
+        ...node.getFinallyBlock()?.getStatements() ?? []
+      ]
+    };
+  }
+  return { kind: "opaque" };
+}
+function armOf(statement) {
+  return import_ts_morph18.Node.isBlock(statement) ? statement.getStatements() : [statement];
+}
+function declarationsOf2(nameNode, value) {
+  if (import_ts_morph18.Node.isIdentifier(nameNode)) {
+    return [{ name: nameNode.getText(), value }];
+  }
+  if (import_ts_morph18.Node.isObjectBindingPattern(nameNode) || import_ts_morph18.Node.isArrayBindingPattern(nameNode)) {
+    return nameNode.getElements().flatMap(
+      (element) => import_ts_morph18.Node.isBindingElement(element) ? declarationsOf2(element.getNameNode(), null) : []
+    );
+  }
+  return [];
+}
+function isRoot(node) {
+  return import_ts_morph18.Node.isSourceFile(node) || import_ts_morph18.Node.isFunctionLikeDeclaration(node);
+}
+function isStandaloneBlock(node) {
+  const parent = node.getParent();
+  return parent !== void 0 && (import_ts_morph18.Node.isBlock(parent) || import_ts_morph18.Node.isSourceFile(parent) || import_ts_morph18.Node.isModuleBlock(parent) || import_ts_morph18.Node.isCaseClause(parent) || import_ts_morph18.Node.isDefaultClause(parent));
+}
+function isPathStatement(node) {
+  if (import_ts_morph18.Node.isBlock(node)) {
+    return isStandaloneBlock(node);
+  }
+  return import_ts_morph18.Node.isStatement(node) && !import_ts_morph18.Node.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 (import_ts_morph18.Node.isSourceFile(node)) {
+    return { parameters: [], body: node.getStatements() };
+  }
+  if (!import_ts_morph18.Node.isFunctionLikeDeclaration(node)) {
+    return null;
+  }
+  const parameters = node.getParameters().flatMap((parameter) => {
+    const nameNode = parameter.getNameNode();
+    return import_ts_morph18.Node.isIdentifier(nameNode) ? [
+      {
+        name: nameNode.getText(),
+        default: parameter.getInitializer() ?? null
+      }
+    ] : [];
+  });
+  const body = import_ts_morph18.Node.isBodied(node) ? node.getBody() : import_ts_morph18.Node.isBodyable(node) ? node.getBody() : void 0;
+  if (body === void 0) {
+    return { parameters, body: [] };
+  }
+  return import_ts_morph18.Node.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 (import_ts_morph18.Node.isBinaryExpression(node)) {
+    const target = peelValue(node.getLeft());
+    return ASSIGNMENT_OPERATORS.has(node.getOperatorToken().getText()) && import_ts_morph18.Node.isIdentifier(target) ? target.getText() : null;
+  }
+  if (import_ts_morph18.Node.isPostfixUnaryExpression(node) || import_ts_morph18.Node.isPrefixUnaryExpression(node)) {
+    const operand2 = peelValue(node.getOperand());
+    return import_ts_morph18.Node.isIdentifier(operand2) ? operand2.getText() : null;
+  }
+  if (import_ts_morph18.Node.isCallExpression(node)) {
+    const callee = peelValue(node.getExpression());
+    if (!import_ts_morph18.Node.isPropertyAccessExpression(callee)) {
+      return null;
+    }
+    const receiver = peelValue(callee.getExpression());
+    return MUTATING_METHODS.has(callee.getName()) && import_ts_morph18.Node.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 (!import_ts_morph18.Node.isIdentifier(descendant)) {
+      return;
+    }
+    const parent = descendant.getParent();
+    if (import_ts_morph18.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === descendant) {
+      return;
+    }
+    if (import_ts_morph18.Node.isVariableDeclaration(parent) || import_ts_morph18.Node.isParameterDeclaration(parent) || import_ts_morph18.Node.isBindingElement(parent) || import_ts_morph18.Node.isFunctionDeclaration(parent)) {
+      declared.add(descendant.getText());
+      return;
+    }
+    if (import_ts_morph18.Node.isPropertyAssignment(parent) && parent.getNameNode() === descendant) {
+      return;
+    }
+    read2.add(descendant.getText());
+  });
+  return [...read2].filter((name) => !declared.has(name));
+}
+
+// src/values/rows.ts
+var import_values = require("@suss/values");
+var PATH_MODULES = ["path", "node:path", "path/posix", "node:path/posix"];
+var operatorRows = [
+  {
+    kind: "operator",
+    operator: "+",
+    arity: 2,
+    apply: ([a, b]) => (0, import_values.plus)((0, import_values.operand)(a), (0, import_values.operand)(b))
+  },
+  {
+    kind: "operator",
+    operator: "===",
+    arity: 2,
+    apply: ([a, b]) => (0, import_values.equals)((0, import_values.operand)(a), (0, import_values.operand)(b))
+  },
+  {
+    kind: "operator",
+    operator: "==",
+    arity: 2,
+    apply: ([a, b]) => (0, import_values.equals)((0, import_values.operand)(a), (0, import_values.operand)(b))
+  },
+  {
+    kind: "operator",
+    operator: "!==",
+    arity: 2,
+    apply: ([a, b]) => (0, import_values.negated)((0, import_values.equals)((0, import_values.operand)(a), (0, import_values.operand)(b)))
+  },
+  {
+    kind: "operator",
+    operator: "!=",
+    arity: 2,
+    apply: ([a, b]) => (0, import_values.negated)((0, import_values.equals)((0, import_values.operand)(a), (0, import_values.operand)(b)))
+  },
+  {
+    kind: "operator",
+    operator: "!",
+    arity: 1,
+    apply: ([a]) => (0, import_values.negated)((0, import_values.operand)(a))
+  },
+  {
+    kind: "operator",
+    operator: "??",
+    arity: 2,
+    apply: ([a, b]) => (0, import_values.readableFallback)((0, import_values.operand)(a), (0, import_values.operand)(b), import_values.isPresent)
+  },
+  {
+    kind: "operator",
+    operator: "||",
+    arity: 2,
+    apply: ([a, b]) => (0, import_values.readableFallback)((0, import_values.operand)(a), (0, import_values.operand)(b), import_values.truthOf)
+  },
+  {
+    kind: "operator",
+    operator: "&&",
+    arity: 2,
+    apply: ([a, b]) => (0, import_values.fallback)((0, import_values.operand)(a), (0, import_values.operand)(b), (left) => {
+      const truth = (0, import_values.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: (0, import_values.concat)([(0, import_values.operand)(receiver)]) })
+  },
+  {
+    kind: "method",
+    method: "concat",
+    on: "string",
+    apply: ({ receiver, args }) => ({
+      result: (0, import_values.concat)([(0, import_values.operand)(receiver), ...args])
+    })
+  }
+];
+var sequenceRows = ["sequence", "unbounded"].flatMap((on) => [
+  {
+    kind: "method",
+    method: "push",
+    on,
+    apply: ({ receiver, args }) => ({
+      result: (0, import_values.constant)(0),
+      receiver: (0, import_values.appended)((0, import_values.operand)(receiver), args)
+    })
+  },
+  {
+    kind: "method",
+    method: "concat",
+    on,
+    apply: ({ receiver, args, contentOf }) => ({
+      result: args.reduce(
+        (sequence, other) => (0, import_values.extended)(sequence, contentOf(other)),
+        (0, import_values.operand)(receiver)
+      )
+    })
+  },
+  {
+    kind: "method",
+    method: "join",
+    on,
+    apply: ({ receiver, args }) => ({
+      result: (0, import_values.joined)((0, import_values.operand)(receiver), args[0])
+    })
+  }
+]);
+var calleeRows = [
+  {
+    kind: "callee",
+    origin: { module: "global", name: "String" },
+    apply: ({ args }) => ({ result: (0, import_values.concat)([(0, import_values.operand)(args[0])]) })
+  },
+  ...PATH_MODULES.map(
+    (module2) => ({
+      kind: "callee",
+      origin: { module: module2, name: "join" },
+      apply: ({ args }) => ({ result: (0, import_values.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 import_values2.Evaluator(
+      typescriptLowering(
+        resolution === void 0 ? { rows: typescriptRows } : { resolution, rows: typescriptRows }
+      )
+    );
+    evaluators.set(key, evaluator);
+  }
+  return evaluator;
+}
+function evaluatedValue(node, resolution) {
+  return (0, import_values2.force)(evaluatorFor(node, resolution).evaluate(node));
+}
+
+// src/discovery/resolveValue.ts
 function couldNameAValue(value) {
-  return import_ts_morph18.Node.isIdentifier(value) || import_ts_morph18.Node.isPropertyAccessExpression(value) || import_ts_morph18.Node.isElementAccessExpression(value) || import_ts_morph18.Node.isCallExpression(value);
+  return import_ts_morph19.Node.isIdentifier(value) || import_ts_morph19.Node.isPropertyAccessExpression(value) || import_ts_morph19.Node.isElementAccessExpression(value) || import_ts_morph19.Node.isCallExpression(value);
 }
 function propertyValueOf(property) {
-  if (import_ts_morph18.Node.isPropertyAssignment(property)) {
+  if (import_ts_morph19.Node.isPropertyAssignment(property)) {
     return property.getInitializer() ?? null;
   }
-  if (import_ts_morph18.Node.isShorthandPropertyAssignment(property)) {
+  if (import_ts_morph19.Node.isShorthandPropertyAssignment(property)) {
     return property.getNameNode();
   }
   return null;
@@ -4689,7 +5288,7 @@ function objectLiteralOf(value, resolution) {
   return literalValueOf(
     value,
     resolution,
-    (node) => import_ts_morph18.Node.isObjectLiteralExpression(node)
+    (node) => import_ts_morph19.Node.isObjectLiteralExpression(node)
   );
 }
 function propertiesOf(object, resolution) {
@@ -4701,7 +5300,7 @@ function propertiesReached(object, resolution, seen) {
   }
   seen.add(object);
   return object.getProperties().flatMap((property) => {
-    if (!import_ts_morph18.Node.isSpreadAssignment(property)) {
+    if (!import_ts_morph19.Node.isSpreadAssignment(property)) {
       return [property];
     }
     const spread = objectLiteralOf(property.getExpression(), resolution);
@@ -4710,17 +5309,17 @@ function propertiesReached(object, resolution, seen) {
 }
 function writtenNodeOf(value, resolution) {
   const written = factKeyOf(value);
-  if (import_ts_morph18.Node.isNewExpression(written)) {
+  if (import_ts_morph19.Node.isNewExpression(written)) {
     return written;
   }
-  if (import_ts_morph18.Node.isCallExpression(written)) {
+  if (import_ts_morph19.Node.isCallExpression(written)) {
     return writtenThroughCall(written, resolution);
   }
   if (resolution === void 0 || !couldNameAValue(written)) {
     return null;
   }
   const resolved = resolution.resolveWrittenValue(written);
-  return resolved !== null && import_ts_morph18.Node.isCallExpression(resolved) ? writtenThroughCall(resolved, resolution) : resolved;
+  return resolved !== null && import_ts_morph19.Node.isCallExpression(resolved) ? writtenThroughCall(resolved, resolution) : resolved;
 }
 function writtenThroughCall(call, resolution) {
   if (resolution !== void 0 && resolution.resolveCallable(call.getExpression()) !== null) {
@@ -4732,24 +5331,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 (0, import_values3.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 import_ts_morph18.Node.isStringLiteral(node) || import_ts_morph18.Node.isNoSubstitutionTemplateLiteral(node);
+  const field = record2.fields.get(name);
+  return field === void 0 ? null : (0, import_values3.literalOf)((0, import_values3.force)(field.value));
 }
 function arrayLiteralOf(value, resolution) {
   return literalValueOf(
     value,
     resolution,
-    (node) => import_ts_morph18.Node.isArrayLiteralExpression(node)
+    (node) => import_ts_morph19.Node.isArrayLiteralExpression(node)
   );
 }
 function literalValueOf(value, resolution, isWanted) {
@@ -4772,26 +5368,26 @@ function discoverClientCalls(sourceFile, match, kind, resolution) {
   if (!isGlobal) {
     for (const varDecl of sourceFile.getVariableDeclarations()) {
       const init = varDecl.getInitializer();
-      if (init !== void 0 && (import_ts_morph19.Node.isCallExpression(init) || import_ts_morph19.Node.isNewExpression(init)) && isCreationCall(init, match, resolution)) {
+      if (init !== void 0 && (import_ts_morph20.Node.isCallExpression(init) || import_ts_morph20.Node.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 (!import_ts_morph19.Node.isCallExpression(node)) {
+    if (!import_ts_morph20.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
     let methodName = null;
     let matched = false;
-    if (isGlobal && import_ts_morph19.Node.isIdentifier(callee)) {
+    if (isGlobal && import_ts_morph20.Node.isIdentifier(callee)) {
       if (callee.getText() === match.importName) {
         matched = true;
       }
-    } else if (import_ts_morph19.Node.isPropertyAccessExpression(callee)) {
+    } else if (import_ts_morph20.Node.isPropertyAccessExpression(callee)) {
       const subject = callee.getExpression();
-      if (import_ts_morph19.Node.isIdentifier(subject) && (isClientImport(subject, match, resolution, true) || clientVarNames.has(subject.getText())) || resolvesToKnownInstance(subject, match, resolution)) {
+      if (import_ts_morph20.Node.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;
@@ -4825,16 +5421,16 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
   );
   const constructedHere = /* @__PURE__ */ new Set();
   sourceFile.forEachDescendant((node) => {
-    if (import_ts_morph19.Node.isVariableDeclaration(node)) {
+    if (import_ts_morph20.Node.isVariableDeclaration(node)) {
       const init = node.getInitializer();
-      if (init !== void 0 && (import_ts_morph19.Node.isCallExpression(init) || import_ts_morph19.Node.isNewExpression(init)) && isCreationCall(init, match, resolution) || localName !== null && typedAsClient(node.getTypeNode(), localName)) {
+      if (init !== void 0 && (import_ts_morph20.Node.isCallExpression(init) || import_ts_morph20.Node.isNewExpression(init)) && isCreationCall(init, match, resolution) || localName !== null && typedAsClient(node.getTypeNode(), localName)) {
         constructedHere.add(node.getName());
       }
       return;
     }
-    if (import_ts_morph19.Node.isParameterDeclaration(node) && localName !== null && typedAsClient(node.getTypeNode(), localName)) {
+    if (import_ts_morph20.Node.isParameterDeclaration(node) && localName !== null && typedAsClient(node.getTypeNode(), localName)) {
       const written = node.getNameNode();
-      if (import_ts_morph19.Node.isIdentifier(written)) {
+      if (import_ts_morph20.Node.isIdentifier(written)) {
         constructedHere.add(written.getText());
       }
     }
@@ -4845,10 +5441,10 @@ function clientReceiverCheckFor(sourceFile, match, resolution) {
     importName: match.importName,
     ...match.factoryMethods === void 0 ? {} : { factoryMethods: match.factoryMethods }
   };
-  return (subject) => isClientImport(subject, match, resolution, true) || import_ts_morph19.Node.isIdentifier(subject) && constructedHere.has(subject.getText()) || resolvesToKnownInstance(subject, full, resolution);
+  return (subject) => isClientImport(subject, match, resolution, true) || import_ts_morph20.Node.isIdentifier(subject) && constructedHere.has(subject.getText()) || resolvesToKnownInstance(subject, full, resolution);
 }
 function typedAsClient(typeNode, localName) {
-  if (typeNode === void 0 || !import_ts_morph19.Node.isTypeReference(typeNode)) {
+  if (typeNode === void 0 || !import_ts_morph20.Node.isTypeReference(typeNode)) {
     return false;
   }
   return typeNode.getTypeName().getText() === localName;
@@ -4858,27 +5454,27 @@ function resolvesToKnownInstance(subject, match, resolution) {
     return false;
   }
   const written = writtenNodeOf(subject, resolution);
-  if (written === null || !import_ts_morph19.Node.isCallExpression(written) && !import_ts_morph19.Node.isNewExpression(written)) {
+  if (written === null || !import_ts_morph20.Node.isCallExpression(written) && !import_ts_morph20.Node.isNewExpression(written)) {
     return false;
   }
   return isCreationCall(written, match, resolution);
 }
 function isCreationCall(call, match, resolution) {
   const callee = call.getExpression();
-  if (import_ts_morph19.Node.isIdentifier(callee)) {
+  if (import_ts_morph20.Node.isIdentifier(callee)) {
     return isClientImport(callee, match, resolution, false);
   }
-  if (!import_ts_morph19.Node.isPropertyAccessExpression(callee)) {
+  if (!import_ts_morph20.Node.isPropertyAccessExpression(callee)) {
     return false;
   }
   const base = callee.getExpression();
-  return import_ts_morph19.Node.isIdentifier(base) && (match.factoryMethods?.includes(callee.getName()) ?? false) && isClientImport(base, match, resolution, false);
+  return import_ts_morph20.Node.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 (!import_ts_morph19.Node.isIdentifier(subject)) {
+  if (!import_ts_morph20.Node.isIdentifier(subject)) {
     return false;
   }
   if (resolution === void 0) {
@@ -4926,27 +5522,27 @@ function resolvedImportLocalName(sourceFile, importModule, importName, strictDef
   return null;
 }
 function clientUnitName(enclosingFunc, methodName) {
-  if (import_ts_morph19.Node.isFunctionDeclaration(enclosingFunc)) {
+  if (import_ts_morph20.Node.isFunctionDeclaration(enclosingFunc)) {
     return enclosingFunc.getName() ?? methodName ?? "anonymous";
   }
-  if (import_ts_morph19.Node.isMethodDeclaration(enclosingFunc)) {
+  if (import_ts_morph20.Node.isMethodDeclaration(enclosingFunc)) {
     return enclosingFunc.getName();
   }
   const parent = enclosingFunc.getParent();
-  if (parent !== void 0 && import_ts_morph19.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph20.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
-  if (parent !== void 0 && import_ts_morph19.Node.isPropertyAssignment(parent)) {
+  if (parent !== void 0 && import_ts_morph20.Node.isPropertyAssignment(parent)) {
     return parent.getName();
   }
   return methodName ?? "anonymous";
 }
 
 // src/discovery/decoratedMethod.ts
-var import_ts_morph22 = require("ts-morph");
+var import_ts_morph23 = require("ts-morph");
 
 // src/discovery/decoratedMembers.ts
-var import_ts_morph20 = require("ts-morph");
+var import_ts_morph21 = require("ts-morph");
 function importedDecoratorLocals(sourceFile, acceptedModules, canonicalNames) {
   const localToCanonical = /* @__PURE__ */ new Map();
   for (const importDecl of sourceFile.getImportDeclarations()) {
@@ -4966,7 +5562,7 @@ function importedDecoratorLocals(sourceFile, acceptedModules, canonicalNames) {
 function decoratedCallablesOf(cls, decoratorNames) {
   const callables = [];
   for (const member of cls.getMembers()) {
-    if (!import_ts_morph20.Node.isMethodDeclaration(member) && !import_ts_morph20.Node.isPropertyDeclaration(member)) {
+    if (!import_ts_morph21.Node.isMethodDeclaration(member) && !import_ts_morph21.Node.isPropertyDeclaration(member)) {
       continue;
     }
     const func = callableOf(member);
@@ -4990,7 +5586,7 @@ function decoratedCallablesOf(cls, decoratorNames) {
   return callables;
 }
 function callableOf(member) {
-  if (import_ts_morph20.Node.isMethodDeclaration(member)) {
+  if (import_ts_morph21.Node.isMethodDeclaration(member)) {
     return toFunctionRoot(member);
   }
   const held = member.getInitializer();
@@ -4998,7 +5594,7 @@ function callableOf(member) {
 }
 
 // src/discovery/decoratorComposition.ts
-var import_ts_morph21 = require("ts-morph");
+var import_ts_morph22 = require("ts-morph");
 function classDecoratorStandingFor(cls, names, modules, resolution) {
   for (const candidate of names) {
     const decorator = cls.getDecorator(candidate);
@@ -5014,7 +5610,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;
@@ -5032,11 +5628,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(import_ts_morph21.SyntaxKind.CallExpression)) {
+  for (const call of wrapper.getDescendantsOfKind(import_ts_morph22.SyntaxKind.CallExpression)) {
     const names = resolution.importedNamesOf(call.getExpression(), modules);
     if (!names.includes(standsFor)) {
       continue;
@@ -5047,17 +5643,17 @@ function frameworkArgs(decorator, standsFor, modules, resolution) {
   return atClass;
 }
 function statesAValue(arg, wrapper) {
-  const identifiers = import_ts_morph21.Node.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(import_ts_morph21.SyntaxKind.Identifier);
+  const identifiers = import_ts_morph22.Node.isIdentifier(arg) ? [arg] : arg.getDescendantsOfKind(import_ts_morph22.SyntaxKind.Identifier);
   return !identifiers.some(
     (identifier) => identifier.getSymbol()?.getDeclarations().some(
-      (declaration) => import_ts_morph21.Node.isParameterDeclaration(declaration) && isWithin(declaration, wrapper)
+      (declaration) => import_ts_morph22.Node.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();
@@ -5070,39 +5666,39 @@ function resolverTypeName(args) {
   return args.typeMap[args.decoratorName] ?? args.classTypeName ?? null;
 }
 function resolveResolverClassTypeName(decoratorArg) {
-  if (import_ts_morph22.Node.isArrowFunction(decoratorArg)) {
+  if (import_ts_morph23.Node.isArrowFunction(decoratorArg)) {
     const body = decoratorArg.getBody();
-    if (import_ts_morph22.Node.isIdentifier(body)) {
+    if (import_ts_morph23.Node.isIdentifier(body)) {
       return body.getText();
     }
     return null;
   }
-  if (import_ts_morph22.Node.isStringLiteral(decoratorArg)) {
+  if (import_ts_morph23.Node.isStringLiteral(decoratorArg)) {
     return decoratorArg.getLiteralValue();
   }
-  if (import_ts_morph22.Node.isIdentifier(decoratorArg)) {
+  if (import_ts_morph23.Node.isIdentifier(decoratorArg)) {
     return decoratorArg.getText();
   }
   return null;
 }
 function resolveOperationNameOverride(decorator) {
-  if (!import_ts_morph22.Node.isDecorator(decorator)) {
+  if (!import_ts_morph23.Node.isDecorator(decorator)) {
     return null;
   }
   const args = decorator.getArguments();
   for (const arg of args) {
-    if (!import_ts_morph22.Node.isObjectLiteralExpression(arg)) {
+    if (!import_ts_morph23.Node.isObjectLiteralExpression(arg)) {
       continue;
     }
     const prop = arg.getProperty("name");
-    if (prop === void 0 || !import_ts_morph22.Node.isPropertyAssignment(prop)) {
+    if (prop === void 0 || !import_ts_morph23.Node.isPropertyAssignment(prop)) {
       continue;
     }
     const init = prop.getInitializer();
     if (init === void 0) {
       continue;
     }
-    if (import_ts_morph22.Node.isStringLiteral(init) || import_ts_morph22.Node.isNoSubstitutionTemplateLiteral(init)) {
+    if (import_ts_morph23.Node.isStringLiteral(init) || import_ts_morph23.Node.isNoSubstitutionTemplateLiteral(init)) {
       return init.getLiteralValue();
     }
   }
@@ -5155,9 +5751,9 @@ function discoverDecoratedMethods(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/decoratedRoute.ts
-var import_ts_morph23 = require("ts-morph");
+var import_ts_morph24 = require("ts-morph");
 function resolveRoutePathArg(decorator, resolution) {
-  if (!import_ts_morph23.Node.isDecorator(decorator)) {
+  if (!import_ts_morph24.Node.isDecorator(decorator)) {
     return "";
   }
   return routePathOf(decorator.getArguments(), resolution);
@@ -5185,7 +5781,7 @@ function declaredChannelOf(source, decorator, resolution) {
   if (source.from === "unstated") {
     return null;
   }
-  if (!import_ts_morph23.Node.isDecorator(decorator)) {
+  if (!import_ts_morph24.Node.isDecorator(decorator)) {
     return null;
   }
   const arg = decorator.getArguments()[source.position];
@@ -5196,7 +5792,7 @@ function declaredChannelOf(source, decorator, resolution) {
   return text === null || text === "" ? null : text;
 }
 function literalStringOf(node, resolution) {
-  if (import_ts_morph23.Node.isStringLiteral(node) || import_ts_morph23.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph24.Node.isStringLiteral(node) || import_ts_morph24.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
   const written = resolution?.resolveWrittenValue(node) ?? null;
@@ -5266,31 +5862,31 @@ function discoverDecoratedRoutes(sourceFile, match, kind, resolution, binding) {
 var import_picomatch = __toESM(require("picomatch"), 1);
 
 // src/discovery/namedExport.ts
-var import_ts_morph24 = require("ts-morph");
+var import_ts_morph25 = require("ts-morph");
 function nameWrittenAt(expression) {
-  if (import_ts_morph24.Node.isIdentifier(expression)) {
+  if (import_ts_morph25.Node.isIdentifier(expression)) {
     return expression.getText();
   }
-  if (import_ts_morph24.Node.isPropertyAccessExpression(expression)) {
+  if (import_ts_morph25.Node.isPropertyAccessExpression(expression)) {
     return expression.getName();
   }
   return null;
 }
 function resolveDefaultExportName(decl, fn) {
-  if (import_ts_morph24.Node.isFunctionDeclaration(fn) || import_ts_morph24.Node.isFunctionExpression(fn)) {
+  if (import_ts_morph25.Node.isFunctionDeclaration(fn) || import_ts_morph25.Node.isFunctionExpression(fn)) {
     const n = fn.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph24.Node.isVariableDeclaration(decl)) {
+  if (import_ts_morph25.Node.isVariableDeclaration(decl)) {
     const name = decl.getName();
     if (name.length > 0) {
       return name;
     }
   }
   const binding = fn.getParent();
-  if (binding !== void 0 && import_ts_morph24.Node.isVariableDeclaration(binding)) {
+  if (binding !== void 0 && import_ts_morph25.Node.isVariableDeclaration(binding)) {
     const name = binding.getName();
     if (name.length > 0) {
       return name;
@@ -5345,7 +5941,7 @@ function discoverNamedExports(sourceFile, match, kind, resolution) {
       }
       continue;
     }
-    if (import_ts_morph24.Node.isArrowFunction(init) || import_ts_morph24.Node.isFunctionExpression(init)) {
+    if (import_ts_morph25.Node.isArrowFunction(init) || import_ts_morph25.Node.isFunctionExpression(init)) {
       results.push({
         func: init,
         kind,
@@ -5454,13 +6050,13 @@ function discoverFileConventions(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/graphqlHookCall.ts
-var import_ts_morph27 = require("ts-morph");
+var import_ts_morph28 = require("ts-morph");
 
 // src/discovery/graphqlShared.ts
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
 var import_graphql = require("graphql");
-var import_ts_morph25 = require("ts-morph");
+var import_ts_morph26 = require("ts-morph");
 var DOCUMENT_TAGS = /* @__PURE__ */ new Set(["gql", "graphql"]);
 var UNQUALIFIED_DOCUMENT_TAG = "gql";
 function parseGraphqlOperation(source) {
@@ -5526,10 +6122,10 @@ function startAssembly(resolution) {
   };
 }
 function assembledTemplateText(template, assembly) {
-  if (import_ts_morph25.Node.isNoSubstitutionTemplateLiteral(template)) {
+  if (import_ts_morph26.Node.isNoSubstitutionTemplateLiteral(template)) {
     return innerTemplateText(template);
   }
-  if (!import_ts_morph25.Node.isTemplateExpression(template)) {
+  if (!import_ts_morph26.Node.isTemplateExpression(template)) {
     return null;
   }
   let text = template.getHead().getLiteralText();
@@ -5665,7 +6261,7 @@ function collectDanglingSpreads(selectionSet, defined, dangling) {
   }
 }
 function documentTextFromExpression(node, assembly) {
-  if (import_ts_morph25.Node.isTaggedTemplateExpression(node)) {
+  if (import_ts_morph26.Node.isTaggedTemplateExpression(node)) {
     if (!isDocumentTag(node.getTag())) {
       return null;
     }
@@ -5675,7 +6271,7 @@ function documentTextFromExpression(node, assembly) {
     assembly.seen.add(node);
     return assembledTemplateText(node.getTemplate(), assembly);
   }
-  if (!import_ts_morph25.Node.isCallExpression(node)) {
+  if (!import_ts_morph26.Node.isCallExpression(node)) {
     return null;
   }
   if (!isDocumentTag(node.getExpression())) {
@@ -5686,7 +6282,7 @@ function documentTextFromExpression(node, assembly) {
     return null;
   }
   const template = stripDocumentNodeCasts(first);
-  if (!import_ts_morph25.Node.isNoSubstitutionTemplateLiteral(template) && !import_ts_morph25.Node.isTemplateExpression(template)) {
+  if (!import_ts_morph26.Node.isNoSubstitutionTemplateLiteral(template) && !import_ts_morph26.Node.isTemplateExpression(template)) {
     return null;
   }
   if (assembly.seen.has(node)) {
@@ -5696,7 +6292,7 @@ function documentTextFromExpression(node, assembly) {
   return assembledTemplateText(template, assembly);
 }
 function isDocumentTag(tag) {
-  if (!import_ts_morph25.Node.isIdentifier(tag)) {
+  if (!import_ts_morph26.Node.isIdentifier(tag)) {
     return false;
   }
   if (tag.getText() === UNQUALIFIED_DOCUMENT_TAG) {
@@ -5707,14 +6303,14 @@ function isDocumentTag(tag) {
     return false;
   }
   for (const declaration of symbol.getDeclarations()) {
-    if (import_ts_morph25.Node.isImportSpecifier(declaration) && DOCUMENT_TAGS.has(declaration.getName())) {
+    if (import_ts_morph26.Node.isImportSpecifier(declaration) && DOCUMENT_TAGS.has(declaration.getName())) {
       return true;
     }
   }
   return false;
 }
 function resolveThroughFacts(arg, assembly) {
-  if (assembly.resolution === void 0 || !import_ts_morph25.Node.isIdentifier(arg)) {
+  if (assembly.resolution === void 0 || !import_ts_morph26.Node.isIdentifier(arg)) {
     return null;
   }
   const written = assembly.resolution.resolveWrittenValue(arg);
@@ -5763,7 +6359,7 @@ function singleLine(text) {
   return collapsed.length > 80 ? `${collapsed.slice(0, 79)}\u2026` : collapsed;
 }
 function importedVariableInitializers(identifier) {
-  if (!import_ts_morph25.Node.isIdentifier(identifier)) {
+  if (!import_ts_morph26.Node.isIdentifier(identifier)) {
     return [];
   }
   const symbol = identifier.getSymbol();
@@ -5773,7 +6369,7 @@ function importedVariableInitializers(identifier) {
   const resolved = resolveAliasedSymbol(symbol) ?? symbol;
   const inits = [];
   for (const decl of resolved.getDeclarations()) {
-    if (import_ts_morph25.Node.isVariableDeclaration(decl)) {
+    if (import_ts_morph26.Node.isVariableDeclaration(decl)) {
       const init = decl.getInitializer();
       if (init !== void 0) {
         inits.push(init);
@@ -5787,7 +6383,7 @@ function resolveGqlTemplateText(arg, assembly) {
   if (direct !== null) {
     return direct;
   }
-  if (!import_ts_morph25.Node.isIdentifier(arg)) {
+  if (!import_ts_morph26.Node.isIdentifier(arg)) {
     return null;
   }
   const symbol = arg.getSymbol();
@@ -5795,7 +6391,7 @@ function resolveGqlTemplateText(arg, assembly) {
     return null;
   }
   for (const decl of symbol.getDeclarations()) {
-    if (import_ts_morph25.Node.isImportClause(decl) || import_ts_morph25.Node.isImportSpecifier(decl)) {
+    if (import_ts_morph26.Node.isImportClause(decl) || import_ts_morph26.Node.isImportSpecifier(decl)) {
       const fromGraphqlFile = resolveGraphqlFileImport(decl);
       if (fromGraphqlFile !== null) {
         return fromGraphqlFile;
@@ -5814,7 +6410,7 @@ function resolveGqlTemplateText(arg, assembly) {
   return null;
 }
 function resolveTypedDocumentSource(arg) {
-  if (!import_ts_morph25.Node.isIdentifier(arg)) {
+  if (!import_ts_morph26.Node.isIdentifier(arg)) {
     return null;
   }
   for (const init of importedVariableInitializers(arg)) {
@@ -5827,7 +6423,7 @@ function resolveTypedDocumentSource(arg) {
 }
 function typedDocumentSourceOf(node) {
   const inner = stripDocumentNodeCasts(node);
-  if (!import_ts_morph25.Node.isObjectLiteralExpression(inner)) {
+  if (!import_ts_morph26.Node.isObjectLiteralExpression(inner)) {
     return null;
   }
   const evaluated = evaluateObjectLiteralAsJson(inner);
@@ -5845,7 +6441,7 @@ function typedDocumentSourceOf(node) {
   }
 }
 function resolveTypedDocumentHeader(arg) {
-  if (!import_ts_morph25.Node.isIdentifier(arg)) {
+  if (!import_ts_morph26.Node.isIdentifier(arg)) {
     return null;
   }
   const reference = arg.getText();
@@ -5855,7 +6451,7 @@ function resolveTypedDocumentHeader(arg) {
   }
   const resolved = resolveAliasedSymbol(symbol) ?? symbol;
   for (const decl of resolved.getDeclarations()) {
-    if (!import_ts_morph25.Node.isVariableDeclaration(decl)) {
+    if (!import_ts_morph26.Node.isVariableDeclaration(decl)) {
       continue;
     }
     const init = decl.getInitializer();
@@ -5888,10 +6484,10 @@ function resolveTypedDocumentHeader(arg) {
 }
 function documentNodeCastTypeArgs(node) {
   let current2 = node;
-  while (import_ts_morph25.Node.isAsExpression(current2) || import_ts_morph25.Node.isParenthesizedExpression(current2)) {
-    if (import_ts_morph25.Node.isAsExpression(current2)) {
+  while (import_ts_morph26.Node.isAsExpression(current2) || import_ts_morph26.Node.isParenthesizedExpression(current2)) {
+    if (import_ts_morph26.Node.isAsExpression(current2)) {
       const typeNode = current2.getTypeNode();
-      if (typeNode !== void 0 && import_ts_morph25.Node.isTypeReference(typeNode)) {
+      if (typeNode !== void 0 && import_ts_morph26.Node.isTypeReference(typeNode)) {
         const name = typeNode.getTypeName().getText();
         const simpleName = name.includes(".") ? name.split(".").pop() ?? name : name;
         if (simpleName === "TypedDocumentNode" || simpleName === "DocumentNode") {
@@ -5904,7 +6500,7 @@ function documentNodeCastTypeArgs(node) {
   return null;
 }
 function operationHeaderFromResultType(typeNode) {
-  if (typeNode === void 0 || !import_ts_morph25.Node.isTypeReference(typeNode)) {
+  if (typeNode === void 0 || !import_ts_morph26.Node.isTypeReference(typeNode)) {
     return null;
   }
   const name = typeNode.getTypeName().getText();
@@ -5925,16 +6521,16 @@ function operationHeaderFromResultType(typeNode) {
 }
 function stripDocumentNodeCasts(node) {
   let current2 = node;
-  while (import_ts_morph25.Node.isAsExpression(current2) || import_ts_morph25.Node.isParenthesizedExpression(current2)) {
+  while (import_ts_morph26.Node.isAsExpression(current2) || import_ts_morph26.Node.isParenthesizedExpression(current2)) {
     current2 = current2.getExpression();
   }
   return current2;
 }
 function evaluateObjectLiteralAsJson(node) {
-  if (import_ts_morph25.Node.isStringLiteral(node) || import_ts_morph25.Node.isNoSubstitutionTemplateLiteral(node)) {
+  if (import_ts_morph26.Node.isStringLiteral(node) || import_ts_morph26.Node.isNoSubstitutionTemplateLiteral(node)) {
     return node.getLiteralValue();
   }
-  if (import_ts_morph25.Node.isNumericLiteral(node)) {
+  if (import_ts_morph26.Node.isNumericLiteral(node)) {
     return Number(node.getText());
   }
   const kind = node.getText();
@@ -5947,17 +6543,17 @@ function evaluateObjectLiteralAsJson(node) {
   if (kind === "null") {
     return null;
   }
-  if (import_ts_morph25.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph26.Node.isObjectLiteralExpression(node)) {
     const out = {};
     for (const prop of node.getProperties()) {
-      if (!import_ts_morph25.Node.isPropertyAssignment(prop)) {
+      if (!import_ts_morph26.Node.isPropertyAssignment(prop)) {
         return null;
       }
       const nameNode = prop.getNameNode();
       let name;
-      if (import_ts_morph25.Node.isIdentifier(nameNode)) {
+      if (import_ts_morph26.Node.isIdentifier(nameNode)) {
         name = nameNode.getText();
-      } else if (import_ts_morph25.Node.isStringLiteral(nameNode) || import_ts_morph25.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
+      } else if (import_ts_morph26.Node.isStringLiteral(nameNode) || import_ts_morph26.Node.isNoSubstitutionTemplateLiteral(nameNode)) {
         name = nameNode.getLiteralValue();
       } else {
         return null;
@@ -5974,7 +6570,7 @@ function evaluateObjectLiteralAsJson(node) {
     }
     return out;
   }
-  if (import_ts_morph25.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph26.Node.isArrayLiteralExpression(node)) {
     const out = [];
     for (const el of node.getElements()) {
       const value = evaluateObjectLiteralAsJson(el);
@@ -5988,8 +6584,8 @@ function evaluateObjectLiteralAsJson(node) {
   return void 0;
 }
 function resolveGraphqlFileImport(decl) {
-  const importDecl = import_ts_morph25.Node.isImportSpecifier(decl) ? decl.getImportDeclaration() : import_ts_morph25.Node.isImportClause(decl) ? decl.getParent() : null;
-  if (importDecl === null || importDecl === void 0 || !import_ts_morph25.Node.isImportDeclaration(importDecl)) {
+  const importDecl = import_ts_morph26.Node.isImportSpecifier(decl) ? decl.getImportDeclaration() : import_ts_morph26.Node.isImportClause(decl) ? decl.getParent() : null;
+  if (importDecl === null || importDecl === void 0 || !import_ts_morph26.Node.isImportDeclaration(importDecl)) {
     return null;
   }
   const specifier = importDecl.getModuleSpecifierValue();
@@ -6008,7 +6604,7 @@ function resolveGraphqlFileImport(decl) {
 function enclosingFunctionRoot(node) {
   let current2 = node.getParent();
   while (current2 !== void 0) {
-    if (import_ts_morph25.Node.isFunctionDeclaration(current2) || import_ts_morph25.Node.isFunctionExpression(current2) || import_ts_morph25.Node.isArrowFunction(current2) || import_ts_morph25.Node.isMethodDeclaration(current2)) {
+    if (import_ts_morph26.Node.isFunctionDeclaration(current2) || import_ts_morph26.Node.isFunctionExpression(current2) || import_ts_morph26.Node.isArrowFunction(current2) || import_ts_morph26.Node.isMethodDeclaration(current2)) {
       return current2;
     }
     current2 = current2.getParent();
@@ -6016,18 +6612,18 @@ function enclosingFunctionRoot(node) {
   return null;
 }
 function functionNameOrAnon(func) {
-  if (import_ts_morph25.Node.isFunctionDeclaration(func) || import_ts_morph25.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph26.Node.isFunctionDeclaration(func) || import_ts_morph26.Node.isMethodDeclaration(func)) {
     return func.getName() ?? "<anon>";
   }
   const parent = func.getParent();
-  if (parent !== void 0 && import_ts_morph25.Node.isVariableDeclaration(parent)) {
+  if (parent !== void 0 && import_ts_morph26.Node.isVariableDeclaration(parent)) {
     return parent.getName();
   }
   return "<anon>";
 }
 
 // src/discovery/importedCalls.ts
-var import_ts_morph26 = require("ts-morph");
+var import_ts_morph27 = require("ts-morph");
 function callsResolvingTo(sourceFile, resolution, spec) {
   return [
     ...callsByOriginName(
@@ -6041,11 +6637,11 @@ function callsResolvingTo(sourceFile, resolution, spec) {
 function callsByOriginName(sourceFile, resolution, module2, names) {
   const candidates = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph26.Node.isCallExpression(node) && !import_ts_morph26.Node.isNewExpression(node)) {
+    if (!import_ts_morph27.Node.isCallExpression(node) && !import_ts_morph27.Node.isNewExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (import_ts_morph26.Node.isIdentifier(callee) && !declaredLocally(callee)) {
+    if (import_ts_morph27.Node.isIdentifier(callee) && !declaredLocally(callee)) {
       candidates.push(node);
     }
   });
@@ -6071,7 +6667,7 @@ function callsByOriginName(sourceFile, resolution, module2, names) {
 function declaredLocally(callee) {
   const declarations = callee.getSymbol()?.getDeclarations() ?? [];
   return declarations.length > 0 && declarations.every(
-    (declaration) => (import_ts_morph26.Node.isFunctionDeclaration(declaration) || import_ts_morph26.Node.isClassDeclaration(declaration)) && !declaration.getSourceFile().isInNodeModules()
+    (declaration) => (import_ts_morph27.Node.isFunctionDeclaration(declaration) || import_ts_morph27.Node.isClassDeclaration(declaration)) && !declaration.getSourceFile().isInNodeModules()
   );
 }
 
@@ -6089,7 +6685,7 @@ function discoverGraphqlHookCalls(sourceFile, match, kind, resolution) {
   );
   const results = [];
   for (const [node, canonical] of hookCalls) {
-    if (!import_ts_morph27.Node.isCallExpression(node)) {
+    if (!import_ts_morph28.Node.isCallExpression(node)) {
       continue;
     }
     const operationType = operationTypeByHook.get(canonical);
@@ -6126,7 +6722,7 @@ function discoverGraphqlHookCalls(sourceFile, match, kind, resolution) {
 }
 
 // src/discovery/graphqlImperativeCall.ts
-var import_ts_morph28 = require("ts-morph");
+var import_ts_morph29 = require("ts-morph");
 function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   const isTheClient = clientReceiverCheckFor(sourceFile, match, resolution);
   const methodSpec = /* @__PURE__ */ new Map();
@@ -6138,11 +6734,11 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   }
   const results = [];
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph28.Node.isCallExpression(node)) {
+    if (!import_ts_morph29.Node.isCallExpression(node)) {
       return;
     }
     const callee = node.getExpression();
-    if (!import_ts_morph28.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph29.Node.isPropertyAccessExpression(callee)) {
       return;
     }
     const methodName = callee.getName();
@@ -6154,7 +6750,7 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
       return;
     }
     const args = node.getArguments();
-    if (args.length === 0 || !import_ts_morph28.Node.isObjectLiteralExpression(args[0])) {
+    if (args.length === 0 || !import_ts_morph29.Node.isObjectLiteralExpression(args[0])) {
       return;
     }
     const config = args[0];
@@ -6190,16 +6786,16 @@ function discoverGraphqlImperativeCalls(sourceFile, match, kind, resolution) {
   return results;
 }
 function imperativeConfigValue(prop) {
-  if (import_ts_morph28.Node.isPropertyAssignment(prop)) {
+  if (import_ts_morph29.Node.isPropertyAssignment(prop)) {
     return prop.getInitializer() ?? null;
   }
-  if (import_ts_morph28.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph29.Node.isShorthandPropertyAssignment(prop)) {
     const valueSymbol = prop.getValueSymbol();
     if (valueSymbol === void 0) {
       return null;
     }
     for (const decl of valueSymbol.getDeclarations()) {
-      if (import_ts_morph28.Node.isVariableDeclaration(decl)) {
+      if (import_ts_morph29.Node.isVariableDeclaration(decl)) {
         const init = decl.getInitializer();
         if (init !== void 0) {
           return init;
@@ -6212,7 +6808,7 @@ function imperativeConfigValue(prop) {
 }
 
 // src/discovery/jsxElementRoute.ts
-var import_ts_morph29 = require("ts-morph");
+var import_ts_morph30 = require("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";
@@ -6244,7 +6840,7 @@ function discoverJsxElementRoutes(sourceFile, match, kind, resolution) {
       }
       return;
     }
-    if (import_ts_morph29.Node.isCallExpression(node) && callsAFactory(node, factoryNames)) {
+    if (import_ts_morph30.Node.isCallExpression(node) && callsAFactory(node, factoryNames)) {
       results.push(
         ...unitsForRouteArray(node, match, elementsNames, kind, resolution)
       );
@@ -6266,7 +6862,7 @@ function localNamesFor(sourceFile, match, exported) {
   return local;
 }
 function asRouteJsx(node, routeNames) {
-  if (!import_ts_morph29.Node.isJsxSelfClosingElement(node) && !import_ts_morph29.Node.isJsxElement(node)) {
+  if (!import_ts_morph30.Node.isJsxSelfClosingElement(node) && !import_ts_morph30.Node.isJsxElement(node)) {
     return null;
   }
   return isRouteJsx(node, routeNames) ? node : null;
@@ -6276,15 +6872,15 @@ function isRouteJsx(node, routeNames) {
   return tag !== null && routeNames.has(tag.getText());
 }
 function tagNameOf(node) {
-  const tag = import_ts_morph29.Node.isJsxElement(node) ? node.getOpeningElement().getTagNameNode() : node.getTagNameNode();
-  return import_ts_morph29.Node.isIdentifier(tag) ? tag : null;
+  const tag = import_ts_morph30.Node.isJsxElement(node) ? node.getOpeningElement().getTagNameNode() : node.getTagNameNode();
+  return import_ts_morph30.Node.isIdentifier(tag) ? tag : null;
 }
 function attributesOf(node) {
-  return import_ts_morph29.Node.isJsxElement(node) ? node.getOpeningElement().getAttributes() : node.getAttributes();
+  return import_ts_morph30.Node.isJsxElement(node) ? node.getOpeningElement().getAttributes() : node.getAttributes();
 }
 function attributeValueOf(node, name) {
   for (const attribute of attributesOf(node)) {
-    if (!import_ts_morph29.Node.isJsxAttribute(attribute)) {
+    if (!import_ts_morph30.Node.isJsxAttribute(attribute)) {
       continue;
     }
     if (attribute.getNameNode().getText() !== name) {
@@ -6295,8 +6891,8 @@ function attributeValueOf(node, name) {
   return null;
 }
 function literalStringOf2(value) {
-  const unwrapped2 = import_ts_morph29.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (import_ts_morph29.Node.isStringLiteral(unwrapped2) || import_ts_morph29.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  const unwrapped2 = import_ts_morph30.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (import_ts_morph30.Node.isStringLiteral(unwrapped2) || import_ts_morph30.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return unwrapped2.getLiteralValue();
   }
   return null;
@@ -6316,8 +6912,8 @@ function elementTargetOfValue(value) {
   if (value === null) {
     return { kind: "absent" };
   }
-  const unwrapped2 = import_ts_morph29.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
-  if (!import_ts_morph29.Node.isJsxSelfClosingElement(unwrapped2) && !import_ts_morph29.Node.isJsxElement(unwrapped2)) {
+  const unwrapped2 = import_ts_morph30.Node.isJsxExpression(value) ? value.getExpression() ?? value : value;
+  if (!import_ts_morph30.Node.isJsxSelfClosingElement(unwrapped2) && !import_ts_morph30.Node.isJsxElement(unwrapped2)) {
     return { kind: "unreadable" };
   }
   const tag = tagNameOf(unwrapped2);
@@ -6329,7 +6925,7 @@ function elementTargetOfValue(value) {
 function composedPrefixOf(node, match, routeNames) {
   const enclosing = [];
   for (const ancestor of node.getAncestors()) {
-    if (import_ts_morph29.Node.isJsxElement(ancestor) && isRouteJsx(ancestor, routeNames)) {
+    if (import_ts_morph30.Node.isJsxElement(ancestor) && isRouteJsx(ancestor, routeNames)) {
       enclosing.push(ancestor);
     }
   }
@@ -6445,14 +7041,14 @@ function abstention(at, kind, sentence, label) {
 }
 function callsAFactory(call, factoryNames) {
   const callee = call.getExpression();
-  return import_ts_morph29.Node.isIdentifier(callee) && factoryNames.has(callee.getText());
+  return import_ts_morph30.Node.isIdentifier(callee) && factoryNames.has(callee.getText());
 }
 function unitsForRouteArray(call, match, elementsNames, kind, resolution) {
   const first = call.getArguments()[0];
   if (first === void 0) {
     return [];
   }
-  if (import_ts_morph29.Node.isJsxElement(first) || import_ts_morph29.Node.isJsxSelfClosingElement(first) || import_ts_morph29.Node.isCallExpression(first) && callsAFactory(first, elementsNames)) {
+  if (import_ts_morph30.Node.isJsxElement(first) || import_ts_morph30.Node.isJsxSelfClosingElement(first) || import_ts_morph30.Node.isCallExpression(first) && callsAFactory(first, elementsNames)) {
     return [];
   }
   const array = arrayLiteralOf(first, resolution);
@@ -6477,7 +7073,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 (import_ts_morph29.Node.isSpreadElement(element)) {
+    if (import_ts_morph30.Node.isSpreadElement(element)) {
       results.push(
         abstention(
           element,
@@ -6488,7 +7084,7 @@ function unitsOfArrayElements(array, match, kind, resolution, prefix, ancestry)
       );
       continue;
     }
-    if (!import_ts_morph29.Node.isObjectLiteralExpression(element)) {
+    if (!import_ts_morph30.Node.isObjectLiteralExpression(element)) {
       results.push(
         abstention(
           element,
@@ -6577,7 +7173,7 @@ function ownPathOfObject(object, match) {
   }
   if (match.indexAttribute !== void 0) {
     const indexValue = routePropertyOf(object, match.indexAttribute);
-    if (indexValue !== null && import_ts_morph29.Node.isTrueLiteral(indexValue)) {
+    if (indexValue !== null && import_ts_morph30.Node.isTrueLiteral(indexValue)) {
       return { kind: "inherited" };
     }
   }
@@ -6591,17 +7187,17 @@ function objectLabelOf(target) {
   return target.kind === "named" ? target.identifier.getText() : "declaration";
 }
 function labelOfExpression(node) {
-  if (import_ts_morph29.Node.isIdentifier(node)) {
+  if (import_ts_morph30.Node.isIdentifier(node)) {
     return node.getText();
   }
-  if (import_ts_morph29.Node.isCallExpression(node)) {
+  if (import_ts_morph30.Node.isCallExpression(node)) {
     return node.getExpression().getText();
   }
   return node.getKindName();
 }
 
 // src/discovery/packageExports.ts
-var import_ts_morph31 = require("ts-morph");
+var import_ts_morph32 = require("ts-morph");
 
 // src/packageExports.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
@@ -6793,13 +7389,13 @@ function sameDeclaration(a, b) {
 }
 
 // src/discovery/factorySurface.ts
-var import_ts_morph30 = require("ts-morph");
+var import_ts_morph31 = require("ts-morph");
 var MAX_BUILDER_HOPS = 2;
 function surfaceMethods(decl) {
-  if (import_ts_morph30.Node.isClassDeclaration(decl)) {
+  if (import_ts_morph31.Node.isClassDeclaration(decl)) {
     return surfaceClassMethods(decl);
   }
-  if (import_ts_morph30.Node.isFunctionDeclaration(decl) || import_ts_morph30.Node.isFunctionExpression(decl) || import_ts_morph30.Node.isArrowFunction(decl) || import_ts_morph30.Node.isMethodDeclaration(decl)) {
+  if (import_ts_morph31.Node.isFunctionDeclaration(decl) || import_ts_morph31.Node.isFunctionExpression(decl) || import_ts_morph31.Node.isArrowFunction(decl) || import_ts_morph31.Node.isMethodDeclaration(decl)) {
     return surfaceFactoryReturnMethods(decl);
   }
   return [];
@@ -6808,7 +7404,7 @@ function surfaceClassMethods(cls) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const method of cls.getInstanceMethods()) {
-    if (method.hasModifier(import_ts_morph30.SyntaxKind.PrivateKeyword)) {
+    if (method.hasModifier(import_ts_morph31.SyntaxKind.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -6819,7 +7415,7 @@ function surfaceClassMethods(cls) {
     out.push({ func: method, name });
   }
   for (const method of cls.getStaticMethods()) {
-    if (method.hasModifier(import_ts_morph30.SyntaxKind.PrivateKeyword)) {
+    if (method.hasModifier(import_ts_morph31.SyntaxKind.PrivateKeyword)) {
       continue;
     }
     const name = method.getName();
@@ -6838,9 +7434,9 @@ function surfaceFactoryReturnMethods(fn) {
   return out;
 }
 function collectFromFunctionReturns(fn, out, seen, depth) {
-  if (import_ts_morph30.Node.isArrowFunction(fn)) {
+  if (import_ts_morph31.Node.isArrowFunction(fn)) {
     const body2 = fn.getBody();
-    if (import_ts_morph30.Node.isExpression(body2)) {
+    if (import_ts_morph31.Node.isExpression(body2)) {
       collectFromReturnValue(body2, out, seen, depth);
       return;
     }
@@ -6851,11 +7447,11 @@ function collectFromFunctionReturns(fn, out, seen, depth) {
   }
   const returns = [];
   body.forEachDescendant((node, traversal) => {
-    if (import_ts_morph30.Node.isFunctionDeclaration(node) || import_ts_morph30.Node.isFunctionExpression(node) || import_ts_morph30.Node.isArrowFunction(node) || import_ts_morph30.Node.isMethodDeclaration(node) || import_ts_morph30.Node.isConstructorDeclaration(node) || import_ts_morph30.Node.isGetAccessorDeclaration(node) || import_ts_morph30.Node.isSetAccessorDeclaration(node)) {
+    if (import_ts_morph31.Node.isFunctionDeclaration(node) || import_ts_morph31.Node.isFunctionExpression(node) || import_ts_morph31.Node.isArrowFunction(node) || import_ts_morph31.Node.isMethodDeclaration(node) || import_ts_morph31.Node.isConstructorDeclaration(node) || import_ts_morph31.Node.isGetAccessorDeclaration(node) || import_ts_morph31.Node.isSetAccessorDeclaration(node)) {
       traversal.skip();
       return;
     }
-    if (import_ts_morph30.Node.isReturnStatement(node)) {
+    if (import_ts_morph31.Node.isReturnStatement(node)) {
       returns.push(node);
     }
   });
@@ -6869,15 +7465,15 @@ function collectFromFunctionReturns(fn, out, seen, depth) {
 }
 function collectFromReturnValue(node, out, seen, depth) {
   const expr = peelParens(node);
-  if (import_ts_morph30.Node.isObjectLiteralExpression(expr)) {
+  if (import_ts_morph31.Node.isObjectLiteralExpression(expr)) {
     collectFromObjectLiteral(expr, out, seen);
     return;
   }
-  if (depth >= MAX_BUILDER_HOPS || !import_ts_morph30.Node.isCallExpression(expr)) {
+  if (depth >= MAX_BUILDER_HOPS || !import_ts_morph31.Node.isCallExpression(expr)) {
     return;
   }
   const callee = expr.getExpression();
-  if (!import_ts_morph30.Node.isIdentifier(callee)) {
+  if (!import_ts_morph31.Node.isIdentifier(callee)) {
     return;
   }
   const helper = sameFileFunctionBehind(callee);
@@ -6900,12 +7496,12 @@ function functionAmong(declarations, filePath) {
     if (decl.getSourceFile().getFilePath() !== filePath) {
       continue;
     }
-    if (import_ts_morph30.Node.isFunctionDeclaration(decl)) {
+    if (import_ts_morph31.Node.isFunctionDeclaration(decl)) {
       return decl;
     }
-    if (import_ts_morph30.Node.isVariableDeclaration(decl)) {
+    if (import_ts_morph31.Node.isVariableDeclaration(decl)) {
       const init = decl.getInitializer();
-      if (init !== void 0 && (import_ts_morph30.Node.isArrowFunction(init) || import_ts_morph30.Node.isFunctionExpression(init))) {
+      if (init !== void 0 && (import_ts_morph31.Node.isArrowFunction(init) || import_ts_morph31.Node.isFunctionExpression(init))) {
         return init;
       }
     }
@@ -6914,11 +7510,11 @@ function functionAmong(declarations, filePath) {
 }
 function collectFromObjectLiteral(node, out, seen) {
   const e = peelParens(node);
-  if (!import_ts_morph30.Node.isObjectLiteralExpression(e)) {
+  if (!import_ts_morph31.Node.isObjectLiteralExpression(e)) {
     return;
   }
   for (const prop of e.getProperties()) {
-    if (import_ts_morph30.Node.isMethodDeclaration(prop)) {
+    if (import_ts_morph31.Node.isMethodDeclaration(prop)) {
       const name = prop.getName();
       if (seen.has(name)) {
         continue;
@@ -6927,16 +7523,16 @@ function collectFromObjectLiteral(node, out, seen) {
       out.push({ func: prop, name });
       continue;
     }
-    if (import_ts_morph30.Node.isPropertyAssignment(prop)) {
+    if (import_ts_morph31.Node.isPropertyAssignment(prop)) {
       const init = prop.getInitializer();
       if (init === void 0) {
         continue;
       }
       let v3 = init;
-      while (import_ts_morph30.Node.isParenthesizedExpression(v3)) {
+      while (import_ts_morph31.Node.isParenthesizedExpression(v3)) {
         v3 = v3.getExpression();
       }
-      if (import_ts_morph30.Node.isArrowFunction(v3) || import_ts_morph30.Node.isFunctionExpression(v3)) {
+      if (import_ts_morph31.Node.isArrowFunction(v3) || import_ts_morph31.Node.isFunctionExpression(v3)) {
         const name = prop.getName();
         if (seen.has(name)) {
           continue;
@@ -6945,7 +7541,7 @@ function collectFromObjectLiteral(node, out, seen) {
         out.push({ func: v3, name });
       }
     }
-    if (import_ts_morph30.Node.isShorthandPropertyAssignment(prop)) {
+    if (import_ts_morph31.Node.isShorthandPropertyAssignment(prop)) {
       collectShorthandFunction(prop, out, seen);
     }
   }
@@ -7008,9 +7604,9 @@ function discoverPackageExports(sourceFile, match, kind, resolution) {
         (decl) => sourceDeclarationsBehind(decl, resolution)
       );
       for (const decl of candidates) {
-        if (import_ts_morph31.Node.isVariableDeclaration(decl)) {
+        if (import_ts_morph32.Node.isVariableDeclaration(decl)) {
           const init = decl.getInitializer();
-          if (init !== void 0 && (import_ts_morph31.Node.isArrowFunction(init) || import_ts_morph31.Node.isFunctionExpression(init))) {
+          if (init !== void 0 && (import_ts_morph32.Node.isArrowFunction(init) || import_ts_morph32.Node.isFunctionExpression(init))) {
             results.push(buildUnit(init, kind, exportName, entry));
             for (const m of surfaceMethods(init)) {
               results.push(buildSurfacedUnit(m, kind, exportName, entry));
@@ -7020,7 +7616,7 @@ function discoverPackageExports(sourceFile, match, kind, resolution) {
           }
           continue;
         }
-        if (import_ts_morph31.Node.isClassDeclaration(decl)) {
+        if (import_ts_morph32.Node.isClassDeclaration(decl)) {
           for (const m of surfaceMethods(decl)) {
             results.push(buildSurfacedUnit(m, kind, exportName, entry));
           }
@@ -7065,7 +7661,7 @@ function buildSurfacedUnit(m, kind, parentExportName, entry) {
 }
 
 // src/discovery/packageImport.ts
-var import_ts_morph32 = require("ts-morph");
+var import_ts_morph33 = require("ts-morph");
 function isLanguageLib(file) {
   return /[\\/]typescript[\\/]lib[\\/]lib\..*\.d\.ts$/.test(file.getFilePath());
 }
@@ -7086,13 +7682,13 @@ function splitPackageSpec(spec) {
   };
 }
 function enclosingFunctionName(func) {
-  if (import_ts_morph32.Node.isFunctionDeclaration(func) || import_ts_morph32.Node.isMethodDeclaration(func)) {
+  if (import_ts_morph33.Node.isFunctionDeclaration(func) || import_ts_morph33.Node.isMethodDeclaration(func)) {
     const n = func.getName?.();
     if (typeof n === "string" && n.length > 0) {
       return n;
     }
   }
-  if (import_ts_morph32.Node.isFunctionExpression(func)) {
+  if (import_ts_morph33.Node.isFunctionExpression(func)) {
     const n = func.getName();
     if (typeof n === "string" && n.length > 0) {
       return n;
@@ -7100,10 +7696,10 @@ function enclosingFunctionName(func) {
   }
   const parent = func.getParent();
   if (parent !== void 0) {
-    if (import_ts_morph32.Node.isVariableDeclaration(parent)) {
+    if (import_ts_morph33.Node.isVariableDeclaration(parent)) {
       return parent.getName();
     }
-    if (import_ts_morph32.Node.isPropertyAssignment(parent)) {
+    if (import_ts_morph33.Node.isPropertyAssignment(parent)) {
       return parent.getName();
     }
   }
@@ -7122,7 +7718,7 @@ function attributedCalls(sourceFile, packages, resolution) {
   const calls = [];
   const candidates = /* @__PURE__ */ new Set();
   sourceFile.forEachDescendant((node) => {
-    if (!import_ts_morph32.Node.isCallExpression(node)) {
+    if (!import_ts_morph33.Node.isCallExpression(node)) {
       return;
     }
     calls.push(node);
@@ -7130,7 +7726,7 @@ function attributedCalls(sourceFile, packages, resolution) {
     if (couldBePackageLinked(callee, packages)) {
       candidates.add(callee);
     }
-    if (import_ts_morph32.Node.isPropertyAccessExpression(callee) && couldBePackageLinked(callee.getExpression(), packages)) {
+    if (import_ts_morph33.Node.isPropertyAccessExpression(callee) && couldBePackageLinked(callee.getExpression(), packages)) {
       candidates.add(callee.getExpression());
     }
   });
@@ -7152,7 +7748,7 @@ function attributedCalls(sourceFile, packages, resolution) {
     if (direct !== null) {
       return direct;
     }
-    if (!import_ts_morph32.Node.isPropertyAccessExpression(callee)) {
+    if (!import_ts_morph33.Node.isPropertyAccessExpression(callee)) {
       return null;
     }
     const subject = originOf(callee.getExpression());
@@ -7177,7 +7773,7 @@ function attributedCalls(sourceFile, packages, resolution) {
   return results;
 }
 function couldBePackageLinked(value, packages) {
-  if (!import_ts_morph32.Node.isIdentifier(value)) {
+  if (!import_ts_morph33.Node.isIdentifier(value)) {
     return true;
   }
   const declarations = value.getSymbol()?.getDeclarations() ?? [];
@@ -7185,7 +7781,7 @@ function couldBePackageLinked(value, packages) {
     return true;
   }
   return !declarations.every(
-    (declaration) => import_ts_morph32.Node.isFunctionDeclaration(declaration) || import_ts_morph32.Node.isMethodDeclaration(declaration) || import_ts_morph32.Node.isClassDeclaration(declaration) || import_ts_morph32.Node.isImportSpecifier(declaration) && importAimsElsewhere(declaration, packages)
+    (declaration) => import_ts_morph33.Node.isFunctionDeclaration(declaration) || import_ts_morph33.Node.isMethodDeclaration(declaration) || import_ts_morph33.Node.isClassDeclaration(declaration) || import_ts_morph33.Node.isImportSpecifier(declaration) && importAimsElsewhere(declaration, packages)
   );
 }
 function importAimsElsewhere(declaration, packages) {
@@ -7242,156 +7838,9 @@ var import_ts_morph34 = require("ts-morph");
 var import_resolution3 = require("@suss/resolution");
 
 // src/resolve/routePath.ts
-var import_ts_morph33 = require("ts-morph");
-var import_behavioral_ir2 = require("@suss/behavioral-ir");
-var URL_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//;
-var URL_ORIGIN = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\/[^/]*/;
-var PROTOCOL_RELATIVE = /^\/\//;
-var PROTOCOL_RELATIVE_ORIGIN = /^\/\/[^/]*/;
-function isAbsoluteUrlLiteral(text) {
-  return URL_SCHEME.test(text) || PROTOCOL_RELATIVE.test(text);
-}
-function stripOriginManually(text) {
-  if (URL_SCHEME.test(text)) {
-    return text.replace(URL_ORIGIN, "");
-  }
-  if (PROTOCOL_RELATIVE.test(text)) {
-    return text.replace(PROTOCOL_RELATIVE_ORIGIN, "");
-  }
-  return text;
-}
-function stripQueryAndFragment(text) {
-  const idx = text.search(/[?#]/);
-  return idx === -1 ? text : text.slice(0, idx);
-}
-var SUBSTITUTION = "\uFFFF";
-var AUTHORITY_OPENER = /^(?:[-+.\uFFFFa-zA-Z0-9]+:\/\/|\/\/)/;
-function originEndOf(flattened) {
-  const opener = AUTHORITY_OPENER.exec(flattened);
-  if (opener === null) {
-    return 0;
-  }
-  const slash = flattened.indexOf("/", opener[0].length);
-  return slash === -1 ? flattened.length : slash;
-}
-function appendPathText(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 (import_ts_morph33.Node.isStringLiteral(node)) {
-    return pathFromLiteralUrl(node.getLiteralValue());
-  }
-  if (import_ts_morph33.Node.isNoSubstitutionTemplateLiteral(node)) {
-    return pathFromLiteralUrl(node.getLiteralValue());
-  }
-  if (import_ts_morph33.Node.isTemplateExpression(node)) {
-    return pathFromTemplateUrl(node, resolution);
-  }
-  if (import_ts_morph33.Node.isBinaryExpression(node)) {
-    const joined = joinedStringOf(node, resolution);
-    return joined === void 0 ? void 0 : pathFromLiteralUrl(joined);
-  }
-  return void 0;
-}
-function joinedStringOf(node, resolution) {
-  if (import_ts_morph33.Node.isStringLiteral(node) || import_ts_morph33.Node.isNoSubstitutionTemplateLiteral(node)) {
-    return node.getLiteralValue();
-  }
-  if (import_ts_morph33.Node.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 (import_ts_morph33.Node.isIdentifier(expr)) {
-    return expr.getText();
-  }
-  if (import_ts_morph33.Node.isPropertyAccessExpression(expr)) {
-    return expr.getName();
-  }
-  return "param";
-}
-function holeText(expr, resolution) {
-  const written = resolution?.resolveWrittenValue(expr) ?? null;
-  if (written === null) {
-    return (0, import_behavioral_ir2.patternHole)(placeholderName(expr));
-  }
-  if (emptyStringLiteral(written)) {
-    return "";
-  }
-  return pathFromUrlNode(written, resolution) ?? (0, import_behavioral_ir2.patternHole)(placeholderName(expr));
-}
-function emptyStringLiteral(node) {
-  return (import_ts_morph33.Node.isStringLiteral(node) || import_ts_morph33.Node.isNoSubstitutionTemplateLiteral(node)) && node.getLiteralValue() === "";
-}
+var import_values4 = require("@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 (0, import_values4.pathOf)(evaluatedValue(arg, resolution));
 }
 
 // src/discovery/registrationCall.ts
@@ -7652,13 +8101,13 @@ function collectMethodsCalledOnCallResults(sourceFile) {
   return called;
 }
 function registrationSubjectsOf(sourceFile, importModule, importName, resolution) {
-  const importedLocalName = resolveImportedLocalName(
+  const spellings = importedReferenceSpellings(
     sourceFile,
     importModule,
     importName
   );
   const subjects = /* @__PURE__ */ new Map();
-  if (importedLocalName === null) {
+  if (spellings.length === 0) {
     return subjects;
   }
   sourceFile.forEachDescendant((node) => {
@@ -7668,7 +8117,7 @@ function registrationSubjectsOf(sourceFile, importModule, importName, resolution
         return;
       }
       const calleeText = import_ts_morph34.Node.isCallExpression(init) || import_ts_morph34.Node.isNewExpression(init) ? init.getExpression().getText() : null;
-      if (calleeText === importedLocalName) {
+      if (calleeText !== null && spellings.includes(calleeText)) {
         subjects.set(node.getName(), init);
       }
       return;
@@ -7681,7 +8130,9 @@ function registrationSubjectsOf(sourceFile, importModule, importName, resolution
       return;
     }
     const typeText = typeNode.getText();
-    if (typeText === importedLocalName || typeText.startsWith(`${importedLocalName}<`)) {
+    if (spellings.some(
+      (spelling) => typeText === spelling || typeText.startsWith(`${spelling}<`)
+    )) {
       subjects.set(node.getName(), creationSiteBehind(node, resolution));
     }
   });
@@ -7725,17 +8176,17 @@ function registrationSubjectIdsOf(sourceFile, matches, resolution) {
   return ids;
 }
 function unboundConstructionsOf(sourceFile, importModule, importName) {
-  const importedLocalName = resolveImportedLocalName(
+  const spellings = importedReferenceSpellings(
     sourceFile,
     importModule,
     importName
   );
-  if (importedLocalName === null) {
+  if (spellings.length === 0) {
     return [];
   }
   const constructions = [];
   sourceFile.forEachDescendant((node) => {
-    if ((import_ts_morph34.Node.isCallExpression(node) || import_ts_morph34.Node.isNewExpression(node)) && node.getExpression().getText() === importedLocalName && !import_ts_morph34.Node.isVariableDeclaration(node.getParent())) {
+    if ((import_ts_morph34.Node.isCallExpression(node) || import_ts_morph34.Node.isNewExpression(node)) && spellings.includes(node.getExpression().getText()) && !import_ts_morph34.Node.isVariableDeclaration(node.getParent())) {
       constructions.push(node);
     }
   });
@@ -7804,32 +8255,14 @@ function mountTargetsAmong(args, targetPosition, knownSubjectIds, resolution) {
   }
   return targets;
 }
-function stringProperty(obj, name) {
-  if (!import_ts_morph34.Node.isObjectLiteralExpression(obj)) {
-    return null;
-  }
-  const property = obj.getProperty(name);
-  if (property === void 0 || !import_ts_morph34.Node.isPropertyAssignment(property)) {
-    return null;
-  }
-  const value = property.getInitializer();
-  if (value !== void 0 && (import_ts_morph34.Node.isStringLiteral(value) || import_ts_morph34.Node.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;
     }
@@ -8029,7 +8462,7 @@ var import_resolution4 = require("@suss/resolution");
 
 // src/resolve/unfollowedCall.ts
 var import_ts_morph36 = require("ts-morph");
-var import_behavioral_ir3 = require("@suss/behavioral-ir");
+var import_behavioral_ir2 = require("@suss/behavioral-ir");
 function isInExternalCode(sourceFile) {
   if (sourceFile.isDeclarationFile()) {
     return true;
@@ -8684,7 +9117,7 @@ function parameterReads(func, parameterNames2, barriers = NO_BARRIERS) {
 
 // src/resolve/readName.ts
 var import_ts_morph41 = require("ts-morph");
-var import_behavioral_ir4 = require("@suss/behavioral-ir");
+var import_behavioral_ir3 = require("@suss/behavioral-ir");
 var MAX_HELPER_HOPS = 2;
 var UNNAMED_HOLE = "param";
 function readName(expr, options = {}) {
@@ -8699,7 +9132,7 @@ function readName(expr, options = {}) {
     return name;
   }
   const reference = referenceIn(expr);
-  return reference === null ? null : (0, import_behavioral_ir4.referenceName)(reference);
+  return reference === null ? null : (0, import_behavioral_ir3.referenceName)(reference);
 }
 function referenceIn(expr) {
   const fromParameter = parameterPath(expr);
@@ -8948,7 +9381,7 @@ function boundOnce(expr, ctx) {
 }
 function readOrHole(expr, ctx) {
   const name = read(expr, ctx);
-  return name ?? (0, import_behavioral_ir4.patternHole)(holeName(expr, ctx));
+  return name ?? (0, import_behavioral_ir3.patternHole)(holeName(expr, ctx));
 }
 function holeName(expr, ctx) {
   const bound = boundOnce(expr, ctx);
@@ -9015,7 +9448,7 @@ function madeExpression(receiver) {
 }
 function callOpsFor(call, resolveWrittenValue, originatesFrom, anchorCallsOf) {
   const resolve2 = resolveWrittenValue ?? (() => null);
-  const expression = calleeOf2(call);
+  const expression = calleeOf3(call);
   const callee = import_ts_morph42.Node.isPropertyAccessExpression(expression) ? expression : null;
   let args = null;
   const argumentsOf = () => {
@@ -9067,7 +9500,7 @@ function anchorCallBehind(subject, origin, resolve2, originatesFrom, anchorCalls
     if (!import_ts_morph42.Node.isCallExpression(candidate) && !import_ts_morph42.Node.isNewExpression(candidate)) {
       return false;
     }
-    const candidateCallee = calleeOf2(candidate);
+    const candidateCallee = calleeOf3(candidate);
     if (origin.named !== void 0 && !origin.named.includes(constructorName(candidate))) {
       return false;
     }
@@ -9201,7 +9634,7 @@ function opsOverCall(value, resolve2) {
 function isCalled(value) {
   return import_ts_morph42.Node.isCallExpression(value) || import_ts_morph42.Node.isNewExpression(value) || import_ts_morph42.Node.isTaggedTemplateExpression(value);
 }
-function calleeOf2(call) {
+function calleeOf3(call) {
   return import_ts_morph42.Node.isTaggedTemplateExpression(call) ? call.getTag() : call.getExpression();
 }
 function argumentsIn(call) {
@@ -9784,199 +10217,12 @@ function tryMatchParameterCall(node, func, pattern, match) {
   return { node, terminal };
 }
 
-// src/terminals/jsx.ts
-var import_ts_morph46 = require("ts-morph");
-function tryMatchJsxReturn(node, pattern) {
-  let expr;
-  let source;
-  if (import_ts_morph46.Node.isReturnStatement(node)) {
-    expr = node.getExpression();
-    source = node;
-  } else if (import_ts_morph46.Node.isArrowFunction(node)) {
-    const body = node.getBody();
-    if (body !== void 0 && !import_ts_morph46.Node.isBlock(body)) {
-      expr = body;
-      source = body;
-    }
-  }
-  if (expr === void 0 || source === void 0) {
-    return null;
-  }
-  const tree = jsxToRenderNode(expr);
-  if (tree === null) {
-    return null;
-  }
-  const component = tree.type === "element" ? tree.tag : "Fragment";
-  const terminal = {
-    kind: pattern.kind,
-    statusCode: null,
-    body: null,
-    exceptionType: null,
-    message: null,
-    component,
-    delegateTarget: null,
-    emitEvent: null,
-    renderTree: tree,
-    location: {
-      start: startLineOf(node),
-      end: endLineOf(node)
-    }
-  };
-  return { node, source, terminal };
-}
-function componentTargetOf(tagNode) {
-  if (!import_ts_morph46.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
-    return null;
-  }
-  const target = functionTargetOf(tagNode);
-  return target === null ? null : { file: target.file, name: target.name };
-}
-function jsxToRenderNode(node) {
-  if (import_ts_morph46.Node.isJsxElement(node)) {
-    const opening = node.getOpeningElement();
-    const tag = opening.getTagNameNode().getText();
-    const attrs = collectJsxAttributes(opening);
-    const target = componentTargetOf(opening.getTagNameNode());
-    const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
-    return {
-      type: "element",
-      tag,
-      children,
-      ...attrs !== null ? { attrs } : {},
-      ...target !== null ? { target } : {}
-    };
-  }
-  if (import_ts_morph46.Node.isJsxSelfClosingElement(node)) {
-    const tag = node.getTagNameNode().getText();
-    const attrs = collectJsxAttributes(node);
-    const target = componentTargetOf(node.getTagNameNode());
-    return {
-      type: "element",
-      tag,
-      children: [],
-      ...attrs !== null ? { attrs } : {},
-      ...target !== null ? { target } : {}
-    };
-  }
-  if (import_ts_morph46.Node.isJsxFragment(node)) {
-    const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
-    return { type: "element", tag: "Fragment", children };
-  }
-  if (import_ts_morph46.Node.isParenthesizedExpression(node)) {
-    return jsxToRenderNode(node.getExpression());
-  }
-  return null;
-}
-function collectJsxAttributes(opening) {
-  const entries = {};
-  for (const attr of opening.getAttributes()) {
-    if (import_ts_morph46.Node.isJsxSpreadAttribute(attr)) {
-      const exprText = attr.getExpression().getText();
-      entries[`...${exprText}`] = exprText;
-      continue;
-    }
-    if (!import_ts_morph46.Node.isJsxAttribute(attr)) {
-      continue;
-    }
-    const name = attr.getNameNode().getText();
-    const initializer = attr.getInitializer();
-    if (initializer === void 0) {
-      entries[name] = "";
-      continue;
-    }
-    if (import_ts_morph46.Node.isJsxExpression(initializer)) {
-      const inner = initializer.getExpression();
-      entries[name] = inner !== void 0 ? inner.getText() : "";
-      continue;
-    }
-    entries[name] = initializer.getText();
-  }
-  return Object.keys(entries).length > 0 ? entries : null;
-}
-function jsxChildToRenderNode(child) {
-  if (import_ts_morph46.Node.isJsxText(child)) {
-    const text = child.getLiteralText().trim();
-    if (text.length === 0) {
-      return null;
-    }
-    return { type: "text", value: text };
-  }
-  if (import_ts_morph46.Node.isJsxExpression(child)) {
-    const inner = child.getExpression();
-    if (inner === void 0) {
-      return null;
-    }
-    return jsxExpressionToRenderNode(inner);
-  }
-  if (import_ts_morph46.Node.isJsxElement(child) || import_ts_morph46.Node.isJsxSelfClosingElement(child) || import_ts_morph46.Node.isJsxFragment(child)) {
-    return jsxToRenderNode(child);
-  }
-  return null;
-}
-function jsxExpressionToRenderNode(expr) {
-  if (import_ts_morph46.Node.isParenthesizedExpression(expr)) {
-    return jsxExpressionToRenderNode(expr.getExpression());
-  }
-  if (import_ts_morph46.Node.isBinaryExpression(expr)) {
-    const op = expr.getOperatorToken().getText();
-    if (op === "&&") {
-      const right = renderAlternative(peelParens(expr.getRight()));
-      if (right.kind === "jsx") {
-        return {
-          type: "conditional",
-          condition: expr.getLeft().getText(),
-          whenTrue: right.node,
-          whenFalse: null
-        };
-      }
-    }
-  }
-  if (import_ts_morph46.Node.isConditionalExpression(expr)) {
-    const truthy = renderAlternative(peelParens(expr.getWhenTrue()));
-    const falsy = renderAlternative(peelParens(expr.getWhenFalse()));
-    if (truthy.kind === "jsx") {
-      return {
-        type: "conditional",
-        condition: expr.getCondition().getText(),
-        whenTrue: truthy.node,
-        whenFalse: falsy.kind === "jsx" ? falsy.node : null
-      };
-    }
-    if (falsy.kind === "jsx") {
-      return {
-        type: "conditional",
-        condition: `!(${expr.getCondition().getText()})`,
-        whenTrue: falsy.node,
-        whenFalse: null
-      };
-    }
-  }
-  return { type: "expression", sourceText: expr.getText() };
-}
-function renderAlternative(node) {
-  if (import_ts_morph46.Node.isNullLiteral(node)) {
-    return { kind: "noRender" };
-  }
-  if (import_ts_morph46.Node.isFalseLiteral(node)) {
-    return { kind: "noRender" };
-  }
-  if (import_ts_morph46.Node.isIdentifier(node) && node.getText() === "undefined") {
-    return { kind: "noRender" };
-  }
-  if (import_ts_morph46.Node.isJsxElement(node) || import_ts_morph46.Node.isJsxSelfClosingElement(node) || import_ts_morph46.Node.isJsxFragment(node)) {
-    const tree = jsxToRenderNode(node);
-    if (tree !== null) {
-      return { kind: "jsx", node: tree };
-    }
-  }
-  return { kind: "notStatic" };
-}
-
-// src/terminals/returns.ts
-var import_ts_morph51 = require("ts-morph");
+// src/terminals/extract.ts
+var import_ts_morph47 = require("ts-morph");
+var import_values5 = require("@suss/values");
 
 // src/shapes/shapes.ts
-var import_ts_morph47 = require("ts-morph");
+var import_ts_morph46 = require("ts-morph");
 
 // src/shapes/typeShapes.ts
 var import_node_crypto = require("crypto");
@@ -10435,60 +10681,60 @@ function extractShapeWithArguments(node, substitutions) {
 }
 function extractShapeInner(node) {
   const unwrapped2 = peelSyntax(node);
-  if (boundArguments !== null && import_ts_morph47.Node.isIdentifier(unwrapped2)) {
+  if (boundArguments !== null && import_ts_morph46.Node.isIdentifier(unwrapped2)) {
     const argument = boundArguments.get(unwrapped2.getText());
     if (argument !== void 0 && argument !== unwrapped2) {
       return extractShape(argument);
     }
   }
-  if (import_ts_morph47.Node.isObjectLiteralExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isObjectLiteralExpression(unwrapped2)) {
     return shapeFromObjectLiteral(unwrapped2);
   }
-  if (import_ts_morph47.Node.isArrayLiteralExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isArrayLiteralExpression(unwrapped2)) {
     return shapeFromArrayLiteral(unwrapped2);
   }
-  if (import_ts_morph47.Node.isStringLiteral(unwrapped2) || import_ts_morph47.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
+  if (import_ts_morph46.Node.isStringLiteral(unwrapped2) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(unwrapped2)) {
     return { type: "literal", value: unwrapped2.getLiteralValue() };
   }
-  if (import_ts_morph47.Node.isTemplateExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isTemplateExpression(unwrapped2)) {
     return { type: "text" };
   }
-  if (import_ts_morph47.Node.isNumericLiteral(unwrapped2)) {
+  if (import_ts_morph46.Node.isNumericLiteral(unwrapped2)) {
     return numericLiteralShape(
       unwrapped2.getLiteralValue(),
       unwrapped2.getText()
     );
   }
-  if (import_ts_morph47.Node.isPrefixUnaryExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isPrefixUnaryExpression(unwrapped2)) {
     const op = unwrapped2.getOperatorToken();
-    if (op === import_ts_morph47.SyntaxKind.MinusToken || op === import_ts_morph47.SyntaxKind.PlusToken) {
+    if (op === import_ts_morph46.SyntaxKind.MinusToken || op === import_ts_morph46.SyntaxKind.PlusToken) {
       const inner = unwrapped2.getOperand();
-      if (import_ts_morph47.Node.isNumericLiteral(inner)) {
+      if (import_ts_morph46.Node.isNumericLiteral(inner)) {
         const v3 = inner.getLiteralValue();
-        const signed = op === import_ts_morph47.SyntaxKind.MinusToken ? -v3 : v3;
+        const signed = op === import_ts_morph46.SyntaxKind.MinusToken ? -v3 : v3;
         const rawBody = inner.getText();
-        const raw = op === import_ts_morph47.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
+        const raw = op === import_ts_morph46.SyntaxKind.MinusToken ? `-${rawBody}` : rawBody;
         return numericLiteralShape(signed, raw);
       }
     }
   }
-  if (import_ts_morph47.Node.isBigIntLiteral(unwrapped2)) {
+  if (import_ts_morph46.Node.isBigIntLiteral(unwrapped2)) {
     return { type: "ref", name: "bigint" };
   }
   const kind = unwrapped2.getKind();
-  if (kind === import_ts_morph47.SyntaxKind.TrueKeyword) {
+  if (kind === import_ts_morph46.SyntaxKind.TrueKeyword) {
     return { type: "literal", value: true };
   }
-  if (kind === import_ts_morph47.SyntaxKind.FalseKeyword) {
+  if (kind === import_ts_morph46.SyntaxKind.FalseKeyword) {
     return { type: "literal", value: false };
   }
-  if (kind === import_ts_morph47.SyntaxKind.NullKeyword) {
+  if (kind === import_ts_morph46.SyntaxKind.NullKeyword) {
     return { type: "null" };
   }
-  if (import_ts_morph47.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
+  if (import_ts_morph46.Node.isIdentifier(unwrapped2) && unwrapped2.getText() === "undefined") {
     return { type: "undefined" };
   }
-  if (import_ts_morph47.Node.isConditionalExpression(unwrapped2)) {
+  if (import_ts_morph46.Node.isConditionalExpression(unwrapped2)) {
     const whenTrue = extractShape(unwrapped2.getWhenTrue());
     const whenFalse = extractShape(unwrapped2.getWhenFalse());
     const variants = [];
@@ -10519,7 +10765,7 @@ function shapeFromArrayLiteral(arr) {
   }
   const shapes = [];
   for (const el of elements) {
-    if (import_ts_morph47.Node.isSpreadElement(el)) {
+    if (import_ts_morph46.Node.isSpreadElement(el)) {
       const inner = el.getExpression();
       const innerShape = extractShape(inner);
       if (innerShape?.type === "array") {
@@ -10538,7 +10784,7 @@ function shapeFromObjectLiteral(obj) {
   const properties = {};
   const unresolvedSpreads = [];
   for (const prop of obj.getProperties()) {
-    if (import_ts_morph47.Node.isPropertyAssignment(prop)) {
+    if (import_ts_morph46.Node.isPropertyAssignment(prop)) {
       const name = propertyName2(prop);
       if (name === null) {
         continue;
@@ -10554,7 +10800,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
+    if (import_ts_morph46.Node.isShorthandPropertyAssignment(prop)) {
       const name = prop.getName();
       const valueExpr = prop.getNameNode();
       properties[name] = extractShape(valueExpr) ?? {
@@ -10563,7 +10809,7 @@ function shapeFromObjectLiteral(obj) {
       };
       continue;
     }
-    if (import_ts_morph47.Node.isSpreadAssignment(prop)) {
+    if (import_ts_morph46.Node.isSpreadAssignment(prop)) {
       const expr = prop.getExpression();
       const spreadShape = extractShape(expr);
       if (spreadShape?.type === "record") {
@@ -10582,7 +10828,7 @@ function shapeFromObjectLiteral(obj) {
 }
 function propertyName2(prop) {
   const nameNode = prop.getNameNode();
-  if (import_ts_morph47.Node.isIdentifier(nameNode) || import_ts_morph47.Node.isStringLiteral(nameNode) || import_ts_morph47.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph47.Node.isNumericLiteral(nameNode)) {
+  if (import_ts_morph46.Node.isIdentifier(nameNode) || import_ts_morph46.Node.isStringLiteral(nameNode) || import_ts_morph46.Node.isNoSubstitutionTemplateLiteral(nameNode) || import_ts_morph46.Node.isNumericLiteral(nameNode)) {
     return nameNode.getText().replace(/^["']|["']$/g, "");
   }
   return null;
@@ -10608,21 +10854,20 @@ function collapseVariants2(shapes) {
 }
 
 // src/terminals/extract.ts
-var import_ts_morph48 = require("ts-morph");
 function unwrapAs(node) {
   return peelSyntax(node);
 }
 function unwrapJsonStringify(node) {
   const outer = unwrapAs(node);
-  if (!import_ts_morph48.Node.isCallExpression(outer)) {
+  if (!import_ts_morph47.Node.isCallExpression(outer)) {
     return node;
   }
   const callee = outer.getExpression();
-  if (!import_ts_morph48.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
+  if (!import_ts_morph47.Node.isPropertyAccessExpression(callee) || callee.getName() !== "stringify") {
     return node;
   }
   const receiver = callee.getExpression();
-  if (!import_ts_morph48.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
+  if (!import_ts_morph47.Node.isIdentifier(receiver) || receiver.getText() !== "JSON") {
     return node;
   }
   const args = outer.getArguments();
@@ -10632,7 +10877,7 @@ function unwrapJsonStringify(node) {
   return unwrapAs(args[0]);
 }
 function substituted(value, ctx) {
-  if (ctx.substitutions === void 0 || !import_ts_morph48.Node.isIdentifier(value)) {
+  if (ctx.substitutions === void 0 || !import_ts_morph47.Node.isIdentifier(value)) {
     return value;
   }
   return ctx.substitutions.get(value.getText()) ?? value;
@@ -10645,10 +10890,10 @@ function extractStatusCode(ctx) {
   if (result !== null) {
     return result;
   }
-  if (ctx.extraction.defaultStatusCode !== void 0) {
-    return { type: "literal", value: ctx.extraction.defaultStatusCode };
-  }
-  return null;
+  return declaredStatusCode(ctx.extraction);
+}
+function declaredStatusCode(extraction) {
+  return extraction.defaultStatusCode !== void 0 ? { type: "literal", value: extraction.defaultStatusCode } : null;
 }
 function matchConstructorCode(ctorText, codes) {
   const fullMatch = codes[ctorText];
@@ -10665,25 +10910,21 @@ function matchConstructorCode(ctorText, codes) {
   return null;
 }
 function statusOf(value, ctx) {
-  const unwrapped2 = unwrapAs(value);
-  if (import_ts_morph48.Node.isNumericLiteral(unwrapped2)) {
-    return { type: "literal", value: Number(unwrapped2.getText()) };
+  const status = (0, import_values5.constantOf)(evaluatedValue(value, ctx.resolution));
+  if (typeof status === "number") {
+    return { type: "literal", value: status };
   }
-  const resolved = ctx.resolveWrittenValue?.(unwrapped2) ?? null;
-  if (resolved !== null && import_ts_morph48.Node.isNumericLiteral(resolved)) {
-    return { type: "literal", value: Number(resolved.getText()) };
-  }
-  return { type: "dynamic", sourceText: unwrapped2.getText() };
+  return { type: "dynamic", sourceText: unwrapAs(value).getText() };
 }
 function statusFromProperty(obj, name, ctx) {
   const prop = obj.getProperty(name);
   if (prop === void 0) {
     return null;
   }
-  if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
     return { type: "dynamic", sourceText: prop.getName() };
   }
-  if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
+  if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
     return null;
   }
   const value = prop.getInitializer();
@@ -10706,7 +10947,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const first = ctx.throwCallArgs?.[0];
-    if (first !== void 0 && import_ts_morph48.Node.isNumericLiteral(first)) {
+    if (first !== void 0 && import_ts_morph47.Node.isNumericLiteral(first)) {
       const value = first.getLiteralValue();
       if (value >= 100 && value <= 599) {
         return { type: "literal", value };
@@ -10719,7 +10960,7 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     const arg = ctx.throwCallArgs[sc.position];
-    if (arg === void 0 || !import_ts_morph48.Node.isNewExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph47.Node.isNewExpression(arg)) {
       return null;
     }
     const ctorText = arg.getExpression().getText();
@@ -10728,7 +10969,7 @@ function extractStatusCodeFromRule(ctx) {
   if (sc.from === "argumentProperty") {
     const args = ctx.throwCallArgs ?? ctx.calls?.[0]?.getArguments();
     const arg = args?.[sc.position];
-    if (arg === void 0 || !import_ts_morph48.Node.isObjectLiteralExpression(arg)) {
+    if (arg === void 0 || !import_ts_morph47.Node.isObjectLiteralExpression(arg)) {
       return null;
     }
     return statusFromProperty(arg, sc.name, ctx);
@@ -10738,8 +10979,8 @@ function extractStatusCodeFromRule(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === sc.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -10797,8 +11038,8 @@ function extractBody(ctx) {
       return null;
     }
     for (const prop of ctx.returnedObj.getProperties()) {
-      if (!import_ts_morph48.Node.isPropertyAssignment(prop)) {
-        if (import_ts_morph48.Node.isShorthandPropertyAssignment(prop)) {
+      if (!import_ts_morph47.Node.isPropertyAssignment(prop)) {
+        if (import_ts_morph47.Node.isShorthandPropertyAssignment(prop)) {
           if (prop.getName() === b.name) {
             const resolved = ctx.substitutions?.get(prop.getName());
             if (resolved !== void 0) {
@@ -10852,6 +11093,197 @@ function extractBody(ctx) {
   return null;
 }
 
+// src/terminals/jsx.ts
+var import_ts_morph48 = require("ts-morph");
+function tryMatchJsxReturn(node, pattern) {
+  let expr;
+  let source;
+  if (import_ts_morph48.Node.isReturnStatement(node)) {
+    expr = node.getExpression();
+    source = node;
+  } else if (import_ts_morph48.Node.isArrowFunction(node)) {
+    const body = node.getBody();
+    if (body !== void 0 && !import_ts_morph48.Node.isBlock(body)) {
+      expr = body;
+      source = body;
+    }
+  }
+  if (expr === void 0 || source === void 0) {
+    return null;
+  }
+  const tree = jsxToRenderNode(expr);
+  if (tree === null) {
+    return null;
+  }
+  const component = tree.type === "element" ? tree.tag : "Fragment";
+  const terminal = {
+    kind: pattern.kind,
+    statusCode: null,
+    body: null,
+    exceptionType: null,
+    message: null,
+    component,
+    delegateTarget: null,
+    emitEvent: null,
+    renderTree: tree,
+    location: {
+      start: startLineOf(node),
+      end: endLineOf(node)
+    }
+  };
+  return { node, source, terminal };
+}
+function componentTargetOf(tagNode) {
+  if (!import_ts_morph48.Node.isIdentifier(tagNode) || !/^[A-Z]/.test(tagNode.getText())) {
+    return null;
+  }
+  const target = functionTargetOf(tagNode);
+  return target === null ? null : { file: target.file, name: target.name };
+}
+function jsxToRenderNode(node) {
+  if (import_ts_morph48.Node.isJsxElement(node)) {
+    const opening = node.getOpeningElement();
+    const tag = opening.getTagNameNode().getText();
+    const attrs = collectJsxAttributes(opening);
+    const target = componentTargetOf(opening.getTagNameNode());
+    const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
+    return {
+      type: "element",
+      tag,
+      children,
+      ...attrs !== null ? { attrs } : {},
+      ...target !== null ? { target } : {}
+    };
+  }
+  if (import_ts_morph48.Node.isJsxSelfClosingElement(node)) {
+    const tag = node.getTagNameNode().getText();
+    const attrs = collectJsxAttributes(node);
+    const target = componentTargetOf(node.getTagNameNode());
+    return {
+      type: "element",
+      tag,
+      children: [],
+      ...attrs !== null ? { attrs } : {},
+      ...target !== null ? { target } : {}
+    };
+  }
+  if (import_ts_morph48.Node.isJsxFragment(node)) {
+    const children = node.getJsxChildren().map(jsxChildToRenderNode).filter((n) => n !== null);
+    return { type: "element", tag: "Fragment", children };
+  }
+  if (import_ts_morph48.Node.isParenthesizedExpression(node)) {
+    return jsxToRenderNode(node.getExpression());
+  }
+  return null;
+}
+function collectJsxAttributes(opening) {
+  const entries = {};
+  for (const attr of opening.getAttributes()) {
+    if (import_ts_morph48.Node.isJsxSpreadAttribute(attr)) {
+      const exprText = attr.getExpression().getText();
+      entries[`...${exprText}`] = exprText;
+      continue;
+    }
+    if (!import_ts_morph48.Node.isJsxAttribute(attr)) {
+      continue;
+    }
+    const name = attr.getNameNode().getText();
+    const initializer = attr.getInitializer();
+    if (initializer === void 0) {
+      entries[name] = "";
+      continue;
+    }
+    if (import_ts_morph48.Node.isJsxExpression(initializer)) {
+      const inner = initializer.getExpression();
+      entries[name] = inner !== void 0 ? inner.getText() : "";
+      continue;
+    }
+    entries[name] = initializer.getText();
+  }
+  return Object.keys(entries).length > 0 ? entries : null;
+}
+function jsxChildToRenderNode(child) {
+  if (import_ts_morph48.Node.isJsxText(child)) {
+    const text = child.getLiteralText().trim();
+    if (text.length === 0) {
+      return null;
+    }
+    return { type: "text", value: text };
+  }
+  if (import_ts_morph48.Node.isJsxExpression(child)) {
+    const inner = child.getExpression();
+    if (inner === void 0) {
+      return null;
+    }
+    return jsxExpressionToRenderNode(inner);
+  }
+  if (import_ts_morph48.Node.isJsxElement(child) || import_ts_morph48.Node.isJsxSelfClosingElement(child) || import_ts_morph48.Node.isJsxFragment(child)) {
+    return jsxToRenderNode(child);
+  }
+  return null;
+}
+function jsxExpressionToRenderNode(expr) {
+  if (import_ts_morph48.Node.isParenthesizedExpression(expr)) {
+    return jsxExpressionToRenderNode(expr.getExpression());
+  }
+  if (import_ts_morph48.Node.isBinaryExpression(expr)) {
+    const op = expr.getOperatorToken().getText();
+    if (op === "&&") {
+      const right = renderAlternative(peelParens(expr.getRight()));
+      if (right.kind === "jsx") {
+        return {
+          type: "conditional",
+          condition: expr.getLeft().getText(),
+          whenTrue: right.node,
+          whenFalse: null
+        };
+      }
+    }
+  }
+  if (import_ts_morph48.Node.isConditionalExpression(expr)) {
+    const truthy = renderAlternative(peelParens(expr.getWhenTrue()));
+    const falsy = renderAlternative(peelParens(expr.getWhenFalse()));
+    if (truthy.kind === "jsx") {
+      return {
+        type: "conditional",
+        condition: expr.getCondition().getText(),
+        whenTrue: truthy.node,
+        whenFalse: falsy.kind === "jsx" ? falsy.node : null
+      };
+    }
+    if (falsy.kind === "jsx") {
+      return {
+        type: "conditional",
+        condition: `!(${expr.getCondition().getText()})`,
+        whenTrue: falsy.node,
+        whenFalse: null
+      };
+    }
+  }
+  return { type: "expression", sourceText: expr.getText() };
+}
+function renderAlternative(node) {
+  if (import_ts_morph48.Node.isNullLiteral(node)) {
+    return { kind: "noRender" };
+  }
+  if (import_ts_morph48.Node.isFalseLiteral(node)) {
+    return { kind: "noRender" };
+  }
+  if (import_ts_morph48.Node.isIdentifier(node) && node.getText() === "undefined") {
+    return { kind: "noRender" };
+  }
+  if (import_ts_morph48.Node.isJsxElement(node) || import_ts_morph48.Node.isJsxSelfClosingElement(node) || import_ts_morph48.Node.isJsxFragment(node)) {
+    const tree = jsxToRenderNode(node);
+    if (tree !== null) {
+      return { kind: "jsx", node: tree };
+    }
+  }
+  return { kind: "notStatic" };
+}
+
+// src/terminals/returns.ts
+var import_ts_morph51 = require("ts-morph");
+
 // src/terminals/helperResolution.ts
 var import_ts_morph49 = require("ts-morph");
 function resolveHelperReturn(call, resolveCallee2) {
@@ -11104,13 +11536,14 @@ function bindArguments(callArgs, params) {
 
 // src/terminals/statusBranches.ts
 var import_ts_morph50 = require("ts-morph");
-function statusChoicesOf(argument) {
+var import_values6 = require("@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;
   }
@@ -11141,20 +11574,14 @@ function asConditional(node) {
   return only === void 0 ? null : toConditional(only);
 }
 var toConditional = (node) => import_ts_morph50.Node.isConditionalExpression(node) ? node : null;
-function numberOf(node) {
-  const inner = unwrap(node);
-  if (!import_ts_morph50.Node.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 = (0, import_values6.constantOf)(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;
   }
@@ -11170,7 +11597,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;
@@ -11184,11 +11614,22 @@ function unwrapMethodChain(call, methodChain, func, paramPos) {
   }
   return { calls: collected };
 }
+function withoutPassThroughCalls(subject, passThrough) {
+  let current2 = subject;
+  while (import_ts_morph51.Node.isCallExpression(current2)) {
+    const callee = current2.getExpression();
+    if (!import_ts_morph51.Node.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 (import_ts_morph51.Node.isObjectLiteralExpression(node)) {
     const source = returnPositionOf(node);
     if (source === null) {
@@ -11203,7 +11644,7 @@ function tryMatchReturnShape(node, pattern, match, resolveWrittenValue, resolveC
       pattern,
       match,
       void 0,
-      resolveWrittenValue
+      resolution
     );
     return terminal === null ? [] : [{ ...terminal, source }];
   }
@@ -11221,7 +11662,7 @@ function tryMatchReturnShape(node, pattern, match, resolveWrittenValue, resolveC
       pattern,
       match,
       void 0,
-      resolveWrittenValue
+      resolution
     );
     return terminal === null ? [] : [terminal];
   }
@@ -11249,7 +11690,7 @@ function tryMatchReturnShape(node, pattern, match, resolveWrittenValue, resolveC
       pattern,
       match,
       resolved.substitutions,
-      resolveWrittenValue
+      resolution
     );
     if (terminal !== null) {
       terminals.push(terminal);
@@ -11257,7 +11698,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();
@@ -11276,7 +11717,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);
@@ -11306,16 +11747,11 @@ function terminalFromReturnedObject(obj, anchor, pattern, match, substitutions,
     }
   };
 }
-function tryMatchParameterMethodCall(node, func, pattern, match, resolveWrittenValue) {
+function tryMatchParameterMethodCall(node, func, pattern, match, resolution) {
   if (!import_ts_morph51.Node.isCallExpression(node)) {
     return [];
   }
-  const result = unwrapMethodChain(
-    node,
-    match.methodChain,
-    func,
-    match.parameterPosition
-  );
+  const result = unwrapMethodChain(node, match, func);
   if (result === null) {
     return [];
   }
@@ -11324,7 +11760,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);
@@ -11345,7 +11781,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 }];
   }
@@ -11379,12 +11815,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;
     }
@@ -11424,10 +11855,9 @@ function tryMatchReturnStatement(node, pattern, func, allPatterns) {
   return null;
 }
 function buildReturnTerminal(locationNode, pattern, body) {
-  const statusCode = pattern.extraction.defaultStatusCode !== void 0 ? { type: "literal", value: pattern.extraction.defaultStatusCode } : null;
   const terminal = {
     kind: pattern.kind,
-    statusCode,
+    statusCode: declaredStatusCode(pattern.extraction),
     body,
     exceptionType: null,
     message: null,
@@ -11482,7 +11912,7 @@ function calleeSubject(callee) {
   }
   return null;
 }
-function tryMatchFunctionCall(node, pattern, match, resolveWrittenValue, originatesFrom) {
+function tryMatchFunctionCall(node, pattern, match, resolution, originatesFrom) {
   if (!import_ts_morph51.Node.isCallExpression(node) && !import_ts_morph51.Node.isNewExpression(node)) {
     return null;
   }
@@ -11501,7 +11931,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);
@@ -11526,7 +11956,7 @@ function tryMatchFunctionCall(node, pattern, match, resolveWrittenValue, origina
 
 // src/terminals/throws.ts
 var import_ts_morph52 = require("ts-morph");
-function tryMatchThrowExpression(node, pattern, match, resolveWrittenValue) {
+function tryMatchThrowExpression(node, pattern, match, resolution) {
   if (!import_ts_morph52.Node.isThrowStatement(node)) {
     return null;
   }
@@ -11541,7 +11971,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);
@@ -11597,7 +12027,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)) {
@@ -11615,7 +12045,7 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolveWrittenVal
           node,
           pattern,
           pattern.match,
-          resolveWrittenValue,
+          resolution,
           resolveCallee2
         );
         if (matches.length > 0) {
@@ -11630,7 +12060,7 @@ function findTerminals(func, patterns, barriers = NO_BARRIERS, resolveWrittenVal
           func,
           pattern,
           pattern.match,
-          resolveWrittenValue
+          resolution
         );
         if (matches.length > 0) {
           results.push(...matches);
@@ -11647,14 +12077,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") {
@@ -11716,15 +12146,15 @@ function functionMayFallThrough(func) {
   }
   return true;
 }
-function makeFallthroughTerminal(func) {
+function makeFallthroughTerminal(func, pattern) {
   const body = func.getBody();
   const anchor = body ?? func;
   const line = endLineOf(anchor);
   return {
     node: anchor,
     terminal: {
-      kind: "return",
-      statusCode: null,
+      kind: pattern.kind,
+      statusCode: declaredStatusCode(pattern.extraction),
       body: null,
       exceptionType: null,
       message: null,
@@ -11810,15 +12240,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(
@@ -11843,15 +12274,15 @@ function extractRawBranches(func, terminalPatterns, invocationRecognizers = [],
     terminals.map(({ node }) => node),
     barriers
   );
-  const wantsFallthrough = terminalPatterns.some(
+  const fallthroughPattern = terminalPatterns.find(
     (p) => p.match.type === "functionFallthrough"
   );
-  if (wantsFallthrough && functionMayFallThrough(func)) {
+  if (fallthroughPattern !== void 0 && functionMayFallThrough(func)) {
     const hasDefaultTerminal = terminals.some(
       ({ node }) => (byTerminal.get(node) ?? []).some(isDefaultConditionList)
     );
     if (!hasDefaultTerminal) {
-      const synthetic = makeFallthroughTerminal(func);
+      const synthetic = makeFallthroughTerminal(func, fallthroughPattern);
       terminals.push(synthetic);
       const pathResult = computePathConditions(
         func,
@@ -11995,7 +12426,7 @@ function indexFunctions(sf) {
 
 // src/contract.ts
 var import_ts_morph56 = require("ts-morph");
-var import_behavioral_ir5 = require("@suss/behavioral-ir");
+var import_behavioral_ir4 = require("@suss/behavioral-ir");
 function extractDeclaredBody(node) {
   if (node === void 0) {
     return null;
@@ -12174,7 +12605,7 @@ function extractEndpointContract(endpointNode, pattern, framework) {
   if (responses.length === 0) {
     return null;
   }
-  const boundaryBinding = method !== void 0 || path14 !== void 0 ? (0, import_behavioral_ir5.restBinding)({
+  const boundaryBinding = method !== void 0 || path14 !== void 0 ? (0, import_behavioral_ir4.restBinding)({
     transport: "http",
     method: method ?? null,
     path: path14 ?? null,
@@ -12375,7 +12806,7 @@ function parameterName(segment, convention) {
 // src/discovery/graphqlClientConstruction.ts
 var import_picomatch2 = __toESM(require("picomatch"), 1);
 var import_ts_morph57 = require("ts-morph");
-var import_behavioral_ir6 = require("@suss/behavioral-ir");
+var import_behavioral_ir5 = require("@suss/behavioral-ir");
 function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
   const scopes = compileOperationScopes(packs);
   const sole = soleGraphqlClientRef(
@@ -12385,10 +12816,10 @@ function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
   const soleClient = sole !== null ? workspace !== null ? { ...sole, workspace } : sole : null;
   let registry = null;
   for (const summary of summaries) {
-    if (!(0, import_behavioral_ir6.isGraphqlOperationBinding)(summary.identity.boundaryBinding)) {
+    if (!(0, import_behavioral_ir5.isGraphqlOperationBinding)(summary.identity.boundaryBinding)) {
       continue;
     }
-    const existing = (0, import_behavioral_ir6.readGraphqlMetadata)(summary) ?? {};
+    const existing = (0, import_behavioral_ir5.readGraphqlMetadata)(summary) ?? {};
     const scoped = scopedWorkspaceFor(summary.location.file, scopes);
     const client = scoped !== null ? { uri: null, uriRef: null, workspace: scoped } : soleClient;
     const dangling = (existing.unresolvedFragments?.length ?? 0) > 0;
@@ -12398,7 +12829,7 @@ function stampGraphqlClientRefs(summaries, sourceFiles, packs, resolution) {
     if (dangling && registry === null) {
       registry = fragmentRegistryStatus(sourceFiles, packs);
     }
-    summary.metadata = (0, import_behavioral_ir6.withGraphqlMetadata)(summary.metadata, {
+    summary.metadata = (0, import_behavioral_ir5.withGraphqlMetadata)(summary.metadata, {
       ...existing,
       ...client !== null ? { client } : {},
       ...dangling && registry !== null ? { fragmentRegistry: registry } : {}
@@ -13564,7 +13995,7 @@ function deriveBoundaryEffects(summaries, facts) {
 
 // src/resolve/reachableClosure.ts
 var import_ts_morph62 = require("ts-morph");
-var import_behavioral_ir7 = require("@suss/behavioral-ir");
+var import_behavioral_ir6 = require("@suss/behavioral-ir");
 var import_datalog4 = require("@suss/datalog");
 var import_extractor7 = require("@suss/extractor");
 var reachablePack = {
@@ -13682,7 +14113,7 @@ function collectReachable(func, scan) {
   const inFunc = { ...scan, scanning: func };
   const candidates = [];
   const stops = [];
-  const placements = new import_behavioral_ir7.TargetPlacements();
+  const placements = new import_behavioral_ir6.TargetPlacements();
   const parameterCalls = [];
   const passedPositions = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
@@ -13690,7 +14121,7 @@ function collectReachable(func, scan) {
   const record2 = (outcome) => {
     if (outcome.kind === "stopped") {
       const stopKey = `${outcome.stop.reason}:${outcome.stop.callee}`;
-      if (!seen.has(stopKey) && (0, import_behavioral_ir3.worthRecording)(outcome.stop.reason)) {
+      if (!seen.has(stopKey) && (0, import_behavioral_ir2.worthRecording)(outcome.stop.reason)) {
         seen.add(stopKey);
         stops.push(outcome.stop);
       }
@@ -13772,9 +14203,9 @@ function extractReachableSummary(candidate, options, recognizers) {
     recognizers.invocation,
     recognizers.access,
     void 0,
-    recognizers.resolveWrittenValue
+    recognizers.resolution
   );
-  raw.boundaryBinding = (0, import_behavioral_ir7.functionCallBinding)({
+  raw.boundaryBinding = (0, import_behavioral_ir6.functionCallBinding)({
     transport: "in-process",
     recognition: "reachable"
   });
@@ -13979,7 +14410,7 @@ function recordStops(stopsByKey, summariesByKey, options) {
   }
   for (const [key, stops] of stopsByKey) {
     for (const summary of summariesByKey.get(key) ?? []) {
-      summary.gaps.push(...stops.map(import_behavioral_ir3.unfollowedCallGap));
+      summary.gaps.push(...stops.map(import_behavioral_ir2.unfollowedCallGap));
     }
   }
 }
@@ -14061,7 +14492,7 @@ function recordParameterGaps(parameterCallsByKey, summariesByKey, passedPosition
     for (const summary of summariesByKey.get(key) ?? []) {
       summary.gaps.push(
         ...unbound.map(
-          ({ callee }) => (0, import_behavioral_ir3.unfollowedCallGap)({ callee, reason: "unboundParameter" })
+          ({ callee }) => (0, import_behavioral_ir2.unfollowedCallGap)({ callee, reason: "unboundParameter" })
         )
       );
     }
@@ -14375,7 +14806,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 [];
   }
@@ -14428,7 +14859,7 @@ function firstCallbackParamName(callback) {
   const nameNode = param.getNameNode();
   return import_ts_morph64.Node.isIdentifier(nameNode) ? nameNode.getText() : null;
 }
-function unwrap2(expr) {
+function unwrap(expr) {
   let node = expr;
   while (import_ts_morph64.Node.isAwaitExpression(node) || import_ts_morph64.Node.isParenthesizedExpression(node) || import_ts_morph64.Node.isAsExpression(node)) {
     node = node.getExpression();
@@ -14443,7 +14874,7 @@ function chainRootedAt(expr, rootName) {
   return import_ts_morph64.Node.isIdentifier(chain.root) && chain.root.getText() === rootName ? chain.segments : null;
 }
 function memberChain(expr) {
-  let node = import_ts_morph64.Node.isExpression(expr) ? unwrap2(expr) : expr;
+  let node = import_ts_morph64.Node.isExpression(expr) ? unwrap(expr) : expr;
   if (import_ts_morph64.Node.isCallExpression(node)) {
     node = node.getExpression();
   }
@@ -14799,7 +15230,7 @@ function readArrayLiteralText(node) {
 
 // src/summaryIdentity.ts
 var import_node_path8 = __toESM(require("path"), 1);
-var import_behavioral_ir8 = require("@suss/behavioral-ir");
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
 function workspaceRootFor(anchor) {
   return namedPackageDirAbove(anchor) ?? import_node_path8.default.resolve(anchor);
 }
@@ -14822,8 +15253,8 @@ function nameSummaries(summaries, args) {
     }
     summary.identity.id = idFor(args.workspace, file, summary);
   }
-  (0, import_behavioral_ir8.disambiguateSummaryIds)(summaries);
-  (0, import_behavioral_ir8.linkCallsToSummaries)(summaries);
+  (0, import_behavioral_ir7.disambiguateSummaryIds)(summaries);
+  (0, import_behavioral_ir7.linkCallsToSummaries)(summaries);
 }
 function relativeFile(file, projectRoot) {
   if (projectRoot === void 0 || !import_node_path8.default.isAbsolute(file)) {
@@ -14833,7 +15264,7 @@ function relativeFile(file, projectRoot) {
   return relative.startsWith("..") ? file : relative;
 }
 function idFor(workspace, file, summary) {
-  return (0, import_behavioral_ir8.summaryIdFromParts)({
+  return (0, import_behavioral_ir7.summaryIdFromParts)({
     workspace: workspace ?? void 0,
     file,
     name: summary.identity.name,
@@ -15337,7 +15768,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,
@@ -15345,7 +15776,7 @@ function extractCodeStructure(unit, pack, invocationRecognizers = [], accessReco
       invocationRecognizers,
       accessRecognizers,
       barriers,
-      resolveWrittenValue,
+      resolution,
       originatesFrom,
       anchorCallsOf,
       resolveCallee2
@@ -15430,7 +15861,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);
@@ -15445,7 +15876,7 @@ function readCodeStructure(unit, pack, invocationRecognizers, accessRecognizers,
     invocationRecognizers,
     accessRecognizers,
     barriers,
-    resolveWrittenValue,
+    resolution,
     originatesFrom,
     anchorCallsOf,
     resolveCallee2
@@ -15526,7 +15957,7 @@ function extractConsumerBinding(unit, pattern, pack, resolution) {
   }
   const method = extractBindingMethod(binding, callSite, pack, resolution);
   const path14 = extractBindingPath(binding, callSite, pack, resolution);
-  return (0, import_behavioral_ir9.restBinding)({
+  return (0, import_behavioral_ir8.restBinding)({
     transport: pack.protocol,
     method: method ?? null,
     path: path14 ?? null,
@@ -15545,7 +15976,7 @@ function fileRouteBinding(filePath, unit, binding, pack) {
   if (method === void 0) {
     return null;
   }
-  return (0, import_behavioral_ir9.restBinding)({
+  return (0, import_behavioral_ir8.restBinding)({
     transport: pack.protocol,
     recognition: pack.name,
     method,
@@ -15567,21 +15998,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 && import_ts_morph66.Node.isObjectLiteralExpression(arg)) {
-      const prop = arg.getProperty(m.property);
-      if (prop !== void 0 && import_ts_morph66.Node.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;
@@ -15784,7 +16203,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, module2) => resolution.importOriginsOf(value, [module2]).length > 0,
         resolution === void 0 ? void 0 : (value, matches) => resolution.anchorCallsOf(value, matches),
         resolution === void 0 ? void 0 : (value) => resolution.resolveCallable(value)
@@ -15798,7 +16217,7 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
       stampWrappers(raw, unit, wrappers);
       const matchedPattern = unit.pattern ?? pack.discovery.find((d) => d.kind === unit.kind);
       if (unit.resolverInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir9.graphqlResolverBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir8.graphqlResolverBinding)({
           transport: pack.protocol,
           recognition: pack.name,
           typeName: unit.resolverInfo.typeName,
@@ -15825,26 +16244,26 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
           }
         }
       } else if (unit.routeInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir9.restBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir8.restBinding)({
           transport: pack.protocol,
           recognition: pack.name,
           method: unit.routeInfo.method,
           path: unit.routeInfo.path
         });
       } else if (unit.channelInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir9.messageBusBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir8.messageBusBinding)({
           recognition: pack.name,
           messageBus: unit.channelInfo.messageBus,
           channel: unit.channelInfo.channel
         });
       } else if (unit.invocationInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir9.unitInvocationBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir8.unitInvocationBinding)({
           recognition: pack.name,
           deploymentTarget: unit.invocationInfo.deploymentTarget,
           instanceName: unit.invocationInfo.instanceName
         });
       } else if (unit.operationInfo !== void 0) {
-        raw.boundaryBinding = (0, import_behavioral_ir9.graphqlOperationBinding)({
+        raw.boundaryBinding = (0, import_behavioral_ir8.graphqlOperationBinding)({
           transport: pack.protocol,
           recognition: pack.name,
           operationType: unit.operationInfo.operationType,
@@ -15933,14 +16352,14 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
       }
       if (raw.boundaryBinding === null) {
         if (unit.packageExportInfo !== void 0) {
-          raw.boundaryBinding = (0, import_behavioral_ir9.packageExportBinding)({
+          raw.boundaryBinding = (0, import_behavioral_ir8.packageExportBinding)({
             transport: pack.protocol,
             recognition: pack.name,
             packageName: unit.packageExportInfo.packageName,
             exportPath: unit.packageExportInfo.exportPath
           });
         } else {
-          raw.boundaryBinding = (0, import_behavioral_ir9.functionCallBinding)({
+          raw.boundaryBinding = (0, import_behavioral_ir8.functionCallBinding)({
             transport: pack.protocol,
             recognition: pack.name,
             ...unit.functionCallInfo !== void 0 ? {
@@ -15952,7 +16371,7 @@ function extractFromSourceFile(sourceFile, frameworks, claimedUnits, options, ta
       }
       const summary = (0, import_extractor11.assembleSummary)(raw, options);
       if (unit.unfollowed !== void 0 && options?.gapHandling !== "silent") {
-        summary.gaps.push((0, import_behavioral_ir3.unfollowedCallGap)(unit.unfollowed));
+        summary.gaps.push((0, import_behavioral_ir2.unfollowedCallGap)(unit.unfollowed));
       }
       if (unit.metadata !== void 0 && Object.keys(unit.metadata).length > 0) {
         summary.metadata = {
@@ -16032,14 +16451,14 @@ function fileImporting(project, modulePrefix) {
 function liftSchemasOntoDocuments(summaries) {
   const sdlByDocument = /* @__PURE__ */ new Map();
   for (const summary of summaries) {
-    const label = (0, import_behavioral_ir9.readSourceDocumentMetadata)(summary)?.label;
-    const graphql = (0, import_behavioral_ir9.readGraphqlMetadata)(summary);
+    const label = (0, import_behavioral_ir8.readSourceDocumentMetadata)(summary)?.label;
+    const graphql = (0, import_behavioral_ir8.readGraphqlMetadata)(summary);
     if (label === void 0 || graphql?.schemaSdl === void 0) {
       continue;
     }
     sdlByDocument.set(label, graphql.schemaSdl);
     const { schemaSdl: _movedToTheDocument, ...rest } = graphql;
-    summary.metadata = (0, import_behavioral_ir9.withGraphqlMetadata)(summary.metadata, rest);
+    summary.metadata = (0, import_behavioral_ir8.withGraphqlMetadata)(summary.metadata, rest);
   }
   for (const [label, schemaSdl] of sdlByDocument) {
     summaries.push(schemaDocumentSummary(label, schemaSdl));
@@ -16054,8 +16473,8 @@ function schemaDocumentSummary(label, schemaSdl) {
     transitions: [],
     gaps: [],
     confidence: { source: "declared", level: "high" },
-    metadata: (0, import_behavioral_ir9.withGraphqlMetadata)(
-      (0, import_behavioral_ir9.withSourceDocumentMetadata)(void 0, { label }),
+    metadata: (0, import_behavioral_ir8.withGraphqlMetadata)(
+      (0, import_behavioral_ir8.withSourceDocumentMetadata)(void 0, { label }),
       { schemaSdl }
     )
   };
@@ -16067,7 +16486,7 @@ function libraryEnvReadMarker(pack, declared, importer) {
     identity: {
       name: `${declared.module} env reads`,
       exportPath: null,
-      boundaryBinding: (0, import_behavioral_ir9.functionCallBinding)({
+      boundaryBinding: (0, import_behavioral_ir8.functionCallBinding)({
         transport: "in-process",
         recognition: pack.name
       })
@@ -16278,7 +16697,7 @@ function buildCallerSummary(wrapper, callerFunc, callExpr, path14, options) {
     }
   };
   const raw = extractCodeStructure(unit, syntheticPack);
-  raw.boundaryBinding = (0, import_behavioral_ir9.restBinding)({
+  raw.boundaryBinding = (0, import_behavioral_ir8.restBinding)({
     transport: wrapperBinding?.transport ?? "http",
     method: wrapperRest?.method ?? null,
     path: path14,
@@ -16618,7 +17037,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)
           },
@@ -16851,10 +17270,10 @@ function mergeWithReused(reused, fresh, ownersBySummary) {
   return { summaries: [...reusedKept, ...fresh], reusedKept, reusedOwners };
 }
 function readsRunLevelJoins(summary) {
-  if ((0, import_behavioral_ir9.readSourceDocumentMetadata)(summary) !== void 0) {
+  if ((0, import_behavioral_ir8.readSourceDocumentMetadata)(summary) !== void 0) {
     return true;
   }
-  if ((0, import_behavioral_ir9.readGraphqlMetadata)(summary)?.client !== void 0) {
+  if ((0, import_behavioral_ir8.readGraphqlMetadata)(summary)?.client !== void 0) {
     return true;
   }
   const semantics = summary.identity.boundaryBinding?.semantics;