@moda-ai/cli 1.55.64 → 1.55.66

package/dist/{cli-vqhaj5tv.js → cli-28mf9mhw.js}

@@ -258,8 +258,13 @@ var MAX_MEMBERS = 400;
 var MAX_MUTATIONS = 64;
 var DEFAULT_CALLER_DEPTH = 3;
 var TEXT_HELPERS = new Set(["dedent", "outdent", "stripIndent", "stripIndents", "oneLine", "oneLineTrim", "String"]);
-var TRIM_METHODS = new Set(["trim", "trimStart", "trimEnd"]);
-var CASE_METHODS = new Set(["toLowerCase", "toUpperCase"]);
+var STRING_METHODS = {
+  trim: (text) => text.trim(),
+  trimStart: (text) => text.trimStart(),
+  trimEnd: (text) => text.trimEnd(),
+  toLowerCase: (text) => text.toLowerCase(),
+  toUpperCase: (text) => text.toUpperCase()
+};
 var EMPTY_ENV = new Map;
 function envFrom(bindings) {
   const env = new Map;
@@ -366,7 +371,16 @@ function mutationsIn(scope) {
       const target = node.expression.expression;
       if (op === "splice") {
         const first = node.arguments[0] ? unwrap(node.arguments[0]) : undefined;
-        add({ op, at: node, target, values: [...node.arguments.slice(2)], index: first && import_typescript2.default.isNumericLiteral(first) ? Number(first.text) : undefined });
+        const count = node.arguments[1] ? unwrap(node.arguments[1]) : undefined;
+        add({
+          op,
+          at: node,
+          target,
+          values: [...node.arguments.slice(2)],
+          index: first && import_typescript2.default.isNumericLiteral(first) ? Number(first.text) : undefined,
+          deleteCount: count && import_typescript2.default.isNumericLiteral(count) ? Number(count.text) : undefined,
+          deleteUnknown: count !== undefined && !import_typescript2.default.isNumericLiteral(count)
+        });
       } else {
         add({ op, at: node, target, values: [...node.arguments] });
       }
@@ -417,6 +431,7 @@ class ValueTracer {
   checker;
   calls;
   modelArgOf;
+  program;
   maxDepth;
   maxCallers;
   maxNodes;
@@ -425,11 +440,13 @@ class ValueTracer {
   callerLevel = 0;
   stack = new Set;
   reassigning = new Set;
-  constructor(rootDir, checker, calls, options = {}, modelArgOf) {
+  writes = new Map;
+  constructor(rootDir, checker, calls, options = {}, modelArgOf, program) {
     this.rootDir = rootDir;
     this.checker = checker;
     this.calls = calls;
     this.modelArgOf = modelArgOf;
+    this.program = program;
     this.maxDepth = options.maxDepth ?? DEFAULT_TRACE_DEPTH;
     this.maxCallers = options.maxCallers ?? DEFAULT_MAX_CALLERS;
     this.maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
@@ -487,12 +504,12 @@ class ValueTracer {
       return this.node("literal", expr, { text: expr.text, resolution: "resolved" });
     }
     if (import_typescript2.default.isNumericLiteral(expr) || import_typescript2.default.isBigIntLiteral(expr))
-      return this.node("literal", expr, { text: expr.text, resolution: "resolved" });
+      return this.node("literal", expr, { text: expr.text, note: "number", resolution: "resolved" });
     if (expr.kind === import_typescript2.default.SyntaxKind.TrueKeyword || expr.kind === import_typescript2.default.SyntaxKind.FalseKeyword) {
-      return this.node("literal", expr, { text: expr.getText(), resolution: "resolved" });
+      return this.node("literal", expr, { text: expr.getText(), note: "boolean", resolution: "resolved" });
     }
     if (expr.kind === import_typescript2.default.SyntaxKind.NullKeyword || import_typescript2.default.isVoidExpression(expr) || import_typescript2.default.isIdentifier(expr) && expr.text === "undefined") {
-      return this.node("external", expr, { resolution: "unresolved", note: "nullish", name: "undefined", unresolvedReason: "external" });
+      return this.node("external", expr, { resolution: "unresolved", note: "nullish", name: expr.kind === import_typescript2.default.SyntaxKind.NullKeyword ? "null" : "undefined", unresolvedReason: "external" });
     }
     if (import_typescript2.default.isTemplateExpression(expr))
       return this.template(expr, depth, env);
@@ -569,9 +586,17 @@ class ValueTracer {
       const children = [left, this.value(expr.right, depth, env)];
       return this.node("oneOf", expr, { children, resolution: rollup(children), note: operator === import_typescript2.default.SyntaxKind.BarBarToken ? "||" : "??" });
     }
-    if (operator === import_typescript2.default.SyntaxKind.AmpersandAmpersandToken || operator === import_typescript2.default.SyntaxKind.CommaToken) {
+    if (operator === import_typescript2.default.SyntaxKind.CommaToken) {
       const child = this.value(expr.right, depth, env);
-      return this.node("oneOf", expr, { children: [child], resolution: child.resolution, note: operator === import_typescript2.default.SyntaxKind.CommaToken ? "," : "&&" });
+      return this.node("oneOf", expr, { children: [child], resolution: child.resolution, note: "," });
+    }
+    if (operator === import_typescript2.default.SyntaxKind.AmpersandAmpersandToken) {
+      const left = this.value(expr.left, depth, env);
+      if (provenFalsy(left))
+        return left;
+      const right = this.value(expr.right, depth, env);
+      const children = provenTruthy(left) ? [right] : [{ ...left, note: "falsy left of &&" }, right];
+      return this.node("oneOf", expr, { children, resolution: rollup(children), note: "&&" });
     }
     return this.external(expr, `binary ${import_typescript2.default.tokenToString(operator) ?? import_typescript2.default.SyntaxKind[operator]}`);
   }
@@ -617,15 +642,22 @@ class ValueTracer {
       return this.node("oneOf", id, { name: id.text, children: values, resolution: rollup(values), note: "for-of element" });
     }
     if (import_typescript2.default.isVariableDeclaration(declaration)) {
-      const mutations = this.mutations(symbol, declaration);
+      const mutations = mutationsReaching(this.mutations(symbol, declaration), id);
       if (mutations.some((mutation) => mutation.op !== "="))
         return this.assembled(id, declaration, mutations, depth, env);
       const sources = [];
       if (declaration.initializer)
         sources.push(this.hop(declaration.initializer, depth, env));
-      sources.push(...this.reassignments(declaration, mutations, depth, env));
+      for (const mutation of mutations) {
+        if (mutation.op === "=" && !mayNotRun(mutation.at, declaration))
+          sources.length = 0;
+        sources.push(...this.reassignments(declaration, [mutation], depth, env));
+      }
       if (sources.length === 0)
         return this.external(id, "declared without a value", id.text);
+      const written = this.propertyWrites(symbol, declaration, id, sources, depth, env);
+      if (written)
+        return this.node("ref", id, { name: id.text, children: [written], resolution: written.resolution, note: "properties assigned" });
       return this.node("ref", id, { name: id.text, children: sources, resolution: rollup(sources), note: sources.length > 1 ? "reassigned" : undefined });
     }
     if (import_typescript2.default.isEnumMember(declaration) || import_typescript2.default.isPropertyAssignment(declaration) || import_typescript2.default.isPropertyDeclaration(declaration)) {
@@ -679,15 +711,33 @@ class ValueTracer {
     }
     this.reassigning.add(declaration);
     try {
-      for (const mutation of mutations) {
-        const values = mutation.values.slice(0, MAX_MEMBERS).map((value) => tag(this.element(value, depth + 1, env), mutation.op));
+      for (const mutation of mutationsReaching(mutations, id)) {
+        const uncertain = mayNotRun(mutation.at, declaration);
+        const traced = (value) => {
+          const element = unwrap(value);
+          if (mutation.op === "concat" && import_typescript2.default.isArrayLiteralExpression(element))
+            return element.elements.slice(0, MAX_MEMBERS).map((item) => this.element(item, depth + 1, env));
+          if (mutation.op === "concat" && !import_typescript2.default.isSpreadElement(value)) {
+            const traced2 = this.value(value, depth + 1, env);
+            const type = this.checker.getTypeAtLocation(value);
+            return [this.checker.isArrayType(type) || this.checker.isTupleType(type) ? { ...traced2, key: "..." } : traced2];
+          }
+          return [this.element(value, depth + 1, env)];
+        };
+        const values = mutation.values.slice(0, MAX_MEMBERS).flatMap(traced).map((value) => tag(uncertain ? atMostPartial(value) : value, mutation.op));
         if (mutation.op === "=") {
-          items.length = 0;
+          if (uncertain)
+            items.splice(0, items.length, ...items.map(atMostPartial));
+          else
+            items.length = 0;
           items.push(...values);
         } else if (mutation.op === "unshift") {
           items.unshift(...values);
-        } else if (mutation.op === "splice" && mutation.index !== undefined) {
-          items.splice(Math.min(mutation.index, items.length), 0, ...values);
+        } else if (mutation.op === "splice" && mutation.index !== undefined && !mutation.deleteUnknown && !uncertain) {
+          const start = mutation.index < 0 ? Math.max(items.length + mutation.index, 0) : Math.min(mutation.index, items.length);
+          items.splice(start, mutation.deleteCount ?? items.length, ...values);
+        } else if (mutation.op === "splice") {
+          items.splice(0, items.length, ...items.map(atMostPartial), ...values);
         } else {
           items.push(...values);
         }
@@ -703,6 +753,69 @@ class ValueTracer {
       text: arrayOps || init && import_typescript2.default.isArrayLiteralExpression(init) ? "array" : isString ? "string" : undefined
     });
   }
+  propertyWrites(symbol, declaration, at, sources, depth, env) {
+    const writes = this.writesOf(symbol, declaration);
+    if (writes.size === 0)
+      return;
+    const initial = sources.length === 1 ? sources[0] : this.node("oneOf", at, { children: sources, resolution: rollup(sources), note: "reassigned" });
+    const children = [{ ...initial, key: "..." }];
+    for (const [key, all] of writes) {
+      const replacements = mutationsReaching(this.mutations(symbol, declaration), at).filter((mutation) => mutation.op === "=" && !mayNotRun(mutation.at, declaration));
+      const lastReplacement = replacements.at(-1)?.at.pos ?? -1;
+      const list = all.filter((write) => mutationsReaching([{ at: write.node }], at).length > 0 && write.node.pos > lastReplacement);
+      if (list.length === 0)
+        continue;
+      const lastDirect = list.reduce((found, write, index) => write.direct ? index : found, -1);
+      const values = list.slice(Math.max(lastDirect, 0)).map((write) => this.hop(write.node.right, depth, env));
+      if (lastDirect < 0) {
+        const missing = this.node("external", at, { resolution: "unresolved", note: "nullish", name: "undefined" });
+        const before = selectKey(initial, key, missing);
+        values.unshift(before);
+      }
+      const value = values.length === 1 ? values[0] : this.node("oneOf", at, { children: values, resolution: rollup(values), note: "property assignment" });
+      children.push({ ...value, key });
+    }
+    if (children.length === 1)
+      return;
+    return this.node("object", at, { children, resolution: rollup(children), note: "properties assigned" });
+  }
+  writesOf(symbol, declaration) {
+    const cached = this.writes.get(symbol);
+    if (cached)
+      return cached;
+    const scope = enclosingScope(declaration);
+    const statement = import_typescript2.default.findAncestor(declaration, import_typescript2.default.isVariableStatement);
+    const writes = new Map;
+    let count = 0;
+    const visit = (node) => {
+      if (count >= MAX_RETURNS)
+        return;
+      if (import_typescript2.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript2.default.SyntaxKind.EqualsToken && (import_typescript2.default.isPropertyAccessExpression(node.left) || import_typescript2.default.isElementAccessExpression(node.left))) {
+        const receiver = unwrap(node.left.expression);
+        const key = import_typescript2.default.isPropertyAccessExpression(node.left) ? node.left.name.text : import_typescript2.default.isStringLiteralLike(node.left.argumentExpression) ? node.left.argumentExpression.text : undefined;
+        if (key && import_typescript2.default.isIdentifier(receiver) && receiver.text === symbol.name && resolvedSymbol(receiver, this.checker) === symbol) {
+          count += 1;
+          const holder = node.parent;
+          const direct = Boolean(statement && import_typescript2.default.isExpressionStatement(holder) && holder.parent === statement.parent && holder.pos > statement.pos);
+          const list = writes.get(key);
+          if (list)
+            list.push({ node, direct });
+          else
+            writes.set(key, [{ node, direct }]);
+        }
+      }
+      import_typescript2.default.forEachChild(node, visit);
+    };
+    visit(scope);
+    this.writes.set(symbol, writes);
+    return writes;
+  }
+  reuse(traced, at) {
+    this.count += treeSize(traced);
+    if (this.count > this.maxNodes)
+      return this.external(at, "node budget reached", undefined, "depth-limit");
+    return traced;
+  }
   parameter(declaration, at, depth, env) {
     const name = import_typescript2.default.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
     const fn = declaration.parent;
@@ -714,7 +827,7 @@ class ValueTracer {
     if (bound) {
       const argument = bound.expr && !isUndefinedLiteral(bound.expr) ? bound.expr : undefined;
       if (argument)
-        bindings.push(bound.traced ?? this.value(argument, depth, bound.env));
+        bindings.push(bound.traced ? this.reuse(bound.traced, declaration) : this.value(argument, depth, bound.env));
       else if (declaration.initializer)
         children.push(this.value(declaration.initializer, depth, env));
       else {
@@ -731,7 +844,7 @@ class ValueTracer {
         reason = "depth-limit";
       } else {
         const index = fn.parameters.indexOf(declaration);
-        const found = fnName ? this.calls.callersOf(fn, fnName, this.maxCallers + 1) : [];
+        const found = fnName ? this.calls.callersOf(fn, fnName, this.maxCallers + 1, this.program) : [];
         const callers = found.slice(0, this.maxCallers);
         this.callerLevel += 1;
         try {
@@ -802,9 +915,10 @@ class ValueTracer {
     const missing = this.missing(at, `no property ${key}`, whole.resolution === "unresolved" ? whole.unresolvedReason : "external");
     let selected = selectKey(whole, key, missing);
     const extra = { name, key, object: shallow(whole), keyNode: this.keyLiteral(element.propertyName ?? element.name, key) };
-    if (element.initializer && hasNode(selected, missing)) {
+    const takesDefault = (node) => node === missing || isUndefinedValue(node);
+    if (element.initializer && hasWhere(selected, takesDefault)) {
       const fallback = this.hop(element.initializer, depth, env);
-      selected = substitute(selected, missing, fallback);
+      selected = substituteWhere(selected, takesDefault, fallback);
       return this.node("lookup", at, { ...extra, children: [selected], resolution: selected.resolution, note: "with default" });
     }
     return this.node("lookup", at, { ...extra, children: [selected], resolution: selected.resolution });
@@ -912,13 +1026,12 @@ class ValueTracer {
       const method = callee.name.text;
       if (method === "join")
         return this.arrayJoin(expr, callee, depth, env);
-      if (TRIM_METHODS.has(method) && expr.arguments.length === 0)
-        return this.value(callee.expression, depth, env);
-      if (CASE_METHODS.has(method) && expr.arguments.length === 0) {
+      const apply = Object.hasOwn(STRING_METHODS, method) ? STRING_METHODS[method] : undefined;
+      if (apply && expr.arguments.length === 0) {
         const receiver = this.value(callee.expression, depth, env);
         const texts = receiver.resolution === "resolved" ? renderings(receiver) : [];
         if (texts.length > 0 && !texts.some((text) => text.includes("${...}"))) {
-          const children = [...new Set(texts)].map((text) => this.node("literal", expr, { text: method === "toLowerCase" ? text.toLowerCase() : text.toUpperCase(), resolution: "resolved" }));
+          const children = [...new Set(texts.map(apply))].map((text) => this.node("literal", expr, { text, resolution: "resolved" }));
           return children.length === 1 ? children[0] : this.node("oneOf", expr, { children, resolution: "resolved", note: method });
         }
         return this.node("call", expr, { name: method, children: [receiver], resolution: receiver.resolution === "resolved" ? "partial" : receiver.resolution });
@@ -961,7 +1074,9 @@ class ValueTracer {
     const live = returns.filter((ret) => this.reachableReturn(ret, fn, depth + 1, inner));
     const values = (live.length > 0 ? live : returns).map((ret) => this.value(ret, depth + 1, inner));
     const calleeTree = values.length === 1 ? values[0] : this.node("oneOf", fn, { children: values, resolution: rollup(values), note: "returns" });
-    return this.node("call", expr, { name, callee: calleeTree, args, ...anchor, resolution: calleeTree.resolution });
+    const embedded = embeddedNodes(calleeTree, new Set(args));
+    const listed = args.map((arg) => embedded.has(arg) ? { ...shallow(arg), note: "bound in callee (see callee bindings)" } : arg);
+    return this.node("call", expr, { name, callee: calleeTree, args: listed, ...anchor, resolution: calleeTree.resolution });
   }
   reachableReturn(ret, fn, depth, env) {
     let node = ret;
@@ -1016,14 +1131,22 @@ class ValueTracer {
   }
   arrayJoin(expr, callee, depth, env) {
     let receiver = unwrap(callee.expression);
+    let filtered = false;
     while (import_typescript2.default.isCallExpression(receiver) && import_typescript2.default.isPropertyAccessExpression(receiver.expression) && receiver.expression.name.text === "filter" && receiver.arguments.length === 1 && import_typescript2.default.isIdentifier(receiver.arguments[0]) && receiver.arguments[0].text === "Boolean") {
+      filtered = true;
       receiver = unwrap(receiver.expression.expression);
     }
     const separatorArg = expr.arguments[0];
     const separator = separatorArg === undefined ? "," : import_typescript2.default.isStringLiteral(separatorArg) || import_typescript2.default.isNoSubstitutionTemplateLiteral(separatorArg) ? separatorArg.text : undefined;
-    const children = import_typescript2.default.isArrayLiteralExpression(receiver) ? receiver.elements.slice(0, MAX_MEMBERS).map((element) => this.element(element, depth, env)) : [this.value(receiver, depth, env)];
-    const resolution = separator === undefined && rollup(children) === "resolved" ? "partial" : rollup(children);
-    return this.node("arrayJoin", expr, { text: separator, children, resolution, note: separator === undefined ? "computed separator" : undefined });
+    let children = import_typescript2.default.isArrayLiteralExpression(receiver) ? receiver.elements.slice(0, MAX_MEMBERS).map((element) => this.element(element, depth, env)) : [{ ...this.value(receiver, depth, env), key: "..." }];
+    if (filtered) {
+      const expanded = joinElements(children);
+      if (expanded)
+        children = expanded.filter((child) => !provenFalsy(child));
+    }
+    const resolution = children.length === 0 ? "resolved" : separator === undefined && rollup(children) === "resolved" ? "partial" : rollup(children);
+    const notes = [separator === undefined ? "computed separator" : undefined, filtered ? "filter(Boolean)" : undefined].filter(Boolean);
+    return this.node("arrayJoin", expr, { text: separator, children, resolution, note: notes.length > 0 ? notes.join("; ") : undefined });
   }
 }
 function alwaysReturns(statement) {
@@ -1080,10 +1203,14 @@ function selectKey(tree, key, missing) {
         return { ...member, key };
       if (member.key === "...") {
         const fromSpread = selectKey(member, key, missing);
-        if (fromSpread !== missing)
+        if (fromSpread !== missing) {
+          if (fromSpread.resolution === "unresolved") {
+            const prior = selectKey({ ...tree, children: members.slice(0, index) }, key, missing);
+            if (prior !== missing)
+              return { ...fromSpread, kind: "oneOf", children: [prior, fromSpread], resolution: "partial", note: "unknown spread may override property" };
+          }
           return fromSpread;
-        if (member.kind !== "object")
-          return { ...missing, note: `property ${key} may come from an unresolved spread` };
+        }
       }
     }
     return missing;
@@ -1100,21 +1227,40 @@ function selectKey(tree, key, missing) {
   return { ...missing, note: `property ${key} of ${tree.kind}${tree.name ? ` ${tree.name}` : ""}` };
 }
 var FLOW_KINDS = new Set(["ref", "call", "param", "oneOf", "lookup"]);
+function isUndefinedValue(node) {
+  return node.kind === "external" && node.note === "nullish" && node.name === "undefined";
+}
+function provenFalsy(node) {
+  if (node.kind === "literal")
+    return node.text === "" || node.note === "boolean" && node.text === "false" || node.note === "number" && /^0n?$/.test(node.text ?? "");
+  if (node.kind === "external")
+    return node.note === "nullish";
+  const flow = FLOW_KINDS.has(node.kind) ? valueChildren(node) : [];
+  return flow.length > 0 && flow.every(provenFalsy);
+}
+function provenTruthy(node) {
+  if (node.kind === "literal")
+    return !provenFalsy(node);
+  if (node.kind === "object" || node.kind === "array")
+    return true;
+  const flow = FLOW_KINDS.has(node.kind) ? valueChildren(node) : [];
+  return flow.length > 0 && flow.every(provenTruthy);
+}
 function leaves(tree) {
   const flow = valueChildren(tree);
   return flow.length > 0 && tree.kind !== "template" ? flow.flatMap(leaves) : [tree];
 }
-function hasNode(tree, target) {
-  return tree === target || valueChildren(tree).some((child) => hasNode(child, target));
+function hasWhere(tree, match) {
+  return match(tree) || valueChildren(tree).some((child) => hasWhere(child, match));
 }
-function substitute(tree, target, replacement) {
-  if (tree === target)
-    return replacement;
-  if (!hasNode(tree, target))
+function substituteWhere(tree, match, replacement) {
+  if (match(tree))
+    return tree.key !== undefined ? { ...replacement, key: tree.key } : replacement;
+  if (!hasWhere(tree, match))
     return tree;
   if (FLOW_KINDS.has(tree.kind))
-    return mapFlow(tree, (child) => substitute(child, target, replacement));
-  return { ...tree, children: (tree.children ?? []).map((child) => substitute(child, target, replacement)) };
+    return mapFlow(tree, (child) => substituteWhere(child, match, replacement));
+  return { ...tree, children: (tree.children ?? []).map((child) => substituteWhere(child, match, replacement)) };
 }
 function allValues(tree) {
   if (tree.kind === "object" || tree.kind === "array" || tree.kind === "assembled" && tree.text === "array") {
@@ -1155,6 +1301,18 @@ function renderings(tree, limit = 16) {
       return combine((tree.children ?? []).map((child) => renderings(child, limit)));
     case "assembled":
       return tree.text === "string" ? combine((tree.children ?? []).map((child) => renderings(child, limit))) : ["${...}"];
+    case "arrayJoin": {
+      const elements = tree.text === undefined ? undefined : joinElements(tree.children ?? []);
+      if (!elements)
+        return ["${...}"];
+      const pieces = [];
+      elements.forEach((element, index) => {
+        if (index > 0)
+          pieces.push([tree.text ?? ""]);
+        pieces.push(renderings(element, limit));
+      });
+      return combine(pieces);
+    }
     case "ref":
     case "lookup":
     case "param":
@@ -1167,6 +1325,113 @@ function renderings(tree, limit = 16) {
       return ["${...}"];
   }
 }
+function joinElements(children) {
+  const out = [];
+  for (const child of children) {
+    if (child.key !== "...") {
+      out.push(child);
+      continue;
+    }
+    let array = child;
+    while (array && array.kind !== "array") {
+      const flow = FLOW_KINDS.has(array.kind) ? valueChildren(array) : [];
+      array = flow.length === 1 ? flow[0] : undefined;
+    }
+    const inner = array ? joinElements(array.children ?? []) : undefined;
+    if (!inner)
+      return;
+    out.push(...inner);
+  }
+  return out;
+}
+function queryParamValue(tree, param) {
+  const pattern = new RegExp(`[?&]${param}=([^&#]*)`);
+  const span = { id: tree.id, path: tree.path, line: tree.line, endLine: tree.endLine, start: tree.start, end: tree.end };
+  const children = [];
+  for (const url of new Set(renderings(tree))) {
+    const value = pattern.exec(url)?.[1];
+    if (value !== undefined && value !== "" && !value.includes("${")) {
+      let text = value;
+      try {
+        text = decodeURIComponent(value);
+      } catch {}
+      if (!children.some((child) => child.text === text))
+        children.push({ ...span, kind: "literal", text, resolution: "resolved" });
+    } else {
+      children.push({ ...span, kind: "external", resolution: "unresolved", note: `query parameter ${param} not literal`, unresolvedReason: "external" });
+    }
+  }
+  if (children.length === 1)
+    return { ...children[0], key: param };
+  return { ...span, kind: "oneOf", key: param, children, resolution: rollup(children), note: "query parameter" };
+}
+function subtrees(tree) {
+  const out = [...tree.children ?? [], ...tree.bindings ?? [], ...tree.args ?? []];
+  if (tree.callee)
+    out.push(tree.callee);
+  if (tree.object)
+    out.push(tree.object);
+  if (tree.keyNode)
+    out.push(tree.keyNode);
+  return out;
+}
+var sizes = new WeakMap;
+function treeSize(tree) {
+  const cached = sizes.get(tree);
+  if (cached !== undefined)
+    return cached;
+  const size = 1 + subtrees(tree).reduce((sum, child) => sum + treeSize(child), 0);
+  sizes.set(tree, size);
+  return size;
+}
+function embeddedNodes(tree, targets) {
+  const found = new Set;
+  if (targets.size === 0)
+    return found;
+  const seen = new Set;
+  const visit = (node) => {
+    if (seen.has(node) || found.size === targets.size)
+      return;
+    seen.add(node);
+    if (targets.has(node)) {
+      found.add(node);
+      return;
+    }
+    subtrees(node).forEach(visit);
+  };
+  visit(tree);
+  return found;
+}
+function atMostPartial(node) {
+  return node.resolution === "resolved" ? { ...node, resolution: "partial" } : node;
+}
+function isLoop(node) {
+  return import_typescript2.default.isForStatement(node) || import_typescript2.default.isForOfStatement(node) || import_typescript2.default.isForInStatement(node) || import_typescript2.default.isWhileStatement(node) || import_typescript2.default.isDoStatement(node);
+}
+function mutationsReaching(mutations, read) {
+  const readFn = import_typescript2.default.findAncestor(read.parent, isFunctionLike);
+  return mutations.filter((mutation) => {
+    if (mutation.at.getSourceFile() !== read.getSourceFile() || mutation.at.pos < read.pos)
+      return true;
+    if (import_typescript2.default.findAncestor(mutation.at.parent, isFunctionLike) !== readFn)
+      return true;
+    for (let node = read.parent;node && node !== readFn; node = node.parent) {
+      if (isLoop(node) && mutation.at.pos >= node.pos && mutation.at.end <= node.end)
+        return true;
+    }
+    return false;
+  });
+}
+function mayNotRun(at, declaration) {
+  const scope = enclosingScope(declaration);
+  for (let node = at.parent;node && node !== scope; node = node.parent) {
+    if (import_typescript2.default.isIfStatement(node) || import_typescript2.default.isConditionalExpression(node) || import_typescript2.default.isSwitchStatement(node) || import_typescript2.default.isCatchClause(node) || isLoop(node) || isFunctionLike(node))
+      return true;
+    if (import_typescript2.default.isBinaryExpression(node) && (node.operatorToken.kind === import_typescript2.default.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === import_typescript2.default.SyntaxKind.BarBarToken || node.operatorToken.kind === import_typescript2.default.SyntaxKind.QuestionQuestionToken))
+      return true;
+  }
+  return false;
+}
 
 // src/harness-extract/calls.ts
 class CallIndex {
@@ -1175,6 +1440,7 @@ class CallIndex {
   byName;
   aliases = new Map;
   members = new Map;
+  checkingDefaults = new Set;
   constructor(program, checker) {
     this.program = program;
     this.checker = checker;
@@ -1184,6 +1450,7 @@ class CallIndex {
     for (const source of this.program.getSourceFiles()) {
       if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
         continue;
+      const imported = importAliases(source);
       const visit = (node) => {
         if ((import_typescript3.default.isParameter(node) || import_typescript3.default.isVariableDeclaration(node)) && node.initializer && import_typescript3.default.isIdentifier(node.name)) {
           let init = unwrap(node.initializer);
@@ -1214,11 +1481,14 @@ class CallIndex {
           const callee = unwrap(node.expression);
           const name = import_typescript3.default.isIdentifier(callee) ? callee.text : import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name.text : undefined;
           if (name) {
-            const list = byName.get(name);
-            if (list)
-              list.push(node);
-            else
-              byName.set(name, [node]);
+            const original = import_typescript3.default.isIdentifier(callee) ? imported.get(name) : undefined;
+            for (const key of original && original !== name ? [name, original] : [name]) {
+              const list = byName.get(key);
+              if (list)
+                list.push(node);
+              else
+                byName.set(key, [node]);
+            }
           }
         }
         import_typescript3.default.forEachChild(node, visit);
@@ -1227,15 +1497,25 @@ class CallIndex {
     }
     return byName;
   }
-  callersOf(fn, name, limit) {
+  callersOf(fn, name, limit, within) {
+    const all = this.allCallersOf(fn, name, within ? Number.MAX_SAFE_INTEGER : limit);
+    if (!within)
+      return all;
+    return all.filter((call) => within.getSourceFile(call.getSourceFile().fileName) === call.getSourceFile()).slice(0, limit);
+  }
+  allCallersOf(fn, name, limit) {
     this.byName ??= this.build();
     const out = this.direct(name, limit, (declaration) => declares(declaration, fn));
+    if (isDefaultExport(fn) && name !== "default" && out.length < limit)
+      out.push(...this.direct("default", limit - out.length, (declaration) => declares(declaration, fn)));
     for (const alias of this.aliases.get(name) ?? []) {
       if (out.length >= limit)
         break;
       const symbol = resolvedSymbol(alias.target, this.checker);
       if (!symbol?.declarations?.some((declaration) => declares(declaration, fn)))
         continue;
+      if (!this.defaultCanApply(alias.declaration))
+        continue;
       const aliasName = alias.declaration.name.text;
       out.push(...this.direct(aliasName, limit - out.length, (declaration) => declaration === alias.declaration));
     }
@@ -1294,6 +1574,40 @@ class CallIndex {
     }
     return out;
   }
+  defaultCanApply(declaration) {
+    if (!import_typescript3.default.isParameter(declaration) || this.checkingDefaults.has(declaration))
+      return true;
+    const init = declaration.initializer ? unwrap(declaration.initializer) : undefined;
+    if (!init || !import_typescript3.default.isIdentifier(init))
+      return true;
+    const fn = declaration.parent;
+    const name = isFunctionLike(fn) ? functionName(fn) : undefined;
+    if (!name || !isFunctionLike(fn))
+      return true;
+    const index = fn.parameters.indexOf(declaration);
+    this.checkingDefaults.add(declaration);
+    try {
+      const callers = this.callersOf(fn, name, 20);
+      if (callers.length === 0 || callers.length >= 20)
+        return true;
+      return callers.some((call) => {
+        if (call.arguments.slice(0, index + 1).some((argument2) => import_typescript3.default.isSpreadElement(argument2)))
+          return true;
+        const argument = call.arguments[index];
+        if (!argument)
+          return true;
+        const inner = unwrap(argument);
+        if (import_typescript3.default.isIdentifier(inner) && inner.text === "undefined" || import_typescript3.default.isVoidExpression(inner))
+          return true;
+        const passed = import_typescript3.default.isIdentifier(inner) ? valueDeclaration(resolvedSymbol(inner, this.checker)) : undefined;
+        if (passed && declaration.initializer && declares(passed, resolvedFunction(declaration.initializer, this.checker) ?? fn))
+          return true;
+        return !definitelyDefined(inner, this.checker);
+      });
+    } finally {
+      this.checkingDefaults.delete(declaration);
+    }
+  }
   direct(name, limit, matches) {
     const candidates = this.byName.get(name) ?? [];
     const out = [];
@@ -1311,13 +1625,114 @@ class CallIndex {
     return out;
   }
 }
+
+class RepoCallIndex {
+  entries;
+  indexes = new Map;
+  owned = new Map;
+  constructor(entries) {
+    this.entries = entries;
+  }
+  indexFor(entry) {
+    let index = this.indexes.get(entry);
+    if (!index) {
+      index = new CallIndex(entry.program, entry.checker());
+      this.indexes.set(entry, index);
+    }
+    return index;
+  }
+  indexedCallersOf(fn, name, limit, within) {
+    const out = [];
+    const seen = new Set;
+    const fnFile = fn.getSourceFile().fileName;
+    for (const entry of this.entries) {
+      if (out.length >= limit)
+        break;
+      if (!entry.program.getSourceFile(fnFile))
+        continue;
+      let owned = this.owned.get(entry);
+      if (!owned) {
+        owned = new Set(entry.owned);
+        this.owned.set(entry, owned);
+      }
+      for (const call of this.indexFor(entry).callersOf(fn, name, Number.MAX_SAFE_INTEGER)) {
+        const source = call.getSourceFile();
+        if (!owned.has(source.fileName))
+          continue;
+        const key = `${source.fileName}:${call.pos}`;
+        if (seen.has(key))
+          continue;
+        if (within && within.getSourceFile(source.fileName) !== source)
+          continue;
+        seen.add(key);
+        out.push({ call, entry });
+        if (out.length >= limit)
+          break;
+      }
+    }
+    return out;
+  }
+  callersOf(fn, name, limit, within) {
+    const own = within ? this.entries.find((entry) => entry.program === within) : undefined;
+    if (own)
+      return this.indexFor(own).callersOf(fn, name, limit);
+    return this.indexedCallersOf(fn, name, limit, within).map((indexed) => indexed.call);
+  }
+}
+function importAliases(source) {
+  const aliases = new Map;
+  for (const statement of source.statements) {
+    const clause = import_typescript3.default.isImportDeclaration(statement) ? statement.importClause : undefined;
+    if (!clause || clause.isTypeOnly)
+      continue;
+    if (clause.name)
+      aliases.set(clause.name.text, "default");
+    if (clause.namedBindings && import_typescript3.default.isNamedImports(clause.namedBindings)) {
+      for (const element of clause.namedBindings.elements) {
+        if (element.propertyName)
+          aliases.set(element.name.text, element.propertyName.text);
+      }
+    }
+  }
+  return aliases;
+}
+function isDefaultExport(fn) {
+  const holder = import_typescript3.default.isVariableDeclaration(fn.parent) ? fn.parent : fn;
+  if (import_typescript3.default.canHaveModifiers(holder) && import_typescript3.default.getModifiers(holder)?.some((modifier) => modifier.kind === import_typescript3.default.SyntaxKind.DefaultKeyword))
+    return true;
+  if (import_typescript3.default.isExportAssignment(fn.parent))
+    return true;
+  const name = functionName(fn);
+  return Boolean(name && fn.getSourceFile().statements.some((statement) => import_typescript3.default.isExportAssignment(statement) && !statement.isExportEquals && import_typescript3.default.isIdentifier(statement.expression) && statement.expression.text === name));
+}
+function sameNode(a, b) {
+  return a === b || a.kind === b.kind && a.pos === b.pos && a.end === b.end && a.getSourceFile().fileName === b.getSourceFile().fileName;
+}
 function declares(declaration, fn) {
-  if (declaration === fn)
+  if (sameNode(declaration, fn))
     return true;
-  if ((import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)) && declaration.initializer && unwrap(declaration.initializer) === fn)
+  if ((import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)) && declaration.initializer && sameNode(unwrap(declaration.initializer), fn))
+    return true;
+  if (import_typescript3.default.isExportAssignment(declaration) && sameNode(unwrap(declaration.expression), fn))
     return true;
   return false;
 }
+function definitelyDefined(expression, checker, seen = new Set) {
+  const node = unwrap(expression);
+  if (seen.has(node))
+    return false;
+  seen.add(node);
+  if (import_typescript3.default.isStringLiteralLike(node) || import_typescript3.default.isNumericLiteral(node) || import_typescript3.default.isObjectLiteralExpression(node) || import_typescript3.default.isArrayLiteralExpression(node) || import_typescript3.default.isArrowFunction(node) || import_typescript3.default.isFunctionExpression(node) || node.kind === import_typescript3.default.SyntaxKind.NullKeyword || node.kind === import_typescript3.default.SyntaxKind.TrueKeyword || node.kind === import_typescript3.default.SyntaxKind.FalseKeyword)
+    return true;
+  if (import_typescript3.default.isIdentifier(node)) {
+    const declaration = valueDeclaration(resolvedSymbol(node, checker));
+    if (declaration && (import_typescript3.default.isFunctionDeclaration(declaration) || import_typescript3.default.isClassDeclaration(declaration)))
+      return true;
+    if (declaration && import_typescript3.default.isVariableDeclaration(declaration) && declaration.initializer && import_typescript3.default.getCombinedNodeFlags(declaration) & import_typescript3.default.NodeFlags.Const)
+      return definitelyDefined(declaration.initializer, checker, seen);
+  }
+  return false;
+}
 
 // src/harness-extract/messages.ts
 var ROLE_LITERALS = {
@@ -1356,14 +1771,9 @@ function elementRole(element, depth = 0) {
   if (depth > 6 || element.key === "...")
     return "unknown";
   if (element.kind === "object") {
-    const members = element.children ?? [];
-    for (let index = members.length - 1;index >= 0; index -= 1) {
-      if (members[index].key === "role") {
-        const text = singleLiteral(members[index]);
-        return text && ROLE_LITERALS[text.toLowerCase()] || "unknown";
-      }
-    }
-    return "unknown";
+    const missing = { ...element, kind: "external", children: undefined, resolution: "unresolved" };
+    const text = singleLiteral(selectKey(element, "role", missing));
+    return text && ROLE_LITERALS[text.toLowerCase()] || "unknown";
   }
   if (element.kind === "array") {
     const text = singleLiteral(element.children?.[0]);
@@ -1415,6 +1825,7 @@ function splitMessages(tree) {
 
 // src/harness-extract/program.ts
 var import_typescript4 = __toESM(require_typescript(), 1);
+import { createHash } from "node:crypto";
 import { readdirSync, statSync } from "node:fs";
 import { dirname, join, relative as relative2, resolve } from "node:path";
 var SKIPPED_DIRS = new Set(["node_modules", "dist", "build", "out", "vendor", "coverage", "graphify-out", "__pycache__"]);
@@ -1489,6 +1900,39 @@ function walkRepository(rootDir, maxFiles, includeTestRunnerFiles) {
   walk(rootDir, "");
   return { files, configs, truncated };
 }
+function sourceFingerprint(rootDir, options = {}) {
+  const walked = walkRepository(resolve(rootDir), options.maxFiles ?? DEFAULT_MAX_FILES, options.includeTestRunnerFiles ?? false);
+  const hash = createHash("sha1");
+  const inputs = new Set([...walked.configs, ...walked.files.map((file) => file.endsWith(SVELTE_VIRTUAL_SUFFIX) ? file.slice(0, -SVELTE_VIRTUAL_SUFFIX.length) : file)]);
+  for (const config of walked.configs) {
+    const host = { ...import_typescript4.default.sys, onUnRecoverableConfigFileDiagnostic: () => {}, readFile: (file) => {
+      inputs.add(file);
+      return import_typescript4.default.sys.readFile(file);
+    } };
+    import_typescript4.default.getParsedCommandLineOfConfigFile(config, {}, host);
+  }
+  const metadata = (directory) => {
+    let entries;
+    try {
+      entries = readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && !SKIPPED_DIRS.has(entry.name))
+        metadata(join(directory, entry.name));
+      else if (entry.isFile() && (entry.name === "package.json" || /^wrangler(?:\.[\w.-]+)?\.(?:json|jsonc|toml)$/.test(entry.name)))
+        inputs.add(join(directory, entry.name));
+    }
+  };
+  metadata(resolve(rootDir));
+  for (const file of [...inputs].sort()) {
+    const text = import_typescript4.default.sys.readFile(file);
+    hash.update(`${file}\x00${text ?? "missing"}
+`);
+  }
+  return hash.digest("hex");
+}
 function extractorOptions(base) {
   const options = {
     ...base,
@@ -1548,6 +1992,7 @@ function sharedHost(options, cache) {
   host.writeFile = () => {};
   return host;
 }
+var NO_INPUTS_FOUND = 18003;
 function parseConfig(configPath, warnings, rootDir) {
   const rel = relative2(rootDir, configPath).split("\\").join("/");
   const read = import_typescript4.default.readConfigFile(configPath, import_typescript4.default.sys.readFile);
@@ -1557,6 +2002,11 @@ function parseConfig(configPath, warnings, rootDir) {
   }
   const raw = read.config;
   const parsed = import_typescript4.default.parseJsonConfigFileContent(read.config, import_typescript4.default.sys, dirname(configPath), undefined, configPath);
+  const errors = parsed.errors.filter((error) => error.code !== NO_INPUTS_FOUND);
+  if (errors.length > 0) {
+    const messages = errors.slice(0, 3).map((error) => import_typescript4.default.flattenDiagnosticMessageText(error.messageText, " "));
+    warnings.push(`tsconfig ${rel}: ${messages.join("; ")}${errors.length > 3 ? ` (+${errors.length - 3} more)` : ""}; extraction continues with the options that parsed`);
+  }
   const explicit = raw.include !== undefined || raw.files !== undefined || parsed.raw && (parsed.raw.include !== undefined || parsed.raw.files !== undefined);
   return { options: parsed.options, fileNames: explicit ? parsed.fileNames.map((name) => resolve(name)) : undefined };
 }
@@ -1604,7 +2054,8 @@ function buildPrograms(rootDir, options = {}) {
       continue;
     const dir = dirname(configPath);
     const nested = configDirs.filter((other) => other !== dir && isUnder(other, dir));
-    const included = parsed.fileNames ? parsed.fileNames.filter((file) => known.has(file)) : walked.files.filter((file) => isUnder(file, dir) && !nested.some((other) => isUnder(file, other)));
+    const underDir = (file) => isUnder(file, dir) && !nested.some((other) => isUnder(file, other));
+    const included = parsed.fileNames ? [...parsed.fileNames.filter((file) => known.has(file)), ...walked.files.filter((file) => file.endsWith(SVELTE_VIRTUAL_SUFFIX) && underDir(file))] : walked.files.filter(underDir);
     const owned = included.filter((file) => !assigned.has(file));
     if (owned.length === 0)
       continue;
@@ -1620,6 +2071,7 @@ function buildPrograms(rootDir, options = {}) {
 
 // src/harness-extract/sinks.ts
 var import_typescript5 = __toESM(require_typescript(), 1);
+var URL_MODEL_KEY = "?model";
 var ANTHROPIC_MODULE = /^@anthropic-ai\//;
 var OPENAI_MODULE = /^openai(?:\/|$)/;
 var OPENAI_COMPATIBLE_MODULE = /^(?:groq-sdk|together-ai|@cerebras\/cerebras_cloud_sdk|fireworks-ai|portkey-ai|@portkey-ai\/|@azure\/openai|deepseek|@helicone\/|cohere-ai)/;
@@ -1656,9 +2108,9 @@ function requestRoles(argument, keys, ctx) {
   if (object && unwrap(argument) === object) {
     for (const [key, role] of Object.entries(keys)) {
       const value = propertyValue(object, key);
-      if (value)
+      if (value && !spreadAfter(object, key))
         roles.push({ role, node: value });
-      else if (!hasProperty(object, key) && object.properties.some((property) => import_typescript5.default.isSpreadAssignment(property))) {
+      else if ((value || !hasProperty(object, key)) && object.properties.some((property) => import_typescript5.default.isSpreadAssignment(property))) {
         roles.push({ role, node: argument, key });
       }
     }
@@ -1671,6 +2123,14 @@ function requestRoles(argument, keys, ctx) {
   }
   return dedupeRoles(roles);
 }
+function spreadAfter(object, key) {
+  let last = -1;
+  object.properties.forEach((property, index) => {
+    if (!import_typescript5.default.isSpreadAssignment(property) && property.name && propertyNameText(property.name) === key)
+      last = index;
+  });
+  return object.properties.some((property, index) => index > last && import_typescript5.default.isSpreadAssignment(property));
+}
 function dedupeRoles(roles) {
   const seen = new Set;
   return roles.filter((role) => {
@@ -1980,13 +2440,14 @@ function urlTemplate(expression, checker, depth = 0) {
   }
   return;
 }
+var MODEL_SOCKET = /^wss:\/\/(?:api\.openai\.com\/v1\/realtime|[\w.-]+\.openai\.azure\.com\/openai\/realtime|generativelanguage\.googleapis\.com\/ws\/[\w.]+BidiGenerateContent|gateway\.ai\.cloudflare\.com\/)/;
 function urlModel(url, checker) {
   const template = urlTemplate(url, checker);
   if (!template)
     return;
   let before = template.head.text;
   for (const span of template.templateSpans) {
-    if (/\/models\/$|[?&]model=$/.test(before))
+    if (/\/models\/$/.test(before) && /^[:/?#]/.test(span.literal.text) || /[?&]model=$/.test(before) && /^(?:[&#]|$)/.test(span.literal.text))
       return span.expression;
     before = span.literal.text;
   }
@@ -2111,7 +2572,7 @@ function receiverClasses(expression, checker, depth = 0) {
   }
   return [];
 }
-function firstParamType(declaration) {
+function firstParamType(declaration, checker) {
   if (!declaration)
     return;
   let parameters;
@@ -2120,7 +2581,13 @@ function firstParamType(declaration) {
   else if ((import_typescript5.default.isPropertySignature(declaration) || import_typescript5.default.isPropertyDeclaration(declaration)) && declaration.type && import_typescript5.default.isFunctionTypeNode(declaration.type))
     parameters = declaration.type.parameters;
   const type = parameters?.[0]?.type;
-  return type && import_typescript5.default.isTypeReferenceNode(type) ? type.typeName.getText() : undefined;
+  if (!type || !import_typescript5.default.isTypeReferenceNode(type))
+    return;
+  const name = import_typescript5.default.isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
+  return valueDeclarationOrType(resolvedSymbol(name, checker));
+}
+function valueDeclarationOrType(symbol) {
+  return symbol?.declarations?.[0];
 }
 function structuralAgent(receiver, method, ctx) {
   let declaration;
@@ -2136,10 +2603,10 @@ function structuralAgent(receiver, method, ctx) {
     const base = ctx.frameworkBase(owner).base;
     return base && AGENT_BASES.has(base) ? owner : undefined;
   }
-  const wanted = firstParamType(declaration);
+  const wanted = firstParamType(declaration, ctx.checker);
   if (!wanted)
     return;
-  return ctx.agentClasses().find((cls) => cls.members.some((member) => import_typescript5.default.isMethodDeclaration(member) && propertyNameText(member.name) === method && firstParamType(member) === wanted));
+  return ctx.agentClasses().find((cls) => cls.members.some((member) => import_typescript5.default.isMethodDeclaration(member) && propertyNameText(member.name) === method && firstParamType(member, ctx.checker) === wanted));
 }
 var agentEntrySink = {
   id: "agent-entry",
@@ -2228,7 +2695,9 @@ var clientChatSink = {
     if (!import_typescript5.default.isCallExpression(call) || call.arguments.length === 0)
       return;
     const callee = unwrap(call.expression);
-    const name = import_typescript5.default.isIdentifier(callee) ? callee.text : import_typescript5.default.isPropertyAccessExpression(callee) ? callee.name.text : undefined;
+    const binding = import_typescript5.default.isIdentifier(callee) ? valueDeclaration(resolvedSymbol(callee, ctx.checker)) : undefined;
+    const bound = binding && import_typescript5.default.isBindingElement(binding) && binding.propertyName ? propertyNameText(binding.propertyName) : undefined;
+    const name = bound ?? (import_typescript5.default.isIdentifier(callee) ? callee.text : import_typescript5.default.isPropertyAccessExpression(callee) ? callee.name.text : undefined);
     if (!name || !CHAT_SEND.has(name))
       return;
     const argument = call.arguments[0];
@@ -2240,6 +2709,27 @@ var clientChatSink = {
     return { api: `chat.${name}`, roles: [{ role: "user", node: argument }] };
   }
 };
+var websocketSink = {
+  id: "websocket",
+  sdk: "websocket",
+  match(call, ctx) {
+    if (!import_typescript5.default.isNewExpression(call) || !call.arguments?.length)
+      return;
+    const callee = unwrap(call.expression);
+    if (!import_typescript5.default.isIdentifier(callee) || callee.text !== "WebSocket")
+      return;
+    const url = ctx.urlTexts(call.arguments[0]).find((candidate) => MODEL_SOCKET.test(candidate));
+    if (!url)
+      return;
+    const modelInUrl = urlModel(call.arguments[0], ctx.checker);
+    const roles = modelInUrl ? [{ role: "model", node: modelInUrl }] : /[?&]model=/.test(url) ? [{ role: "model", node: call.arguments[0], key: URL_MODEL_KEY }] : [];
+    return {
+      api: "websocket",
+      provider: /openai/.test(url) ? "openai" : /generativelanguage/.test(url) ? "google" : undefined,
+      roles
+    };
+  }
+};
 function frameworkName(identifier, checker, member) {
   if (!identifier)
     return;
@@ -2325,7 +2815,7 @@ function hookSink(memo) {
       const roles = [];
       for (const member of cls.members) {
         const name = propertyNameText(member.name);
-        if (!name)
+        if (!name || import_typescript5.default.getCombinedModifierFlags(member) & import_typescript5.default.ModifierFlags.Static)
           continue;
         if ((import_typescript5.default.isMethodDeclaration(member) || import_typescript5.default.isGetAccessorDeclaration(member)) && HOOK_METHODS[name] && member.body) {
           roles.push({ role: HOOK_METHODS[name], node: member, values: returnExpressions(member) });
@@ -2339,7 +2829,7 @@ function hookSink(memo) {
               roles.push({ role, node: member, values: returns, key });
             }
           }
-        } else if (import_typescript5.default.isPropertyDeclaration(member) && HOOK_PROPERTIES[name] && member.initializer && !member.modifiers?.some((m) => m.kind === import_typescript5.default.SyntaxKind.StaticKeyword)) {
+        } else if (import_typescript5.default.isPropertyDeclaration(member) && HOOK_PROPERTIES[name] && member.initializer) {
           roles.push({ role: HOOK_PROPERTIES[name], node: member.initializer });
         }
       }
@@ -2352,7 +2842,7 @@ function hookSink(memo) {
 function createFrameworkMemo() {
   return new Map;
 }
-var CALL_SINKS = [anthropicSink, openaiSink, aiSdkSink, workersAiSink, fetchSink, providerFactorySink, agentEntrySink, clientChatSink];
+var CALL_SINKS = [anthropicSink, openaiSink, aiSdkSink, workersAiSink, fetchSink, websocketSink, providerFactorySink, agentEntrySink, clientChatSink];
 function registerCallSink(recognizer) {
   CALL_SINKS.push(recognizer);
 }
@@ -2412,43 +2902,52 @@ function definitionName(tree) {
 }
 function toolNamesOf(tree) {
   const out = { names: [], unresolved: [] };
-  const visit = (node, inArray) => {
-    if (node.kind === "array") {
+  const visit = (node, inArray, names) => {
+    if (node.kind === "array" || node.kind === "assembled" && node.text === "array") {
       for (const child of node.children ?? [])
-        visit(child, true);
+        visit(child, true, names);
       return;
     }
     if (node.kind === "object") {
       const definition = definitionName(node);
       if (definition) {
-        out.names.push(definition);
+        names.push(definition);
         return;
       }
       if (inArray) {
         out.unresolved.push({ ...node, note: "tool object without a literal name" });
         return;
       }
+      const record = new Map;
+      const set = (hit) => {
+        record.delete(hit.name);
+        record.set(hit.name, hit);
+      };
       for (const child of node.children ?? []) {
-        if (child.key === "...")
-          visit(child, false);
-        else if (child.key)
-          out.names.push({ name: child.key, path: child.path, line: child.line, via: "key" });
+        if (child.key === "...") {
+          const spread = [];
+          visit(child, false, spread);
+          spread.forEach(set);
+        } else if (child.key) {
+          set({ name: child.key, path: child.path, line: child.line, via: "key" });
+        }
       }
+      names.push(...record.values());
       return;
     }
     if (PASS_THROUGH2.has(node.kind) && valueChildren(node).length > 0) {
       for (const child of valueChildren(node))
-        visit(child, inArray);
+        visit(child, inArray, names);
       return;
     }
     out.unresolved.push(node);
   };
-  visit(tree, false);
+  visit(tree, false, out.names);
   return out;
 }
 
 // src/harness-extract/index.ts
-var PROMPT_ROLES = new Set(["system", "messages", "prompt", "instructions"]);
+var PROMPT_ROLES = new Set(["system", "user", "messages", "prompt", "instructions", "questions"]);
 var MAX_HELPER_CALLERS = 200;
 var MAX_DERIVED = 5000;
 var MAX_CALLER_CHAIN = 3;
@@ -2463,11 +2962,12 @@ function extractHarnessWithContext(rootDir, options = {}) {
   const root = resolve2(rootDir);
   const { fresh, ...rest } = options;
   const key = `${root}\x00${JSON.stringify(rest)}`;
+  const fingerprint = sourceFingerprint(root, rest);
   const cached = fresh ? undefined : cache.get(key);
-  if (cached)
-    return cached;
+  if (cached && cached.fingerprint === fingerprint)
+    return cached.output;
   const output = runExtract(root, options);
-  cache.set(key, output);
+  cache.set(key, { output, fingerprint });
   return output;
 }
 function argRef(rootDir, node, key) {
@@ -2492,7 +2992,19 @@ function qualifiedName(fn, name) {
   return owner ? `${owner}.${name}` : name;
 }
 function functionScope(rootDir, fn, name) {
-  return `${relPath(rootDir, fn.getSourceFile().fileName)}#${qualifiedName(fn, name)}`;
+  const parts = [qualifiedName(fn, name)];
+  const object = objectLiteralOf2(fn);
+  if (object) {
+    const holder = object.parent && import_typescript6.default.isVariableDeclaration(object.parent) && import_typescript6.default.isIdentifier(object.parent.name) ? object.parent.name.text : `L${lineOf(object)}`;
+    parts.unshift(holder);
+  }
+  for (let outer = namedEnclosingFunction(object ?? fn);outer; outer = namedEnclosingFunction(outer.fn))
+    parts.unshift(qualifiedName(outer.fn, outer.name));
+  return `${relPath(rootDir, fn.getSourceFile().fileName)}#${parts.join(".")}`;
+}
+function objectLiteralOf2(fn) {
+  const member2 = import_typescript6.default.isMethodDeclaration(fn) || import_typescript6.default.isGetAccessorDeclaration(fn) || import_typescript6.default.isSetAccessorDeclaration(fn) ? fn : import_typescript6.default.isPropertyAssignment(fn.parent) ? fn.parent : undefined;
+  return member2 && import_typescript6.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
 }
 function scopeOf(rootDir, node) {
   const named = namedEnclosingFunction(node);
@@ -2606,6 +3118,15 @@ function paramFlow(node, fn, checker, hops = 0) {
   }
   return;
 }
+function roleParamFlow(arg, fn, checker) {
+  const object = unwrap(arg.node);
+  if (arg.key !== undefined && !arg.key.includes(".") && import_typescript6.default.isObjectLiteralExpression(object)) {
+    const value = propertyValue(object, arg.key);
+    const flow = value ? paramFlow(value, fn, checker) : undefined;
+    return flow ? { ...flow, viaProperty: true } : undefined;
+  }
+  return paramFlow(arg.node, fn, checker);
+}
 function descendArg(argument, path) {
   let node = argument;
   let index = 0;
@@ -2647,24 +3168,23 @@ function runExtract(rootDir, options) {
   const memo = createFrameworkMemo();
   const chainMemo = new Map;
   const wrapperSinks = {};
+  const calls = new RepoCallIndex(repo?.entries ?? []);
   const tracers = new Map;
-  const toolsFor = (entry) => {
-    let tools = tracers.get(entry);
-    if (!tools) {
+  const tracerFor = (entry) => {
+    let tracer = tracers.get(entry);
+    if (!tracer) {
       const checker = entry.checker();
-      const calls = new CallIndex(entry.program, checker);
       const modelArgOf = (call) => providerModelCall(call, checker)?.model;
-      tools = { tracer: new ValueTracer(rootDir, checker, calls, options, modelArgOf), calls };
-      tracers.set(entry, tools);
+      tracer = new ValueTracer(rootDir, checker, calls, options, modelArgOf, entry.program);
+      tracers.set(entry, tracer);
     }
-    return tools;
+    return tracer;
   };
   for (const entry of repo?.entries ?? []) {
     try {
       const checker = entry.checker();
-      const { calls } = toolsFor(entry);
       let agentClasses;
-      const urlTracer = new ValueTracer(rootDir, checker, calls, { maxDepth: 6, maxNodes: 300, maxCallers: 2 });
+      const urlTracer = new ValueTracer(rootDir, checker, calls, { maxDepth: 6, maxNodes: 300, maxCallers: 2 }, undefined, entry.program);
       const ctx2 = { checker, urlTexts: (expression) => renderings(urlTracer.trace(expression)), frameworkBase: (cls) => frameworkBaseOf(cls, checker, memo), agentClasses: () => agentClasses ??= findAgentClasses(entry.program, checker, memo) };
       const classRecognizers = classSinks(memo);
       for (const file of entry.owned) {
@@ -2728,7 +3248,9 @@ function runExtract(rootDir, options) {
   clock = mark("sinks", clock);
   for (const [id, ms] of Object.entries(recognizerMs))
     timings[`sinks.${id}`] = Math.round(ms);
-  const seenIds = new Set(sites.map((entry) => entry.site.id));
+  const directIds = new Set(sites.map((entry) => entry.site.id));
+  const seenIds = new Set(directIds);
+  const seenDerived = new Set;
   const rounds = options.helperDepth ?? 8;
   let frontier = sites.filter((entry) => entry.sources.every((source) => !source.values));
   let derivedCount = 0;
@@ -2741,8 +3263,7 @@ function runExtract(rootDir, options) {
         const named = namedEnclosingFunction(inner.anchor);
         if (!named)
           continue;
-        const checker = inner.entry.checker();
-        const flowing = inner.sources.map((source) => ({ source, flow: paramFlow(source.arg.node, named.fn, checker) })).filter((item) => Boolean(item.flow));
+        const flowing = inner.sources.map((source) => ({ source, flow: roleParamFlow(source.arg, named.fn, inner.entry.checker()) })).filter((item) => Boolean(item.flow));
         if (flowing.length === 0)
           continue;
         const fnSource = named.fn.getSourceFile();
@@ -2754,14 +3275,15 @@ function runExtract(rootDir, options) {
             wrapper.roles.push({ role: source.role, param, index: named.fn.parameters.indexOf(flow.param), ...flow.key ? { key: flow.key } : {} });
           }
         }
-        const { calls } = toolsFor(inner.entry);
-        for (const call of calls.callersOf(named.fn, named.name, MAX_HELPER_CALLERS)) {
+        const origin = inner.site.viaHelper ?? inner.site.id;
+        for (const { call, entry: callerEntry } of calls.indexedCallersOf(named.fn, named.name, MAX_HELPER_CALLERS)) {
           if (enclosingFunction(call) === named.fn)
             continue;
           const source = call.getSourceFile();
           const rel = relPath(rootDir, source.fileName);
-          const id = `${rel}:${lineOf(call)}:${colOf(call)}`;
-          if (seenIds.has(id))
+          const location = `${rel}:${lineOf(call)}:${colOf(call)}`;
+          const derivedKey = `${location}\x00${origin}`;
+          if (directIds.has(location) || seenDerived.has(derivedKey))
             continue;
           const callerBindings = named.fn.parameters.map((param, index) => ({ param, expr: call.arguments[index] }));
           const sources = [];
@@ -2769,12 +3291,18 @@ function runExtract(rootDir, options) {
             const argument = call.arguments[named.fn.parameters.indexOf(flow.param)];
             if (!argument || import_typescript6.default.isSpreadElement(argument))
               continue;
-            const arg = descendArg(argument, [flow.key, role.arg.key].filter((part) => Boolean(part)));
+            const arg = descendArg(argument, [flow.key, flow.viaProperty ? undefined : role.arg.key].filter((part) => Boolean(part)));
             sources.push({ ...role, bindings: extendBindings(role.bindings, callerBindings), arg });
           }
           if (sources.length === 0)
             continue;
+          seenDerived.add(derivedKey);
+          let id = location;
+          for (let n = 2;seenIds.has(id); n += 1)
+            id = `${location}#${n}`;
           seenIds.add(id);
+          const entry = callerEntry.program.getSourceFile(fnSource.fileName) === fnSource ? callerEntry : inner.entry;
+          const checker = entry.checker();
           const site = {
             id,
             path: rel,
@@ -2792,7 +3320,7 @@ function runExtract(rootDir, options) {
             isTest: isTestPath(rel),
             isEval: isEvalPath(rel)
           };
-          const derived = { site, entry: inner.entry, anchor: call, sources, level };
+          const derived = { site, entry, anchor: call, sources, level };
           sites.push(derived);
           next.push(derived);
           derivedCount += 1;
@@ -2811,14 +3339,16 @@ function runExtract(rootDir, options) {
   const roles = [];
   const tracePrompts = options.tracePrompts ?? true;
   for (const entry of sites) {
-    const { tracer } = toolsFor(entry.entry);
+    const tracer = tracerFor(entry.entry);
     for (const source of entry.sources) {
       if (!tracePrompts && PROMPT_ROLES.has(source.role))
         continue;
       let tree;
       try {
         tree = source.values ? tracer.traceAll(source.values, source.node) : tracer.trace(source.node, source.bindings);
-        if (source.key !== undefined) {
+        if (source.key === URL_MODEL_KEY) {
+          tree = queryParamValue(tree, "model");
+        } else if (source.key !== undefined) {
           for (const segment of source.key.split("."))
             tree = selectKey(tree, segment, tracer.missing(source.arg.node, `property ${source.key} not found`));
         }