@moda-ai/cli 1.55.60 → 1.55.62

package/dist/index-gtqxj0fp.js

@@ -0,0 +1,2956 @@
+import {
+  buildImportGraphReachability
+} from "./cli-mfvwvh84.js";
+import {
+  require_typescript
+} from "./cli-gmvbapx7.js";
+import {
+  __toESM
+} from "./cli-0v6na3yp.js";
+
+// src/harness-extract/index.ts
+var import_typescript6 = __toESM(require_typescript(), 1);
+import { resolve as resolve2 } from "node:path";
+
+// src/harness-extract/ast.ts
+var import_typescript = __toESM(require_typescript(), 1);
+import { relative } from "node:path";
+var SVELTE_VIRTUAL_SUFFIX = ".moda-script.ts";
+function svelteVirtualName(svelteFile) {
+  return `${svelteFile}${SVELTE_VIRTUAL_SUFFIX}`;
+}
+function relPath(rootDir, fileName) {
+  const real = fileName.endsWith(SVELTE_VIRTUAL_SUFFIX) ? fileName.slice(0, -SVELTE_VIRTUAL_SUFFIX.length) : fileName;
+  return relative(rootDir, real).split("\\").join("/");
+}
+function lineOf(node) {
+  const source = node.getSourceFile();
+  return source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+}
+function colOf(node) {
+  const source = node.getSourceFile();
+  return source.getLineAndCharacterOfPosition(node.getStart(source)).character + 1;
+}
+function unwrap(node) {
+  let current = node;
+  for (;; ) {
+    if (import_typescript.default.isParenthesizedExpression(current) || import_typescript.default.isAsExpression(current) || import_typescript.default.isSatisfiesExpression(current) || import_typescript.default.isTypeAssertionExpression(current) || import_typescript.default.isNonNullExpression(current) || import_typescript.default.isAwaitExpression(current)) {
+      current = current.expression;
+    } else {
+      return current;
+    }
+  }
+}
+function propertyNameText(name) {
+  if (!name)
+    return;
+  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isPrivateIdentifier(name) || import_typescript.default.isNumericLiteral(name) || import_typescript.default.isNoSubstitutionTemplateLiteral(name))
+    return name.text;
+  if (import_typescript.default.isComputedPropertyName(name)) {
+    const inner = unwrap(name.expression);
+    if (import_typescript.default.isStringLiteral(inner) || import_typescript.default.isNoSubstitutionTemplateLiteral(inner))
+      return inner.text;
+  }
+  return;
+}
+function calleeChain(expression) {
+  const parts = [];
+  let current = expression;
+  for (;; ) {
+    current = unwrap(current);
+    if (import_typescript.default.isPropertyAccessExpression(current)) {
+      parts.unshift(current.name.text);
+      current = current.expression;
+    } else if (import_typescript.default.isIdentifier(current)) {
+      parts.unshift(current.text);
+      return parts;
+    } else if (current.kind === import_typescript.default.SyntaxKind.ThisKeyword) {
+      parts.unshift("this");
+      return parts;
+    } else if (import_typescript.default.isCallExpression(current) || import_typescript.default.isNewExpression(current) || import_typescript.default.isElementAccessExpression(current)) {
+      parts.unshift("()");
+      return parts;
+    } else {
+      return;
+    }
+  }
+}
+function isFunctionLike(node) {
+  return import_typescript.default.isFunctionDeclaration(node) || import_typescript.default.isMethodDeclaration(node) || import_typescript.default.isArrowFunction(node) || import_typescript.default.isFunctionExpression(node) || import_typescript.default.isConstructorDeclaration(node) || import_typescript.default.isGetAccessorDeclaration(node);
+}
+function enclosingFunction(node) {
+  for (let current = node.parent;current; current = current.parent) {
+    if (isFunctionLike(current))
+      return current;
+  }
+  return;
+}
+function functionName(fn) {
+  if (import_typescript.default.isConstructorDeclaration(fn))
+    return "constructor";
+  if (fn.name)
+    return propertyNameText(fn.name);
+  const holder = fn.parent;
+  if (holder && import_typescript.default.isVariableDeclaration(holder) && import_typescript.default.isIdentifier(holder.name))
+    return holder.name.text;
+  if (holder && (import_typescript.default.isPropertyAssignment(holder) || import_typescript.default.isPropertyDeclaration(holder)))
+    return propertyNameText(holder.name);
+  return;
+}
+function enclosingClass(node) {
+  for (let current = node.parent;current; current = current.parent) {
+    if (import_typescript.default.isClassDeclaration(current) || import_typescript.default.isClassExpression(current))
+      return current;
+  }
+  return;
+}
+function className(cls) {
+  if (cls.name)
+    return cls.name.text;
+  const holder = cls.parent;
+  if (holder && import_typescript.default.isVariableDeclaration(holder) && import_typescript.default.isIdentifier(holder.name))
+    return holder.name.text;
+  return;
+}
+function returnExpressions(fn) {
+  const body = fn.body;
+  if (!body)
+    return [];
+  if (!import_typescript.default.isBlock(body))
+    return [body];
+  const out = [];
+  const visit = (node) => {
+    if (isFunctionLike(node) || import_typescript.default.isClassLike(node))
+      return;
+    if (import_typescript.default.isReturnStatement(node) && node.expression)
+      out.push(node.expression);
+    import_typescript.default.forEachChild(node, visit);
+  };
+  import_typescript.default.forEachChild(body, visit);
+  return out;
+}
+function moduleSpecifierOf(declaration) {
+  let specifier;
+  let imported = "";
+  if (import_typescript.default.isImportSpecifier(declaration)) {
+    specifier = declaration.parent.parent.parent.moduleSpecifier;
+    imported = (declaration.propertyName ?? declaration.name).text;
+  } else if (import_typescript.default.isImportClause(declaration)) {
+    specifier = declaration.parent.moduleSpecifier;
+    imported = "default";
+  } else if (import_typescript.default.isNamespaceImport(declaration)) {
+    specifier = declaration.parent.parent.moduleSpecifier;
+    imported = "*";
+  } else if (import_typescript.default.isExportSpecifier(declaration)) {
+    specifier = declaration.parent.parent.moduleSpecifier;
+    imported = (declaration.propertyName ?? declaration.name).text;
+  } else if (import_typescript.default.isImportEqualsDeclaration(declaration) && import_typescript.default.isExternalModuleReference(declaration.moduleReference)) {
+    specifier = declaration.moduleReference.expression;
+    imported = "*";
+  } else if (import_typescript.default.isVariableDeclaration(declaration) && declaration.initializer) {
+    const init = unwrap(declaration.initializer);
+    if (import_typescript.default.isCallExpression(init) && import_typescript.default.isIdentifier(init.expression) && init.expression.text === "require" && init.arguments[0] && import_typescript.default.isStringLiteral(init.arguments[0])) {
+      specifier = init.arguments[0];
+      imported = "*";
+    }
+  }
+  if (!specifier || !import_typescript.default.isStringLiteral(specifier))
+    return;
+  return { module: specifier.text, imported };
+}
+function isBareModule(module) {
+  return !module.startsWith(".") && !module.startsWith("/");
+}
+function importOrigin(identifier, checker) {
+  let symbol;
+  try {
+    symbol = checker.getSymbolAtLocation(identifier);
+  } catch {
+    return;
+  }
+  for (let hop = 0;symbol && hop < 6; hop += 1) {
+    if (!(symbol.flags & import_typescript.default.SymbolFlags.Alias))
+      return;
+    const declaration = symbol.declarations?.[0];
+    if (!declaration)
+      return;
+    const origin = moduleSpecifierOf(declaration);
+    if (origin && isBareModule(origin.module))
+      return origin;
+    let next;
+    try {
+      next = checker.getImmediateAliasedSymbol(symbol);
+    } catch {
+      return;
+    }
+    if (!next || next === symbol)
+      return;
+    symbol = next;
+  }
+  return;
+}
+function resolvedSymbol(node, checker) {
+  let symbol;
+  try {
+    symbol = node.parent && import_typescript.default.isShorthandPropertyAssignment(node.parent) && node.parent.name === node ? checker.getShorthandAssignmentValueSymbol(node.parent) : checker.getSymbolAtLocation(node);
+    if (symbol && symbol.flags & import_typescript.default.SymbolFlags.Alias) {
+      const aliased = checker.getAliasedSymbol(symbol);
+      if (aliased && aliased.declarations && aliased.declarations.length > 0)
+        symbol = aliased;
+    }
+  } catch {
+    return;
+  }
+  return symbol;
+}
+function valueDeclaration(symbol) {
+  if (!symbol)
+    return;
+  return symbol.valueDeclaration ?? symbol.declarations?.[0];
+}
+function rootIdentifier(expression) {
+  let current = unwrap(expression);
+  while (import_typescript.default.isPropertyAccessExpression(current) || import_typescript.default.isElementAccessExpression(current))
+    current = unwrap(current.expression);
+  return import_typescript.default.isIdentifier(current) ? current : undefined;
+}
+function objectLiteralOf(node, checker, depth = 0) {
+  if (!node || depth > 3)
+    return;
+  const value = unwrap(node);
+  if (import_typescript.default.isObjectLiteralExpression(value))
+    return value;
+  if (import_typescript.default.isIdentifier(value)) {
+    const declaration = valueDeclaration(resolvedSymbol(value, checker));
+    if (declaration && import_typescript.default.isVariableDeclaration(declaration) && declaration.initializer) {
+      return objectLiteralOf(declaration.initializer, checker, depth + 1);
+    }
+  }
+  return;
+}
+function propertyValue(object, key) {
+  let found;
+  for (const property of object.properties) {
+    if (import_typescript.default.isPropertyAssignment(property) && propertyNameText(property.name) === key)
+      found = property.initializer;
+    else if (import_typescript.default.isShorthandPropertyAssignment(property) && property.name.text === key)
+      found = property.name;
+    else if (import_typescript.default.isMethodDeclaration(property) && propertyNameText(property.name) === key)
+      found = undefined;
+  }
+  return found;
+}
+function hasProperty(object, key) {
+  return object.properties.some((property) => propertyNameText(property.name) === key);
+}
+
+// src/harness-extract/calls.ts
+var import_typescript3 = __toESM(require_typescript(), 1);
+
+// src/harness-extract/trace.ts
+var import_typescript2 = __toESM(require_typescript(), 1);
+var DEFAULT_TRACE_DEPTH = 8;
+var DEFAULT_MAX_CALLERS = 10;
+var DEFAULT_MAX_NODES = 4000;
+var MAX_TEXT = 4000;
+var MAX_RETURNS = 12;
+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 EMPTY_ENV = new Map;
+function envFrom(bindings) {
+  const env = new Map;
+  for (const binding of bindings)
+    env.set(binding.param, { expr: binding.expr, env: envFrom(binding.outer ?? []) });
+  return env;
+}
+function valueChildren(tree) {
+  if (tree.kind === "call" && tree.callee)
+    return [tree.callee];
+  if (tree.kind === "param")
+    return [...tree.bindings ?? [], ...tree.children ?? []];
+  return tree.children ?? [];
+}
+function mapFlow(tree, map) {
+  if (tree.kind === "call" && tree.callee) {
+    const callee = map(tree.callee);
+    return { ...tree, callee, resolution: callee.resolution, ...reasonOf(callee.resolution, [callee]) };
+  }
+  const out = { ...tree };
+  if (tree.bindings)
+    out.bindings = tree.bindings.map(map);
+  if (tree.children)
+    out.children = tree.children.map(map);
+  const all = valueChildren(out);
+  out.resolution = rollup(all);
+  delete out.unresolvedReason;
+  Object.assign(out, reasonOf(out.resolution, all));
+  return out;
+}
+function reasonOf(resolution, children) {
+  if (resolution !== "unresolved")
+    return {};
+  const reason = children.find((child) => child.unresolvedReason)?.unresolvedReason;
+  return reason ? { unresolvedReason: reason } : {};
+}
+function rollup(children) {
+  if (children.length === 0)
+    return "unresolved";
+  if (children.every((child) => child.resolution === "resolved"))
+    return "resolved";
+  if (children.every((child) => child.resolution === "unresolved"))
+    return "unresolved";
+  return "partial";
+}
+function truncate(text) {
+  return text.length > MAX_TEXT ? `${text.slice(0, MAX_TEXT)}...` : text;
+}
+function makeNode(rootDir, kind, at, extra) {
+  const source = at.getSourceFile();
+  const start = at.getStart(source);
+  const end = at.getEnd();
+  const begin = source.getLineAndCharacterOfPosition(start);
+  const path = relPath(rootDir, source.fileName);
+  const out = {
+    id: `${path}:${begin.line + 1}:${begin.character + 1}`,
+    kind,
+    path,
+    line: begin.line + 1,
+    endLine: source.getLineAndCharacterOfPosition(end).line + 1,
+    start,
+    end,
+    resolution: extra.resolution
+  };
+  for (const [field, value] of Object.entries(extra)) {
+    if (value !== undefined && field !== "resolution")
+      out[field] = value;
+  }
+  if (out.resolution === "unresolved" && !out.unresolvedReason)
+    Object.assign(out, reasonOf("unresolved", valueChildren(out)));
+  return out;
+}
+function shallow(tree) {
+  const { children: _children, bindings: _bindings, callee: _callee, args: _args, object: _object, keyNode: _keyNode, parts: _parts, ...rest } = tree;
+  return rest;
+}
+var IO_METHOD = /^(?:fetch|readFile|readFileSync|readdir|query|prepare|first|all|exec|execute|getItem|json|text|blob|arrayBuffer|findMany|findFirst|findUnique|findOne|find|select|download|getObject|scan|batch|sql|raw)$/;
+var IO_MODULE = /^(?:node:)?(?:fs|fs\/promises|http|https|net|child_process)$|^(?:@supabase\/|@prisma\/|drizzle-orm|pg$|postgres$|mysql2?|mongodb|mongoose|redis|ioredis|@upstash\/|@aws-sdk\/|@google-cloud\/|kysely|knex|better-sqlite3|@libsql\/|@planetscale\/|@neondatabase\/|axios|got|node-fetch|undici|ky)/;
+var MESSAGE_CLASS = /^(?:System|Human|AI|Ai|Tool|Function|Chat|Assistant|User)Message(?:Chunk)?$/;
+var PROMPT_FACTORY = /(?:PromptTemplate|MessagePromptTemplate)\.(?:fromTemplate|fromMessages|fromPromptMessages)$/;
+var ARRAY_METHODS = new Set(["push", "unshift", "splice"]);
+var mutationIndex = new WeakMap;
+function mutationsIn(scope) {
+  const cached = mutationIndex.get(scope);
+  if (cached)
+    return cached;
+  const byName = new Map;
+  const add = (mutation) => {
+    const list = byName.get(mutation.target.text);
+    if (list)
+      list.push(mutation);
+    else
+      byName.set(mutation.target.text, [mutation]);
+  };
+  const visit = (node) => {
+    if (import_typescript2.default.isBinaryExpression(node) && import_typescript2.default.isIdentifier(node.left)) {
+      const kind = node.operatorToken.kind;
+      if (kind === import_typescript2.default.SyntaxKind.PlusEqualsToken)
+        add({ op: "+=", at: node, target: node.left, values: [node.right] });
+      else if (kind === import_typescript2.default.SyntaxKind.EqualsToken)
+        add(selfAssignment(node.left, node.right, node));
+    } else if (import_typescript2.default.isCallExpression(node) && import_typescript2.default.isPropertyAccessExpression(node.expression) && import_typescript2.default.isIdentifier(node.expression.expression) && ARRAY_METHODS.has(node.expression.name.text)) {
+      const op = node.expression.name.text;
+      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 });
+      } else {
+        add({ op, at: node, target, values: [...node.arguments] });
+      }
+    }
+    import_typescript2.default.forEachChild(node, visit);
+  };
+  import_typescript2.default.forEachChild(scope, visit);
+  mutationIndex.set(scope, byName);
+  return byName;
+}
+function selfAssignment(target, right, at) {
+  const value = unwrap(right);
+  const isSelf = (expression) => {
+    const inner = unwrap(expression);
+    return import_typescript2.default.isIdentifier(inner) && inner.text === target.text;
+  };
+  if (import_typescript2.default.isCallExpression(value) && import_typescript2.default.isPropertyAccessExpression(value.expression) && value.expression.name.text === "concat" && isSelf(value.expression.expression)) {
+    return { op: "concat", at, target, values: [...value.arguments] };
+  }
+  if (import_typescript2.default.isBinaryExpression(value) && value.operatorToken.kind === import_typescript2.default.SyntaxKind.PlusToken) {
+    const parts = [];
+    const flatten = (node) => {
+      const inner = unwrap(node);
+      if (import_typescript2.default.isBinaryExpression(inner) && inner.operatorToken.kind === import_typescript2.default.SyntaxKind.PlusToken) {
+        flatten(inner.left);
+        flatten(inner.right);
+      } else
+        parts.push(node);
+    };
+    flatten(value);
+    if (parts.length > 1 && isSelf(parts[0]))
+      return { op: "+=", at, target, values: parts.slice(1) };
+  }
+  if (import_typescript2.default.isArrayLiteralExpression(value)) {
+    const elements = [...value.elements];
+    const first = elements[0];
+    const last = elements[elements.length - 1];
+    if (first && import_typescript2.default.isSpreadElement(first) && isSelf(first.expression))
+      return { op: "push", at, target, values: elements.slice(1) };
+    if (last && import_typescript2.default.isSpreadElement(last) && isSelf(last.expression))
+      return { op: "unshift", at, target, values: elements.slice(0, -1) };
+  }
+  return { op: "=", at, target, values: [right] };
+}
+
+class ValueTracer {
+  rootDir;
+  checker;
+  calls;
+  modelArgOf;
+  maxDepth;
+  maxCallers;
+  maxNodes;
+  maxCallerDepth;
+  count = 0;
+  callerLevel = 0;
+  stack = new Set;
+  reassigning = new Set;
+  constructor(rootDir, checker, calls, options = {}, modelArgOf) {
+    this.rootDir = rootDir;
+    this.checker = checker;
+    this.calls = calls;
+    this.modelArgOf = modelArgOf;
+    this.maxDepth = options.maxDepth ?? DEFAULT_TRACE_DEPTH;
+    this.maxCallers = options.maxCallers ?? DEFAULT_MAX_CALLERS;
+    this.maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
+    this.maxCallerDepth = options.maxCallerDepth ?? DEFAULT_CALLER_DEPTH;
+  }
+  trace(expression, bindings = []) {
+    this.count = 0;
+    this.callerLevel = 0;
+    this.stack.clear();
+    this.reassigning.clear();
+    return this.value(expression, 0, envFrom(bindings));
+  }
+  traceAll(expressions, at) {
+    if (expressions.length === 1)
+      return this.trace(expressions[0]);
+    const children = expressions.map((expression) => this.trace(expression));
+    return this.node("oneOf", at, { children, resolution: rollup(children) });
+  }
+  missing(at, note, reason = "external") {
+    return this.node("external", at, { resolution: "unresolved", note, unresolvedReason: reason });
+  }
+  node(kind, at, extra) {
+    return makeNode(this.rootDir, kind, at, extra);
+  }
+  external(at, note, name, reason = "external") {
+    return this.node("external", at, { resolution: "unresolved", note, name, text: truncate(at.getText().replace(/\s+/g, " ")), unresolvedReason: reason });
+  }
+  depthLimit(at, name) {
+    return this.external(at, "depth limit reached", name, "depth-limit");
+  }
+  value(expression, depth, env) {
+    this.count += 1;
+    if (this.count > this.maxNodes)
+      return this.external(expression, "node budget reached", undefined, "depth-limit");
+    const expr = unwrap(expression);
+    if (this.stack.has(expr))
+      return this.external(expr, "cycle", undefined, "depth-limit");
+    this.stack.add(expr);
+    try {
+      return this.dispatch(expr, depth, env);
+    } finally {
+      this.stack.delete(expr);
+    }
+  }
+  hop(expression, depth, env) {
+    if (depth + 1 > this.maxDepth)
+      return this.depthLimit(expression);
+    return this.value(expression, depth + 1, env);
+  }
+  element(element, depth, env) {
+    return import_typescript2.default.isSpreadElement(element) ? { ...this.value(element.expression, depth, env), key: "..." } : this.value(element, depth, env);
+  }
+  dispatch(expr, depth, env) {
+    if (import_typescript2.default.isStringLiteral(expr) || import_typescript2.default.isNoSubstitutionTemplateLiteral(expr)) {
+      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" });
+    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" });
+    }
+    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" });
+    }
+    if (import_typescript2.default.isTemplateExpression(expr))
+      return this.template(expr, depth, env);
+    if (import_typescript2.default.isTaggedTemplateExpression(expr)) {
+      const tag = import_typescript2.default.isIdentifier(expr.tag) ? expr.tag.text : undefined;
+      if (tag && TEXT_HELPERS.has(tag))
+        return this.value(expr.template, depth, env);
+      return this.external(expr, `tagged template ${expr.tag.getText()}`);
+    }
+    if (import_typescript2.default.isBinaryExpression(expr))
+      return this.binary(expr, depth, env);
+    if (import_typescript2.default.isConditionalExpression(expr)) {
+      const children = [this.value(expr.whenTrue, depth, env), this.value(expr.whenFalse, depth, env)];
+      return this.node("oneOf", expr, { children, resolution: rollup(children), note: "conditional" });
+    }
+    if (import_typescript2.default.isArrayLiteralExpression(expr)) {
+      const children = expr.elements.slice(0, MAX_MEMBERS).map((element) => this.element(element, depth, env));
+      return this.node("array", expr, { children, resolution: children.length === 0 ? "resolved" : rollup(children) });
+    }
+    if (import_typescript2.default.isObjectLiteralExpression(expr))
+      return this.object(expr, depth, env);
+    if (import_typescript2.default.isIdentifier(expr))
+      return this.identifier(expr, depth, env);
+    if (import_typescript2.default.isPropertyAccessExpression(expr))
+      return this.propertyAccess(expr, depth, env);
+    if (import_typescript2.default.isElementAccessExpression(expr))
+      return this.elementAccess(expr, depth, env);
+    if (import_typescript2.default.isCallExpression(expr))
+      return this.call(expr, depth, env);
+    if (import_typescript2.default.isNewExpression(expr)) {
+      const name = expr.expression.getText();
+      const last = import_typescript2.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name.text : name;
+      if (MESSAGE_CLASS.test(last) && !resolvedFunction(expr.expression, this.checker)) {
+        const children = (expr.arguments ?? []).map((argument) => this.element(argument, depth, env));
+        return this.node("call", expr, { name, children, resolution: children.length === 0 ? "unresolved" : rollup(children), note: "constructor" });
+      }
+      return this.external(expr, `new ${name}`, name);
+    }
+    if (import_typescript2.default.isArrowFunction(expr) || import_typescript2.default.isFunctionExpression(expr))
+      return this.external(expr, "function value");
+    if (expr.kind === import_typescript2.default.SyntaxKind.ThisKeyword)
+      return this.external(expr, "this");
+    return this.external(expr, import_typescript2.default.SyntaxKind[expr.kind]);
+  }
+  template(expr, depth, env) {
+    const children = expr.templateSpans.map((span) => ({ ...this.value(span.expression, depth, env), hole: truncate(span.expression.getText().replace(/\s+/g, " ")) }));
+    const literalText = expr.head.text + expr.templateSpans.map((span) => span.literal.text).join("");
+    const resolution = children.every((child) => child.resolution === "resolved") ? "resolved" : literalText.trim() !== "" ? "partial" : rollup(children);
+    const parts = [expr.head.text, ...expr.templateSpans.map((span) => span.literal.text)];
+    return this.node("template", expr, { text: truncate(expr.getText()), children, parts, resolution });
+  }
+  binary(expr, depth, env) {
+    const operator = expr.operatorToken.kind;
+    if (operator === import_typescript2.default.SyntaxKind.PlusToken) {
+      const parts = [];
+      const flatten = (node) => {
+        const inner = unwrap(node);
+        if (import_typescript2.default.isBinaryExpression(inner) && inner.operatorToken.kind === import_typescript2.default.SyntaxKind.PlusToken) {
+          flatten(inner.left);
+          flatten(inner.right);
+        } else {
+          parts.push(node);
+        }
+      };
+      flatten(expr);
+      const children = parts.map((part) => this.value(part, depth, env));
+      return this.node("concat", expr, { children, resolution: rollup(children) });
+    }
+    if (operator === import_typescript2.default.SyntaxKind.QuestionQuestionToken || operator === import_typescript2.default.SyntaxKind.BarBarToken) {
+      const left = this.value(expr.left, depth, env);
+      if (left.resolution === "resolved" && leaves(left).every((leaf) => leaf.kind === "literal" && (operator === import_typescript2.default.SyntaxKind.QuestionQuestionToken || leaf.text !== "" && leaf.text !== "false" && leaf.text !== "0"))) {
+        return left;
+      }
+      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) {
+      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.external(expr, `binary ${import_typescript2.default.tokenToString(operator) ?? import_typescript2.default.SyntaxKind[operator]}`);
+  }
+  object(expr, depth, env) {
+    const children = [];
+    for (const property of expr.properties.slice(0, MAX_MEMBERS)) {
+      if (import_typescript2.default.isPropertyAssignment(property)) {
+        const key = propertyNameText(property.name) ?? property.name.getText();
+        children.push({ ...this.value(property.initializer, depth, env), key });
+      } else if (import_typescript2.default.isShorthandPropertyAssignment(property)) {
+        children.push({ ...this.value(property.name, depth, env), key: property.name.text });
+      } else if (import_typescript2.default.isSpreadAssignment(property)) {
+        children.push({ ...this.value(property.expression, depth, env), key: "..." });
+      } else if (import_typescript2.default.isMethodDeclaration(property) || import_typescript2.default.isGetAccessorDeclaration(property)) {
+        const key = propertyNameText(property.name) ?? property.name.getText();
+        children.push({ ...this.node("external", property, { resolution: "unresolved", note: "method", unresolvedReason: "external" }), key });
+      }
+    }
+    return this.node("object", expr, { children, resolution: children.length === 0 ? "resolved" : rollup(children) });
+  }
+  identifier(id, depth, env) {
+    const symbol = resolvedSymbol(id, this.checker);
+    const declaration = valueDeclaration(symbol);
+    if (!symbol || !declaration) {
+      const origin = importOrigin(id, this.checker);
+      if (origin)
+        return this.external(id, `import ${origin.imported} from ${origin.module}`, id.text);
+      return this.external(id, "unresolved identifier", id.text);
+    }
+    if (this.reassigning.has(declaration))
+      return this.external(id, "previous value", id.text);
+    if (import_typescript2.default.isParameter(declaration))
+      return this.parameter(declaration, id, depth, env);
+    if (import_typescript2.default.isBindingElement(declaration))
+      return this.bindingElement(declaration, id, depth, env);
+    if (import_typescript2.default.isVariableDeclaration(declaration) && import_typescript2.default.isVariableDeclarationList(declaration.parent) && import_typescript2.default.isForOfStatement(declaration.parent.parent)) {
+      if (depth + 1 > this.maxDepth)
+        return this.depthLimit(id, id.text);
+      const iterable = this.value(declaration.parent.parent.expression, depth + 1, env);
+      const values = allValues(iterable);
+      if (values.length === 0)
+        return this.external(id, "element of an unresolved iterable", id.text);
+      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);
+      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));
+      if (sources.length === 0)
+        return this.external(id, "declared without a value", id.text);
+      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)) {
+      if (!declaration.initializer)
+        return this.external(id, "declared without a value", id.text);
+      const child = this.hop(declaration.initializer, depth, env);
+      return this.node("ref", id, { name: id.text, children: [child], resolution: child.resolution });
+    }
+    if (import_typescript2.default.isShorthandPropertyAssignment(declaration))
+      return this.hop(declaration.name, depth, env);
+    if (import_typescript2.default.isFunctionDeclaration(declaration) || import_typescript2.default.isMethodDeclaration(declaration))
+      return this.external(id, "function", id.text);
+    if (import_typescript2.default.isClassDeclaration(declaration))
+      return this.external(id, "class", id.text);
+    return this.external(id, `declaration ${import_typescript2.default.SyntaxKind[declaration.kind]}`, id.text);
+  }
+  mutations(symbol, declaration) {
+    const scope = import_typescript2.default.isParameter(declaration) && isFunctionLike(declaration.parent) ? declaration.parent : enclosingScope(declaration);
+    const candidates = mutationsIn(scope).get(symbol.name) ?? [];
+    return candidates.filter((mutation) => resolvedSymbol(mutation.target, this.checker) === symbol).slice(0, MAX_MUTATIONS);
+  }
+  reassignments(declaration, mutations, depth, env) {
+    if (mutations.length === 0)
+      return [];
+    this.reassigning.add(declaration);
+    try {
+      return mutations.slice(0, MAX_RETURNS).map((mutation) => {
+        const values = mutation.values.map((value) => this.hop(value, depth, env));
+        if (mutation.op === "=")
+          return values[0];
+        const previous = this.node("external", mutation.target, { resolution: "unresolved", note: "previous value", name: mutation.target.text, unresolvedReason: "external" });
+        return this.node("concat", mutation.at, { children: [previous, ...values], resolution: values.every((value) => value.resolution === "unresolved") ? "unresolved" : "partial", note: "compound assignment" });
+      });
+    } finally {
+      this.reassigning.delete(declaration);
+    }
+  }
+  assembled(id, declaration, mutations, depth, env) {
+    if (depth + 1 > this.maxDepth)
+      return this.depthLimit(id, id.text);
+    const items = [];
+    let order = 0;
+    const tag = (value, note) => ({ ...value, order: order++, note });
+    const init = declaration.initializer ? unwrap(declaration.initializer) : undefined;
+    const arrayOps = mutations.some((mutation) => mutation.op === "push" || mutation.op === "unshift" || mutation.op === "splice" || mutation.op === "concat");
+    if (init && import_typescript2.default.isArrayLiteralExpression(init)) {
+      for (const element of init.elements.slice(0, MAX_MEMBERS))
+        items.push(tag(this.element(element, depth + 1, env), "init"));
+    } else if (init) {
+      items.push(tag(this.value(init, depth + 1, env), "init"));
+    }
+    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));
+        if (mutation.op === "=") {
+          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 {
+          items.push(...values);
+        }
+      }
+    } finally {
+      this.reassigning.delete(declaration);
+    }
+    const isString = !arrayOps && (!init || !import_typescript2.default.isArrayLiteralExpression(init));
+    return this.node("assembled", id, {
+      name: id.text,
+      children: items,
+      resolution: items.length === 0 ? arrayOps ? "resolved" : "unresolved" : rollup(items),
+      text: arrayOps || init && import_typescript2.default.isArrayLiteralExpression(init) ? "array" : isString ? "string" : undefined
+    });
+  }
+  parameter(declaration, at, depth, env) {
+    const name = import_typescript2.default.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
+    const fn = declaration.parent;
+    const bindings = [];
+    const children = [];
+    let note;
+    let reason;
+    const bound = env.get(declaration);
+    if (bound) {
+      const argument = bound.expr && !isUndefinedLiteral(bound.expr) ? bound.expr : undefined;
+      if (argument)
+        bindings.push(bound.traced ?? this.value(argument, depth, bound.env));
+      else if (declaration.initializer)
+        children.push(this.value(declaration.initializer, depth, env));
+      else {
+        note = "argument omitted";
+        reason = "param-unbound";
+      }
+    } else if (declaration.dotDotDotToken) {
+      note = "rest parameter";
+      reason = "param-unbound";
+    } else if (isFunctionLike(fn)) {
+      const fnName = functionName(fn);
+      if (this.callerLevel >= this.maxCallerDepth) {
+        note = `caller depth limit (${this.maxCallerDepth})`;
+        reason = "depth-limit";
+      } else {
+        const index = fn.parameters.indexOf(declaration);
+        const found = fnName ? this.calls.callersOf(fn, fnName, this.maxCallers + 1) : [];
+        const callers = found.slice(0, this.maxCallers);
+        this.callerLevel += 1;
+        try {
+          if (found.length > callers.length)
+            bindings.push(this.node("external", declaration, { resolution: "unresolved", note: `more than ${this.maxCallers} call sites of ${fnName}; the rest not followed`, unresolvedReason: "depth-limit" }));
+          let usedDefault = false;
+          for (const call of callers) {
+            const spreadBefore = call.arguments.slice(0, index + 1).some((argument2) => import_typescript2.default.isSpreadElement(argument2));
+            const argument = call.arguments[index];
+            if (spreadBefore) {
+              bindings.push(this.external(call, "spread arguments"));
+            } else if (argument && !isUndefinedLiteral(argument)) {
+              bindings.push(this.hop(argument, depth, EMPTY_ENV));
+            } else if (declaration.initializer && !usedDefault) {
+              usedDefault = true;
+              children.push(this.hop(declaration.initializer, depth, env));
+            } else if (!declaration.initializer) {
+              bindings.push(this.node("external", call, { resolution: "unresolved", note: "argument omitted", unresolvedReason: "param-unbound" }));
+            }
+          }
+        } finally {
+          this.callerLevel -= 1;
+        }
+        if (callers.length === 0) {
+          if (declaration.initializer)
+            children.push(this.hop(declaration.initializer, depth, env));
+          note = fnName ? `no call sites of ${fnName} found` : "callback parameter";
+          reason = "param-unbound";
+        }
+      }
+    }
+    if (!this.reassigning.has(declaration) && isFunctionLike(fn) && fn.body) {
+      const symbol = import_typescript2.default.isIdentifier(declaration.name) ? this.checker.getSymbolAtLocation(declaration.name) : undefined;
+      if (symbol) {
+        const mutations = this.mutations(symbol, declaration).filter((mutation) => mutation.op === "=" || mutation.op === "+=");
+        children.push(...this.reassignments(declaration, mutations, depth, env));
+      }
+    }
+    const all = [...bindings, ...children];
+    const resolution = rollup(all);
+    return this.node("param", at, {
+      name,
+      bindings: bindings.length > 0 ? bindings : undefined,
+      children: children.length > 0 ? children : undefined,
+      resolution,
+      note,
+      unresolvedReason: resolution === "unresolved" ? reasonOf("unresolved", all).unresolvedReason ?? reason ?? "param-unbound" : undefined
+    });
+  }
+  bindingElement(element, at, depth, env) {
+    const pattern = element.parent;
+    const name = import_typescript2.default.isIdentifier(element.name) ? element.name.text : element.name.getText();
+    if (!import_typescript2.default.isObjectBindingPattern(pattern) || element.dotDotDotToken)
+      return this.external(at, "array or rest destructuring", name);
+    const key = propertyNameText(element.propertyName ?? element.name);
+    if (!key)
+      return this.external(at, "computed destructuring key", name);
+    const holder = pattern.parent;
+    let whole;
+    if (import_typescript2.default.isVariableDeclaration(holder) && holder.initializer)
+      whole = this.hop(holder.initializer, depth, env);
+    else if (import_typescript2.default.isParameter(holder))
+      whole = this.parameter(holder, holder, depth + 1, env);
+    else if (import_typescript2.default.isBindingElement(holder))
+      whole = this.bindingElement(holder, holder, depth + 1, env);
+    if (!whole)
+      return this.external(at, "destructured from an unknown value", name);
+    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 fallback = this.hop(element.initializer, depth, env);
+      selected = substitute(selected, missing, 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 });
+  }
+  keyLiteral(at, key) {
+    return this.node("literal", at, { text: key, resolution: "resolved" });
+  }
+  tableRef(receiver, resolution) {
+    return this.node("ref", receiver, { name: truncate(receiver.getText().replace(/\s+/g, " ")), resolution, note: "table (member resolved by declaration)" });
+  }
+  propertyAccess(expr, depth, env) {
+    const key = expr.name.text;
+    const receiver = unwrap(expr.expression);
+    const receiverName = import_typescript2.default.isPropertyAccessExpression(receiver) ? receiver.name.text : import_typescript2.default.isIdentifier(receiver) ? receiver.text : undefined;
+    if (receiverName === "env")
+      return this.node("env", expr, { name: key, resolution: "unresolved", note: "environment variable", unresolvedReason: "env" });
+    const keyNode = this.keyLiteral(expr.name, key);
+    const symbol = resolvedSymbol(expr.name, this.checker);
+    const declaration = symbol?.declarations?.find((candidate) => (import_typescript2.default.isPropertyAssignment(candidate) || import_typescript2.default.isPropertyDeclaration(candidate) || import_typescript2.default.isEnumMember(candidate) || import_typescript2.default.isVariableDeclaration(candidate)) && candidate.initializer) ?? symbol?.declarations?.find((candidate) => import_typescript2.default.isShorthandPropertyAssignment(candidate) || import_typescript2.default.isGetAccessorDeclaration(candidate));
+    const lookup = (children, note) => {
+      const resolution = rollup(children);
+      return this.node("lookup", expr, { name: expr.getText(), key, keyNode, object: this.tableRef(expr.expression, resolution), children, resolution, note });
+    };
+    if (declaration && (import_typescript2.default.isPropertyAssignment(declaration) || import_typescript2.default.isPropertyDeclaration(declaration) || import_typescript2.default.isEnumMember(declaration) || import_typescript2.default.isVariableDeclaration(declaration))) {
+      const children = [this.hop(declaration.initializer, depth, env)];
+      if (import_typescript2.default.isPropertyDeclaration(declaration) && symbol)
+        children.push(...this.memberAssignments(declaration, key, depth, env));
+      return lookup(children);
+    }
+    if (declaration && import_typescript2.default.isShorthandPropertyAssignment(declaration))
+      return lookup([this.hop(declaration.name, depth, env)]);
+    if (declaration && import_typescript2.default.isGetAccessorDeclaration(declaration)) {
+      return lookup(returnExpressions(declaration).slice(0, MAX_RETURNS).map((ret) => this.hop(ret, depth, env)), "getter");
+    }
+    const field = symbol?.declarations?.find((candidate) => import_typescript2.default.isPropertyDeclaration(candidate));
+    if (field && import_typescript2.default.isPropertyDeclaration(field)) {
+      const children = this.memberAssignments(field, key, depth, env);
+      if (children.length > 0)
+        return lookup(children);
+    }
+    if (depth + 1 > this.maxDepth)
+      return this.depthLimit(expr);
+    const whole = this.value(expr.expression, depth + 1, env);
+    const selected = selectKey(whole, key, this.missing(expr, `property ${key} not found`, whole.resolution === "unresolved" ? whole.unresolvedReason : "external"));
+    return this.node("lookup", expr, { name: expr.getText(), key, keyNode, object: shallow(whole), children: [selected], resolution: selected.resolution });
+  }
+  memberAssignments(field, key, depth, env) {
+    const cls = field.parent;
+    const out = [];
+    const visit = (node) => {
+      if (out.length >= MAX_RETURNS)
+        return;
+      if (import_typescript2.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript2.default.SyntaxKind.EqualsToken && import_typescript2.default.isPropertyAccessExpression(node.left) && node.left.expression.kind === import_typescript2.default.SyntaxKind.ThisKeyword && node.left.name.text === key && enclosingClass(node) === cls) {
+        out.push(this.hop(node.right, depth, env));
+      }
+      import_typescript2.default.forEachChild(node, visit);
+    };
+    import_typescript2.default.forEachChild(cls, visit);
+    return out;
+  }
+  elementAccess(expr, depth, env) {
+    const argument = unwrap(expr.argumentExpression);
+    if (depth + 1 > this.maxDepth)
+      return this.depthLimit(expr);
+    const whole = this.value(expr.expression, depth + 1, env);
+    const object = shallow(whole);
+    const name = expr.getText();
+    if (import_typescript2.default.isStringLiteral(argument) || import_typescript2.default.isNoSubstitutionTemplateLiteral(argument) || import_typescript2.default.isNumericLiteral(argument)) {
+      const selected = selectKey(whole, argument.text, this.missing(expr, `property ${argument.text} not found`, whole.resolution === "unresolved" ? whole.unresolvedReason : "external"));
+      return this.node("lookup", expr, { name, key: argument.text, keyNode: this.keyLiteral(argument, argument.text), object, children: [selected], resolution: selected.resolution });
+    }
+    const keyNode = this.value(argument, depth + 1, env);
+    const keys = keyNode.resolution === "resolved" ? renderings(keyNode) : [];
+    if (keys.length > 0 && !keys.some((key) => key.includes("${...}"))) {
+      const children = [...new Set(keys)].map((key) => {
+        const missing = this.node("external", expr, { resolution: "unresolved", note: `no entry for key ${JSON.stringify(key)}`, name: "undefined", unresolvedReason: "external" });
+        const selected = selectKey(whole, key, missing);
+        return selected === missing ? missing : { ...selected, key };
+      });
+      return this.node("lookup", expr, { name, keyNode, object, children, resolution: rollup(children), note: "computed key" });
+    }
+    const values = allValues(whole);
+    if (values.length === 0) {
+      return this.node("lookup", expr, { name, keyNode, object, resolution: "unresolved", note: `dynamic key ${truncate(argument.getText())} on a value with no known entries`, unresolvedReason: "dynamic-key" });
+    }
+    const literal = values.some((value) => value.resolution !== "unresolved");
+    return this.node("lookup", expr, {
+      name,
+      keyNode,
+      object,
+      children: values,
+      resolution: literal ? "partial" : "unresolved",
+      unresolvedReason: literal ? undefined : "dynamic-key",
+      note: `dynamic key ${truncate(argument.getText())}`
+    });
+  }
+  call(expr, depth, env) {
+    const callee = unwrap(expr.expression);
+    const factoryModel = this.modelArgOf?.(expr);
+    if (factoryModel) {
+      const child = this.hop(factoryModel, depth, env);
+      return this.node("call", expr, { name: callee.getText(), children: [child], resolution: child.resolution, note: "model factory" });
+    }
+    if (import_typescript2.default.isPropertyAccessExpression(callee)) {
+      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 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" }));
+          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 });
+      }
+    }
+    if (import_typescript2.default.isPropertyAccessExpression(callee) && import_typescript2.default.isIdentifier(callee.expression) && callee.expression.text === "JSON" && callee.name.text === "stringify" && expr.arguments[0]) {
+      const child = this.value(expr.arguments[0], depth, env);
+      return this.node("call", expr, { name: "JSON.stringify", children: [child], resolution: child.resolution });
+    }
+    if (import_typescript2.default.isIdentifier(callee) && TEXT_HELPERS.has(callee.text) && expr.arguments.length === 1 && !resolvedFunction(callee, this.checker)) {
+      return this.value(expr.arguments[0], depth, env);
+    }
+    const fn = resolvedFunction(callee, this.checker);
+    const name = callee.getText().replace(/\s+/g, "");
+    if (!fn) {
+      const root = rootOf(callee);
+      const origin = root ? importOrigin(root, this.checker) : undefined;
+      if (PROMPT_FACTORY.test(name) || import_typescript2.default.isIdentifier(callee) && MESSAGE_CLASS.test(callee.text)) {
+        const children = expr.arguments.map((argument) => this.element(argument, depth, env));
+        return this.node("call", expr, { name, children, resolution: children.length === 0 ? "unresolved" : rollup(children), note: origin ? `call into ${origin.module}` : "prompt template" });
+      }
+      const last = import_typescript2.default.isPropertyAccessExpression(callee) ? callee.name.text : import_typescript2.default.isIdentifier(callee) ? callee.text : "";
+      const io = origin && IO_MODULE.test(origin.module) || IO_METHOD.test(last);
+      return this.external(expr, origin ? `call into ${origin.module}` : "call to an unresolved function", name, io ? "io" : "external");
+    }
+    if (depth + 1 > this.maxDepth)
+      return this.depthLimit(expr, name);
+    const returns = returnExpressions(fn).slice(0, MAX_RETURNS);
+    const anchor = { anchorPath: relPath(this.rootDir, fn.getSourceFile().fileName), anchorLine: lineOf(fn) };
+    const args = expr.arguments.slice(0, MAX_MEMBERS).map((argument) => this.element(argument, depth, env));
+    if (returns.length === 0) {
+      return this.node("call", expr, { name, args, ...anchor, resolution: "unresolved", note: "function returns no value", unresolvedReason: "external" });
+    }
+    const inner = new Map(env);
+    fn.parameters.forEach((parameter, index) => {
+      if (expr.arguments.slice(0, index + 1).some((argument) => import_typescript2.default.isSpreadElement(argument)))
+        return;
+      inner.set(parameter, { expr: expr.arguments[index], env, traced: args[index] });
+    });
+    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 });
+  }
+  reachableReturn(ret, fn, depth, env) {
+    let node = ret;
+    while (node.parent && node !== fn) {
+      const parent = node.parent;
+      if (import_typescript2.default.isIfStatement(parent) && node !== parent.expression) {
+        const value = this.condition(parent.expression, depth, env);
+        if (value === false && node === parent.thenStatement)
+          return false;
+        if (value === true && node === parent.elseStatement)
+          return false;
+      }
+      if (import_typescript2.default.isBlock(parent) || import_typescript2.default.isSourceFile(parent)) {
+        for (const statement of parent.statements) {
+          if (statement === node)
+            break;
+          if (import_typescript2.default.isIfStatement(statement) && !statement.elseStatement && alwaysReturns(statement.thenStatement) && this.condition(statement.expression, depth, env) === true)
+            return false;
+        }
+      }
+      node = parent;
+    }
+    return true;
+  }
+  condition(expression, depth, env) {
+    const expr = unwrap(expression);
+    if (!import_typescript2.default.isBinaryExpression(expr))
+      return;
+    const operator = expr.operatorToken.kind;
+    const equal = operator === import_typescript2.default.SyntaxKind.EqualsEqualsEqualsToken || operator === import_typescript2.default.SyntaxKind.EqualsEqualsToken;
+    const notEqual = operator === import_typescript2.default.SyntaxKind.ExclamationEqualsEqualsToken || operator === import_typescript2.default.SyntaxKind.ExclamationEqualsToken;
+    if (!equal && !notEqual)
+      return;
+    const left = unwrap(expr.left);
+    const right = unwrap(expr.right);
+    const literal = import_typescript2.default.isStringLiteral(right) || import_typescript2.default.isNoSubstitutionTemplateLiteral(right) ? right : import_typescript2.default.isStringLiteral(left) || import_typescript2.default.isNoSubstitutionTemplateLiteral(left) ? left : undefined;
+    if (!literal)
+      return;
+    const operand = literal === right ? expr.left : expr.right;
+    const traced = this.value(operand, depth, env);
+    if (traced.resolution !== "resolved")
+      return;
+    const values = renderings(traced);
+    if (values.length === 0 || values.some((value) => value.includes("${...}")))
+      return;
+    const matches = values.map((value) => value === literal.text);
+    if (matches.every(Boolean))
+      return equal;
+    if (!matches.some(Boolean))
+      return notEqual;
+    return;
+  }
+  arrayJoin(expr, callee, depth, env) {
+    let receiver = unwrap(callee.expression);
+    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") {
+      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 });
+  }
+}
+function alwaysReturns(statement) {
+  if (import_typescript2.default.isReturnStatement(statement) || import_typescript2.default.isThrowStatement(statement))
+    return true;
+  if (import_typescript2.default.isBlock(statement)) {
+    const last = statement.statements[statement.statements.length - 1];
+    return Boolean(last && alwaysReturns(last));
+  }
+  return false;
+}
+function isUndefinedLiteral(node) {
+  const inner = unwrap(node);
+  return import_typescript2.default.isIdentifier(inner) && inner.text === "undefined" || import_typescript2.default.isVoidExpression(inner);
+}
+function enclosingScope(node) {
+  for (let current = node.parent;current; current = current.parent) {
+    if (isFunctionLike(current) || import_typescript2.default.isSourceFile(current))
+      return current;
+  }
+  return node.getSourceFile();
+}
+function rootOf(expression) {
+  let current = unwrap(expression);
+  while (import_typescript2.default.isPropertyAccessExpression(current) || import_typescript2.default.isElementAccessExpression(current) || import_typescript2.default.isCallExpression(current))
+    current = unwrap(current.expression);
+  return import_typescript2.default.isIdentifier(current) ? current : undefined;
+}
+function resolvedFunction(callee, checker) {
+  const inner = unwrap(callee);
+  if (import_typescript2.default.isArrowFunction(inner) || import_typescript2.default.isFunctionExpression(inner))
+    return inner;
+  const nameNode = import_typescript2.default.isPropertyAccessExpression(inner) ? inner.name : import_typescript2.default.isIdentifier(inner) ? inner : undefined;
+  if (!nameNode)
+    return;
+  const symbol = resolvedSymbol(nameNode, checker);
+  for (const declaration of symbol?.declarations ?? []) {
+    if (isFunctionLike(declaration) && declaration.body)
+      return declaration;
+    if ((import_typescript2.default.isVariableDeclaration(declaration) || import_typescript2.default.isPropertyAssignment(declaration) || import_typescript2.default.isPropertyDeclaration(declaration)) && declaration.initializer) {
+      const value = unwrap(declaration.initializer);
+      if ((import_typescript2.default.isArrowFunction(value) || import_typescript2.default.isFunctionExpression(value)) && value.body)
+        return value;
+    }
+  }
+  return;
+}
+function selectKey(tree, key, missing) {
+  if (tree.kind === "object") {
+    const members = tree.children ?? [];
+    for (let index = members.length - 1;index >= 0; index -= 1) {
+      const member = members[index];
+      if (member.key === key)
+        return { ...member, key };
+      if (member.key === "...") {
+        const fromSpread = selectKey(member, key, missing);
+        if (fromSpread !== missing)
+          return fromSpread;
+        if (member.kind !== "object")
+          return { ...missing, note: `property ${key} may come from an unresolved spread` };
+      }
+    }
+    return missing;
+  }
+  if (FLOW_KINDS.has(tree.kind)) {
+    const flow = valueChildren(tree);
+    if (flow.length === 0)
+      return { ...missing, note: `property ${key} of ${tree.kind}${tree.name ? ` ${tree.name}` : ""}` };
+    const selected = new Map(flow.map((child) => [child, selectKey(child, key, missing)]));
+    if ([...selected.values()].every((child) => child === missing))
+      return missing;
+    return mapFlow(tree, (child) => selected.get(child) ?? child);
+  }
+  return { ...missing, note: `property ${key} of ${tree.kind}${tree.name ? ` ${tree.name}` : ""}` };
+}
+var FLOW_KINDS = new Set(["ref", "call", "param", "oneOf", "lookup"]);
+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 substitute(tree, target, replacement) {
+  if (tree === target)
+    return replacement;
+  if (!hasNode(tree, target))
+    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)) };
+}
+function allValues(tree) {
+  if (tree.kind === "object" || tree.kind === "array" || tree.kind === "assembled" && tree.text === "array") {
+    return (tree.children ?? []).flatMap((child) => child.key === "..." ? allValues(child) : [child]);
+  }
+  if (FLOW_KINDS.has(tree.kind))
+    return valueChildren(tree).flatMap((child) => allValues(child));
+  return [];
+}
+function renderings(tree, limit = 16) {
+  const combine = (pieces) => {
+    let out = [""];
+    for (const options of pieces) {
+      const next = [];
+      for (const prefix of out)
+        for (const option of options)
+          if (next.length < limit)
+            next.push(prefix + option);
+      out = next;
+    }
+    return out;
+  };
+  switch (tree.kind) {
+    case "literal":
+      return [tree.text ?? ""];
+    case "template": {
+      const parts = tree.parts ?? [];
+      const pieces = [];
+      parts.forEach((part, index) => {
+        pieces.push([part]);
+        const child = tree.children?.[index];
+        if (child)
+          pieces.push(renderings(child, limit));
+      });
+      return combine(pieces);
+    }
+    case "concat":
+      return combine((tree.children ?? []).map((child) => renderings(child, limit)));
+    case "assembled":
+      return tree.text === "string" ? combine((tree.children ?? []).map((child) => renderings(child, limit))) : ["${...}"];
+    case "ref":
+    case "lookup":
+    case "param":
+    case "call":
+    case "oneOf": {
+      const out = valueChildren(tree).flatMap((child) => renderings(child, limit)).slice(0, limit);
+      return out.length > 0 ? out : ["${...}"];
+    }
+    default:
+      return ["${...}"];
+  }
+}
+
+// src/harness-extract/calls.ts
+class CallIndex {
+  program;
+  checker;
+  byName;
+  aliases = new Map;
+  members = new Map;
+  constructor(program, checker) {
+    this.program = program;
+    this.checker = checker;
+  }
+  build() {
+    const byName = new Map;
+    for (const source of this.program.getSourceFiles()) {
+      if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
+        continue;
+      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);
+          if (import_typescript3.default.isBinaryExpression(init) && (init.operatorToken.kind === import_typescript3.default.SyntaxKind.QuestionQuestionToken || init.operatorToken.kind === import_typescript3.default.SyntaxKind.BarBarToken))
+            init = unwrap(init.right);
+          if (import_typescript3.default.isIdentifier(init)) {
+            const entry = { declaration: node, target: init };
+            const list = this.aliases.get(init.text);
+            if (list)
+              list.push(entry);
+            else
+              this.aliases.set(init.text, [entry]);
+          }
+        }
+        if ((import_typescript3.default.isPropertyAssignment(node) || import_typescript3.default.isShorthandPropertyAssignment(node)) && import_typescript3.default.isObjectLiteralExpression(node.parent)) {
+          const value = import_typescript3.default.isShorthandPropertyAssignment(node) ? node.name : unwrap(node.initializer);
+          const property = import_typescript3.default.isIdentifier(node.name) || import_typescript3.default.isStringLiteral(node.name) ? node.name.text : undefined;
+          if (property && import_typescript3.default.isIdentifier(value)) {
+            const entry = { property, literal: node.parent, target: value };
+            const list = this.members.get(value.text);
+            if (list)
+              list.push(entry);
+            else
+              this.members.set(value.text, [entry]);
+          }
+        }
+        if (import_typescript3.default.isCallExpression(node)) {
+          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]);
+          }
+        }
+        import_typescript3.default.forEachChild(node, visit);
+      };
+      visit(source);
+    }
+    return byName;
+  }
+  callersOf(fn, name, limit) {
+    this.byName ??= this.build();
+    const out = this.direct(name, limit, (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;
+      const aliasName = alias.declaration.name.text;
+      out.push(...this.direct(aliasName, limit - out.length, (declaration) => declaration === alias.declaration));
+    }
+    for (const member of this.members.get(name) ?? []) {
+      if (out.length >= limit)
+        break;
+      const symbol = resolvedSymbol(member.target, this.checker);
+      if (!symbol?.declarations?.some((declaration) => declares(declaration, fn)))
+        continue;
+      for (const param of this.holders(member.literal)) {
+        out.push(...this.memberCalls(param, member.property, limit - out.length));
+      }
+    }
+    return out;
+  }
+  holders(literal) {
+    let node = literal;
+    while (node.parent && (import_typescript3.default.isParenthesizedExpression(node.parent) || import_typescript3.default.isAsExpression(node.parent) || import_typescript3.default.isSatisfiesExpression(node.parent)))
+      node = node.parent;
+    const parent = node.parent;
+    const out = [];
+    if (parent && import_typescript3.default.isCallExpression(parent)) {
+      const index = parent.arguments.indexOf(node);
+      const fn = index >= 0 ? resolvedFunction(parent.expression, this.checker) : undefined;
+      if (fn && fn.parameters[index])
+        out.push(fn.parameters[index]);
+    } else if (parent && import_typescript3.default.isParameter(parent) && parent.initializer === node) {
+      out.push(parent);
+    } else if (parent && import_typescript3.default.isVariableDeclaration(parent) && parent.initializer === node && import_typescript3.default.isIdentifier(parent.name)) {
+      for (const alias of this.aliases.get(parent.name.text) ?? []) {
+        if (import_typescript3.default.isParameter(alias.declaration) && valueDeclaration(resolvedSymbol(alias.target, this.checker)) === parent)
+          out.push(alias.declaration);
+      }
+    }
+    return out;
+  }
+  memberCalls(param, property, limit) {
+    const out = [];
+    for (const call of this.byName.get(property) ?? []) {
+      if (out.length >= limit)
+        break;
+      const callee = unwrap(call.expression);
+      if (import_typescript3.default.isPropertyAccessExpression(callee)) {
+        const receiver = unwrap(callee.expression);
+        if (import_typescript3.default.isIdentifier(receiver) && valueDeclaration(resolvedSymbol(receiver, this.checker)) === param)
+          out.push(call);
+      } else if (import_typescript3.default.isIdentifier(callee)) {
+        const declaration = valueDeclaration(resolvedSymbol(callee, this.checker));
+        if (!declaration || !import_typescript3.default.isBindingElement(declaration))
+          continue;
+        const holder = declaration.parent.parent;
+        const init = import_typescript3.default.isVariableDeclaration(holder) && holder.initializer ? unwrap(holder.initializer) : undefined;
+        if (holder === param || init && import_typescript3.default.isIdentifier(init) && valueDeclaration(resolvedSymbol(init, this.checker)) === param)
+          out.push(call);
+      }
+    }
+    return out;
+  }
+  direct(name, limit, matches) {
+    const candidates = this.byName.get(name) ?? [];
+    const out = [];
+    let checked = 0;
+    for (const call of candidates) {
+      if (out.length >= limit || checked >= limit * 20)
+        break;
+      checked += 1;
+      const callee = unwrap(call.expression);
+      const nameNode = import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name : callee;
+      const symbol = resolvedSymbol(nameNode, this.checker);
+      if (symbol?.declarations?.some(matches))
+        out.push(call);
+    }
+    return out;
+  }
+}
+function declares(declaration, fn) {
+  if (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)
+    return true;
+  return false;
+}
+
+// src/harness-extract/messages.ts
+var ROLE_LITERALS = {
+  system: "system",
+  developer: "system",
+  user: "user",
+  human: "user",
+  assistant: "assistant",
+  ai: "assistant",
+  model: "assistant",
+  tool: "tool",
+  function: "tool"
+};
+var CONSTRUCTOR_ROLE = [
+  [/(?:^|\.)System(?:Message|MessagePromptTemplate)\b/, "system"],
+  [/(?:^|\.)(?:Human|User)(?:Message|MessagePromptTemplate)\b/, "user"],
+  [/(?:^|\.)(?:AI|Ai|Assistant)(?:Message|MessagePromptTemplate)\b/, "assistant"],
+  [/(?:^|\.)(?:Tool|Function)Message\b/, "tool"]
+];
+var PASS_THROUGH = new Set(["ref", "lookup", "param", "call", "oneOf"]);
+var STRINGY = new Set(["literal", "template", "concat", "arrayJoin"]);
+var MAX_CONTAINERS = 16;
+function singleLiteral(tree) {
+  if (!tree)
+    return;
+  if (tree.kind === "literal")
+    return tree.text;
+  if (PASS_THROUGH.has(tree.kind)) {
+    const flow = valueChildren(tree);
+    if (flow.length === 1)
+      return singleLiteral(flow[0]);
+  }
+  return;
+}
+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";
+  }
+  if (element.kind === "array") {
+    const text = singleLiteral(element.children?.[0]);
+    return text && ROLE_LITERALS[text.toLowerCase()] || "unknown";
+  }
+  if ((element.kind === "call" || element.kind === "external") && element.name) {
+    for (const [pattern, role] of CONSTRUCTOR_ROLE)
+      if (pattern.test(element.name))
+        return role;
+  }
+  if (PASS_THROUGH.has(element.kind)) {
+    const roles = new Set(valueChildren(element).map((child) => elementRole(child, depth + 1)));
+    return roles.size === 1 ? [...roles][0] : "unknown";
+  }
+  return "unknown";
+}
+function containersOf(tree, containers, others, depth = 0) {
+  if (containers.length >= MAX_CONTAINERS)
+    return;
+  if (tree.kind === "array" || tree.kind === "assembled" && tree.text !== "string") {
+    containers.push(tree);
+    return;
+  }
+  const flow = PASS_THROUGH.has(tree.kind) ? valueChildren(tree) : [];
+  if (flow.length > 0 && depth < 12) {
+    for (const child of flow)
+      containersOf(child, containers, others, depth + 1);
+    return;
+  }
+  others.push(tree);
+}
+function splitMessages(tree) {
+  const containers = [];
+  const others = [];
+  containersOf(tree, containers, others);
+  if (containers.length === 0) {
+    return [{ role: STRINGY.has(tree.kind) || others.length > 0 && others.every((other) => STRINGY.has(other.kind)) ? "user" : "unknown", tree }];
+  }
+  const out = [];
+  for (const container of containers) {
+    (container.children ?? []).forEach((element, index) => {
+      out.push({ role: elementRole(element), tree: element, message: { arrayId: container.id, index } });
+    });
+  }
+  for (const other of others)
+    out.push({ role: STRINGY.has(other.kind) ? "user" : "unknown", tree: other });
+  return out;
+}
+
+// src/harness-extract/program.ts
+var import_typescript4 = __toESM(require_typescript(), 1);
+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__"]);
+var CODE_FILE = /\.(?:[cm]?[jt]sx?)$/i;
+var SVELTE_FILE = /\.svelte$/i;
+var SCRIPT_BLOCK = /(<script\b[^>]*>)([\s\S]*?)<\/script\s*>/gi;
+function svelteScriptText(text) {
+  const out = text.replace(/[^\n]/g, " ").split("");
+  for (const match of text.matchAll(SCRIPT_BLOCK)) {
+    const start = (match.index ?? 0) + match[1].length;
+    for (let index = 0;index < match[2].length; index += 1)
+      out[start + index] = match[2][index];
+  }
+  return out.join("");
+}
+var DECLARATION_FILE = /\.d\.[cm]?ts$/i;
+var TEST_RUNNER_FILE = /(?:^|\/)__tests__\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+var TEST_PATH = /(?:^|\/)(?:test|tests|__tests__|test-fixtures|fixtures?|__fixtures__|__mocks__|e2e)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+var EVAL_PATH = /(?:^|\/)evals?\/|\.evals?\.[cm]?[jt]sx?$/i;
+var MAX_FILE_BYTES = 1024 * 1024;
+var DEFAULT_MAX_FILES = 20000;
+function isTestPath(rel) {
+  return TEST_PATH.test(rel);
+}
+function isEvalPath(rel) {
+  return EVAL_PATH.test(rel);
+}
+function walkRepository(rootDir, maxFiles, includeTestRunnerFiles) {
+  const files = [];
+  const configs = [];
+  let truncated = false;
+  const walk = (abs, rel) => {
+    let entries;
+    try {
+      entries = readdirSync(abs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (files.length >= maxFiles) {
+        truncated = true;
+        return;
+      }
+      const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+      const childAbs = join(abs, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !SKIPPED_DIRS.has(entry.name))
+          walk(childAbs, childRel);
+      } else if (entry.isFile()) {
+        if (entry.name === "tsconfig.json")
+          configs.push(childAbs);
+        else if (SVELTE_FILE.test(entry.name)) {
+          try {
+            if (statSync(childAbs).size <= MAX_FILE_BYTES)
+              files.push(svelteVirtualName(childAbs));
+          } catch {
+            continue;
+          }
+        } else if (CODE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name) && !/\.min\.[cm]?js$/i.test(entry.name) && (includeTestRunnerFiles || !TEST_RUNNER_FILE.test(childRel))) {
+          try {
+            if (statSync(childAbs).size > MAX_FILE_BYTES)
+              continue;
+          } catch {
+            continue;
+          }
+          files.push(childAbs);
+        }
+      }
+    }
+  };
+  walk(rootDir, "");
+  return { files, configs, truncated };
+}
+function extractorOptions(base) {
+  const options = {
+    ...base,
+    noEmit: true,
+    skipLibCheck: true,
+    noLib: true,
+    types: [],
+    noResolve: false,
+    allowJs: true,
+    checkJs: false,
+    resolveJsonModule: false,
+    declaration: false,
+    composite: false,
+    incremental: false,
+    tsBuildInfoFile: undefined,
+    plugins: undefined
+  };
+  if (options.moduleResolution === undefined) {
+    options.module = import_typescript4.default.ModuleKind.ESNext;
+    options.moduleResolution = import_typescript4.default.ModuleResolutionKind.Bundler;
+  }
+  options.allowImportingTsExtensions = true;
+  return options;
+}
+var FALLBACK_OPTIONS = extractorOptions({
+  target: import_typescript4.default.ScriptTarget.ES2022,
+  jsx: import_typescript4.default.JsxEmit.Preserve,
+  esModuleInterop: true
+});
+function sharedHost(options, cache) {
+  const host = import_typescript4.default.createCompilerHost(options, true);
+  const moduleCache = import_typescript4.default.createModuleResolutionCache(host.getCurrentDirectory(), (name) => name, options);
+  host.getSourceFile = (fileName, languageVersionOrOptions) => {
+    const version = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.languageVersion : languageVersionOrOptions;
+    const key = `${version}:${fileName}`;
+    if (cache.has(key))
+      return cache.get(key);
+    let source;
+    const svelte = fileName.endsWith(SVELTE_VIRTUAL_SUFFIX);
+    const raw = import_typescript4.default.sys.readFile(svelte ? fileName.slice(0, -SVELTE_VIRTUAL_SUFFIX.length) : fileName);
+    const text = svelte && raw !== undefined ? svelteScriptText(raw) : raw;
+    if (text !== undefined && text.length <= MAX_FILE_BYTES) {
+      source = import_typescript4.default.createSourceFile(fileName, text, languageVersionOrOptions, true, svelte ? import_typescript4.default.ScriptKind.TS : undefined);
+    }
+    cache.set(key, source);
+    return source;
+  };
+  host.resolveModuleNameLiterals = (literals, containingFile, redirected, compilerOptions) => literals.map((literal) => {
+    const resolved = import_typescript4.default.resolveModuleName(literal.text, containingFile, compilerOptions, host, moduleCache, redirected).resolvedModule;
+    if (!resolved || resolved.isExternalLibraryImport || /[\\/]node_modules[\\/]/.test(resolved.resolvedFileName) || DECLARATION_FILE.test(resolved.resolvedFileName) || !CODE_FILE.test(resolved.resolvedFileName)) {
+      return { resolvedModule: undefined };
+    }
+    return { resolvedModule: resolved };
+  });
+  const fileExists = host.fileExists.bind(host);
+  host.fileExists = (fileName) => fileName.endsWith(SVELTE_VIRTUAL_SUFFIX) ? fileExists(fileName.slice(0, -SVELTE_VIRTUAL_SUFFIX.length)) : fileExists(fileName);
+  host.writeFile = () => {};
+  return host;
+}
+function parseConfig(configPath, warnings, rootDir) {
+  const rel = relative2(rootDir, configPath).split("\\").join("/");
+  const read = import_typescript4.default.readConfigFile(configPath, import_typescript4.default.sys.readFile);
+  if (read.error || !read.config || typeof read.config !== "object") {
+    warnings.push(`tsconfig ${rel}: unreadable, its files fall back to the default program`);
+    return;
+  }
+  const raw = read.config;
+  const parsed = import_typescript4.default.parseJsonConfigFileContent(read.config, import_typescript4.default.sys, dirname(configPath), undefined, configPath);
+  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 };
+}
+function isUnder(file, dir) {
+  const rel = relative2(dir, file);
+  return rel !== "" && !rel.startsWith("..") && !rel.startsWith("/");
+}
+function buildPrograms(rootDir, options = {}) {
+  const root = resolve(rootDir);
+  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+  const warnings = [];
+  const walked = walkRepository(root, maxFiles, options.includeTestRunnerFiles ?? false);
+  if (walked.truncated)
+    warnings.push(`file cap reached: only the first ${maxFiles} code files are scanned`);
+  const known = new Set(walked.files);
+  const configDirs = walked.configs.map((path) => dirname(path));
+  const assigned = new Set;
+  const cache = new Map;
+  const entries = [];
+  const owner = new Map;
+  const create = (rootNames, owned, compilerOptions, configPath) => {
+    const host = sharedHost(compilerOptions, cache);
+    let program;
+    try {
+      program = import_typescript4.default.createProgram({ rootNames, options: compilerOptions, host });
+    } catch (error) {
+      warnings.push(`program ${configPath ?? "(fallback)"}: ${error.message}`);
+      return;
+    }
+    let checker;
+    const entry = {
+      program,
+      configPath,
+      owned,
+      checker: () => checker ??= program.getTypeChecker()
+    };
+    entries.push(entry);
+    for (const file of owned)
+      owner.set(file, entry);
+  };
+  const configs = [...walked.configs].sort((a, b) => b.split(/[\\/]/).length - a.split(/[\\/]/).length || a.localeCompare(b));
+  for (const configPath of configs) {
+    const parsed = parseConfig(configPath, warnings, root);
+    if (!parsed)
+      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 owned = included.filter((file) => !assigned.has(file));
+    if (owned.length === 0)
+      continue;
+    for (const file of owned)
+      assigned.add(file);
+    create(included, owned, extractorOptions(parsed.options), relative2(root, configPath).split("\\").join("/"));
+  }
+  const rest = walked.files.filter((file) => !assigned.has(file));
+  if (rest.length > 0)
+    create(rest, rest, FALLBACK_OPTIONS);
+  return { rootDir: root, entries, owner, files: assigned.size + rest.length, warnings };
+}
+
+// src/harness-extract/sinks.ts
+var import_typescript5 = __toESM(require_typescript(), 1);
+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)/;
+var AI_SDK_CALLS = new Set(["generateText", "streamText", "generateObject", "streamObject"]);
+var AI_SDK_DECIDE = new Set(["experimental_decide", "decide", "experimental_evaluate", "evaluate"]);
+var AI_SDK_AGENTS = new Set(["Agent", "Experimental_Agent", "ToolLoopAgent"]);
+var PROVIDER_MODULE = /^(?:@ai-sdk\/(?!react$|ui-utils$|rsc$|provider$|provider-utils$|svelte$|vue$|solid$|angular$|valibot$)[\w-]+|@openrouter\/ai-sdk-provider|workers-ai-provider|ollama-ai-provider(?:-v2)?|@requesty\/ai-sdk|@portkey-ai\/vercel-provider|@mistralai\/ai-sdk)$/;
+var MODEL_HOST = /^https?:\/\/(?:openrouter\.ai|api\.openai\.com|api\.anthropic\.com|generativelanguage\.googleapis\.com|api\.groq\.com|api\.together\.(?:xyz|ai)|api\.mistral\.ai|api\.deepseek\.com|api\.fireworks\.ai|api\.x\.ai|api\.perplexity\.ai|gateway\.ai\.cloudflare\.com)\//;
+var MODEL_PATH = /\/chat\/completions\b|\/v1\/messages\b|\/v1\/responses\b|:generateContent\b|:streamGenerateContent\b/;
+var FRAMEWORK_MODULE = /^(?:agents(?:\/.*)?|@cloudflare\/think|@cloudflare\/ai-chat|@cloudflare\/agents|cloudflare:workers|cloudflare:workflows)$/;
+var FRAMEWORK_BASES = new Set(["Think", "Agent", "AIChatAgent", "McpAgent", "DurableObject", "WorkflowEntrypoint", "AgentWorkflow"]);
+var HOOK_BASES = new Set(["Think", "Agent", "AIChatAgent", "McpAgent"]);
+var HOOK_METHODS = { getModel: "model", getSystemPrompt: "system", getTools: "tools" };
+var HOOK_PROPERTIES = { model: "model", systemPrompt: "system" };
+var TURN_HOOKS = new Set(["beforeTurn"]);
+var TURN_CONFIG_KEYS = { model: "model", system: "system", tools: "tools" };
+function providerName(module) {
+  if (module === "ai" || module === "@ai-sdk/gateway")
+    return "ai-gateway";
+  if (module === "@openrouter/ai-sdk-provider")
+    return "openrouter";
+  if (module === "workers-ai-provider")
+    return "workers-ai";
+  if (module.startsWith("ollama-ai-provider"))
+    return "ollama";
+  const scoped = /^@[\w-]+\/(?:ai-sdk-)?([\w-]+)$/.exec(module);
+  return scoped ? scoped[1] : module;
+}
+function requestRoles(argument, keys, ctx) {
+  if (!argument)
+    return [];
+  const object = objectLiteralOf(argument, ctx.checker);
+  const roles = [];
+  if (object && unwrap(argument) === object) {
+    for (const [key, role] of Object.entries(keys)) {
+      const value = propertyValue(object, key);
+      if (value)
+        roles.push({ role, node: value });
+      else if (!hasProperty(object, key) && object.properties.some((property) => import_typescript5.default.isSpreadAssignment(property))) {
+        roles.push({ role, node: argument, key });
+      }
+    }
+    return dedupeRoles(roles);
+  }
+  for (const [key, role] of Object.entries(keys)) {
+    if (!object || hasProperty(object, key) || object.properties.some((property) => import_typescript5.default.isSpreadAssignment(property))) {
+      roles.push({ role, node: argument, key });
+    }
+  }
+  return dedupeRoles(roles);
+}
+function dedupeRoles(roles) {
+  const seen = new Set;
+  return roles.filter((role) => {
+    if (seen.has(role.role))
+      return false;
+    seen.add(role.role);
+    return true;
+  });
+}
+function typeOrigin(type, checker) {
+  if (!type)
+    return;
+  if (import_typescript5.default.isUnionTypeNode(type) || import_typescript5.default.isIntersectionTypeNode(type)) {
+    for (const member of type.types) {
+      const origin = typeOrigin(member, checker);
+      if (origin)
+        return origin;
+    }
+    return;
+  }
+  if (import_typescript5.default.isTypeReferenceNode(type)) {
+    let name = type.typeName;
+    while (import_typescript5.default.isQualifiedName(name))
+      name = name.left;
+    return importOrigin(name, checker);
+  }
+  return;
+}
+function valueOrigin(expression, checker, depth = 0, seen = new Set) {
+  const expr = unwrap(expression);
+  if (depth > 6 || seen.has(expr))
+    return;
+  seen.add(expr);
+  if (import_typescript5.default.isNewExpression(expr) || import_typescript5.default.isCallExpression(expr)) {
+    const root = rootIdentifier(expr.expression);
+    const origin = root ? importOrigin(root, checker) : undefined;
+    if (origin)
+      return origin;
+    const fn = resolvedFunction(expr.expression, checker);
+    if (fn) {
+      const declared = typeOrigin(fn.type, checker);
+      if (declared)
+        return declared;
+      for (const ret of returnExpressions(fn)) {
+        const found = valueOrigin(ret, checker, depth + 1, seen);
+        if (found)
+          return found;
+      }
+    }
+    return;
+  }
+  let declaration;
+  if (import_typescript5.default.isIdentifier(expr)) {
+    const origin = importOrigin(expr, checker);
+    if (origin)
+      return origin;
+    declaration = valueDeclaration(resolvedSymbol(expr, checker));
+  } else if (import_typescript5.default.isPropertyAccessExpression(expr)) {
+    declaration = valueDeclaration(resolvedSymbol(expr.name, checker));
+  }
+  if (!declaration)
+    return;
+  if (import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isPropertyDeclaration(declaration) || import_typescript5.default.isParameter(declaration) || import_typescript5.default.isPropertySignature(declaration) || import_typescript5.default.isPropertyAssignment(declaration)) {
+    const declared = "type" in declaration ? typeOrigin(declaration.type, checker) : undefined;
+    if (declared)
+      return declared;
+    const initializer = "initializer" in declaration ? declaration.initializer : undefined;
+    if (initializer)
+      return valueOrigin(initializer, checker, depth + 1, seen);
+    if (import_typescript5.default.isPropertyDeclaration(declaration)) {
+      const key = propertyNameText(declaration.name);
+      let found;
+      const visit = (node) => {
+        if (found)
+          return;
+        if (import_typescript5.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript5.default.SyntaxKind.EqualsToken && import_typescript5.default.isPropertyAccessExpression(node.left) && node.left.expression.kind === import_typescript5.default.SyntaxKind.ThisKeyword && node.left.name.text === key) {
+          found = valueOrigin(node.right, checker, depth + 1, seen);
+        }
+        import_typescript5.default.forEachChild(node, visit);
+      };
+      import_typescript5.default.forEachChild(declaration.parent, visit);
+      return found;
+    }
+  }
+  return;
+}
+function providerInstance(expression, checker, depth = 0) {
+  const expr = unwrap(expression);
+  if (depth > 6)
+    return;
+  if (import_typescript5.default.isIdentifier(expr)) {
+    const origin = importOrigin(expr, checker);
+    if (origin) {
+      if (origin.module === "ai" && origin.imported === "gateway")
+        return "ai";
+      return PROVIDER_MODULE.test(origin.module) && !/^create/.test(origin.imported) && origin.imported !== "*" ? origin.module : undefined;
+    }
+    const declaration = valueDeclaration(resolvedSymbol(expr, checker));
+    if (declaration && (import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isPropertyDeclaration(declaration)) && declaration.initializer) {
+      const initializer = declaration.initializer;
+      return memoized(declaration, () => providerInstance(initializer, checker, depth + 1));
+    }
+    return;
+  }
+  if (import_typescript5.default.isPropertyAccessExpression(expr)) {
+    const declaration = valueDeclaration(resolvedSymbol(expr.name, checker));
+    if (declaration && (import_typescript5.default.isPropertyDeclaration(declaration) || import_typescript5.default.isPropertyAssignment(declaration) || import_typescript5.default.isVariableDeclaration(declaration)) && declaration.initializer) {
+      const initializer = declaration.initializer;
+      return memoized(declaration, () => providerInstance(initializer, checker, depth + 1));
+    }
+    return;
+  }
+  if (import_typescript5.default.isCallExpression(expr)) {
+    const root = rootIdentifier(expr.expression);
+    const origin = root ? importOrigin(root, checker) : undefined;
+    if (origin) {
+      if (PROVIDER_MODULE.test(origin.module) && /^create/.test(origin.imported))
+        return origin.module;
+      if (origin.module === "ai" && (origin.imported === "customProvider" || origin.imported === "createGateway"))
+        return "ai";
+      return;
+    }
+    const fn = resolvedFunction(expr.expression, checker);
+    if (fn) {
+      return memoized(fn, () => {
+        for (const ret of returnExpressions(fn)) {
+          const found = providerInstance(ret, checker, depth + 1);
+          if (found)
+            return found;
+        }
+        return;
+      });
+    }
+  }
+  return;
+}
+var providerMemo = new WeakMap;
+function memoized(node, compute) {
+  if (providerMemo.has(node))
+    return providerMemo.get(node) ?? undefined;
+  providerMemo.set(node, null);
+  const value = compute();
+  providerMemo.set(node, value ?? null);
+  return value;
+}
+var MODEL_METHOD = /model|chat|completion|responses|messages|image|embedding|speech|transcription/i;
+function providerModelCall(call, checker) {
+  const model = call.arguments[0];
+  if (!model || import_typescript5.default.isSpreadElement(model) || import_typescript5.default.isObjectLiteralExpression(unwrap(model)))
+    return;
+  const callee = unwrap(call.expression);
+  if (import_typescript5.default.isIdentifier(callee)) {
+    const module = providerInstance(callee, checker);
+    return module ? { module, model } : undefined;
+  }
+  if (import_typescript5.default.isPropertyAccessExpression(callee) && MODEL_METHOD.test(callee.name.text)) {
+    const module = providerInstance(callee.expression, checker);
+    return module ? { module, method: callee.name.text, model } : undefined;
+  }
+  return;
+}
+function chainEndsWith(chain, tail) {
+  if (!chain || chain.length <= tail.length)
+    return false;
+  return tail.every((part, index) => chain[chain.length - tail.length + index] === part);
+}
+function receiverOf(callee, tailLength) {
+  let current = unwrap(callee);
+  for (let index = 0;index < tailLength && import_typescript5.default.isPropertyAccessExpression(current); index += 1)
+    current = unwrap(current.expression);
+  return current;
+}
+var anthropicSink = {
+  id: "anthropic",
+  sdk: "anthropic",
+  match(call, ctx) {
+    if (!import_typescript5.default.isCallExpression(call))
+      return;
+    const chain = calleeChain(call.expression);
+    const tails = [["beta", "messages", "create"], ["beta", "messages", "stream"], ["messages", "create"], ["messages", "stream"]];
+    const tail = tails.find((candidate) => chainEndsWith(chain, candidate));
+    if (!tail || chain.includes("threads"))
+      return;
+    const receiver = receiverOf(call.expression, tail.length);
+    const origin = valueOrigin(receiver, ctx.checker);
+    const request = call.arguments[0];
+    if (origin && !ANTHROPIC_MODULE.test(origin.module))
+      return;
+    if (!origin) {
+      const object = objectLiteralOf(request, ctx.checker);
+      const receiverName = receiver.getText();
+      if (!object || !hasProperty(object, "model") || !hasProperty(object, "messages"))
+        return;
+      if (!/anthropic|claude|client|llm|openrouter/i.test(receiverName) && !hasProperty(object, "max_tokens"))
+        return;
+    }
+    return {
+      api: `anthropic.${tail.join(".")}`,
+      provider: "anthropic",
+      roles: requestRoles(request, { model: "model", system: "system", messages: "messages", tools: "tools" }, ctx)
+    };
+  }
+};
+var openaiSink = {
+  id: "openai",
+  sdk: "openai",
+  match(call, ctx) {
+    if (!import_typescript5.default.isCallExpression(call))
+      return;
+    const chain = calleeChain(call.expression);
+    const tails = [["chat", "completions", "create"], ["chat", "completions", "parse"], ["chat", "completions", "stream"], ["responses", "create"], ["responses", "stream"], ["responses", "parse"]];
+    const tail = tails.find((candidate) => chainEndsWith(chain, candidate));
+    if (!tail)
+      return;
+    const receiver = receiverOf(call.expression, tail.length);
+    const origin = valueOrigin(receiver, ctx.checker);
+    if (origin && !OPENAI_MODULE.test(origin.module) && !(tail[0] === "chat" && !ANTHROPIC_MODULE.test(origin.module)))
+      return;
+    const request = call.arguments[0];
+    if (!origin && tail[0] === "responses") {
+      const object = objectLiteralOf(request, ctx.checker);
+      if (!object || !hasProperty(object, "model") || !(hasProperty(object, "input") || hasProperty(object, "instructions")))
+        return;
+    }
+    return {
+      api: `openai.${tail.join(".")}`,
+      provider: !origin || OPENAI_MODULE.test(origin.module) ? "openai" : OPENAI_COMPATIBLE_MODULE.test(origin.module) ? providerName(origin.module).replace(/-sdk$|_cloud_sdk$|-ai$/, "") : providerName(origin.module),
+      roles: requestRoles(request, { model: "model", messages: "messages", input: "messages", instructions: "instructions", tools: "tools", functions: "tools" }, ctx)
+    };
+  }
+};
+var aiSdkSink = {
+  id: "ai-sdk",
+  sdk: "ai-sdk",
+  match(call, ctx) {
+    const callee = unwrap(call.expression);
+    const nameNode = import_typescript5.default.isPropertyAccessExpression(callee) ? callee.name : import_typescript5.default.isIdentifier(callee) ? callee : undefined;
+    const root = rootIdentifier(callee);
+    if (!nameNode || !root)
+      return;
+    const origin = importOrigin(root, ctx.checker);
+    if (!origin || origin.module !== "ai")
+      return;
+    const name = origin.imported === "*" ? nameNode.text : origin.imported;
+    if (!import_typescript5.default.isNewExpression(call) && AI_SDK_DECIDE.has(name)) {
+      return { api: `ai.${name}`, roles: requestRoles(call.arguments[0], { model: "model", questions: "questions", criteria: "questions" }, ctx) };
+    }
+    const known = import_typescript5.default.isNewExpression(call) ? AI_SDK_AGENTS.has(name) : AI_SDK_CALLS.has(name);
+    if (!known)
+      return;
+    return {
+      api: `ai.${name}`,
+      roles: requestRoles(call.arguments?.[0], { model: "model", system: "system", instructions: "instructions", prompt: "prompt", messages: "messages", tools: "tools" }, ctx)
+    };
+  }
+};
+var providerFactorySink = {
+  id: "provider-factory",
+  sdk: "provider-factory",
+  match(call, ctx) {
+    if (!import_typescript5.default.isCallExpression(call))
+      return;
+    const found = providerModelCall(call, ctx.checker);
+    if (!found)
+      return;
+    const provider = providerName(found.module);
+    return { api: `${provider}${found.method ? `.${found.method}` : ""}(model)`, provider, roles: [{ role: "model", node: found.model }] };
+  }
+};
+var workersAiSink = {
+  id: "workers-ai",
+  sdk: "workers-ai",
+  match(call, ctx) {
+    if (!import_typescript5.default.isCallExpression(call))
+      return;
+    const chain = calleeChain(call.expression);
+    if (!chainEndsWith(chain, ["AI", "run"]) || call.arguments.length === 0)
+      return;
+    const [model, input] = call.arguments;
+    return {
+      api: "workers-ai.AI.run",
+      provider: "workers-ai",
+      roles: [{ role: "model", node: model }, ...requestRoles(input, { messages: "messages", prompt: "prompt", tools: "tools" }, ctx)]
+    };
+  }
+};
+var REQUEST_KEYS = { model: "model", system: "system", messages: "messages", input: "messages", instructions: "instructions", prompt: "prompt", tools: "tools" };
+var OPAQUE_BODY_KEYS = { model: "model", system: "system", messages: "messages", tools: "tools" };
+var FETCH_LIKE = /fetch|request|post/i;
+var NON_MODEL_PATH = /\/models\/?(?:\?|$|`)|\/generation\b|\/credits\b|\/auth\/|\/keys?\b|\/embeddings\b|\/files\b/;
+function bodyHasModel(init, checker) {
+  const body = init ? propertyValue(init, "body") : undefined;
+  let payload = body ? unwrap(body) : undefined;
+  if (payload && import_typescript5.default.isCallExpression(payload) && payload.arguments[0])
+    payload = payload.arguments[0];
+  const object = objectLiteralOf(payload, checker);
+  return Boolean(object && hasProperty(object, "model"));
+}
+function urlTemplate(expression, checker, depth = 0) {
+  const expr = unwrap(expression);
+  if (import_typescript5.default.isTemplateExpression(expr))
+    return expr;
+  if (depth < 3 && import_typescript5.default.isIdentifier(expr)) {
+    const declaration = valueDeclaration(resolvedSymbol(expr, checker));
+    if (declaration && import_typescript5.default.isVariableDeclaration(declaration) && declaration.initializer)
+      return urlTemplate(declaration.initializer, checker, depth + 1);
+  }
+  return;
+}
+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))
+      return span.expression;
+    before = span.literal.text;
+  }
+  return;
+}
+var fetchSink = {
+  id: "fetch",
+  sdk: "fetch",
+  match(call, ctx) {
+    if (!import_typescript5.default.isCallExpression(call) || call.arguments.length < 2)
+      return;
+    const callee = unwrap(call.expression);
+    const calleeText = import_typescript5.default.isCallExpression(callee) ? callee.expression.getText() : callee.getText();
+    if (!FETCH_LIKE.test(calleeText))
+      return;
+    if (import_typescript5.default.isIdentifier(callee) && callee.text === "fetch" && resolvedFunction(callee, ctx.checker))
+      return;
+    const second = unwrap(call.arguments[1]);
+    if (import_typescript5.default.isArrowFunction(second) || import_typescript5.default.isFunctionExpression(second))
+      return;
+    const first = unwrap(call.arguments[0]);
+    if ((import_typescript5.default.isStringLiteral(first) || import_typescript5.default.isNoSubstitutionTemplateLiteral(first)) && !MODEL_HOST.test(first.text) && !MODEL_PATH.test(first.text))
+      return;
+    const urls = ctx.urlTexts(call.arguments[0]);
+    const initArg = call.arguments[1];
+    const init = objectLiteralOf(initArg, ctx.checker);
+    const url = urls.find((candidate) => !NON_MODEL_PATH.test(candidate) && (MODEL_HOST.test(candidate) || MODEL_PATH.test(candidate) && (/^https?:\/\//.test(candidate) || bodyHasModel(init, ctx.checker))));
+    if (!url)
+      return;
+    const roles = [];
+    if (init) {
+      const body = propertyValue(init, "body");
+      let payload = body ? unwrap(body) : undefined;
+      if (payload && import_typescript5.default.isCallExpression(payload) && calleeChain(payload.expression)?.join(".") === "JSON.stringify")
+        payload = payload.arguments[0];
+      if (payload)
+        roles.push(...requestRoles(payload, REQUEST_KEYS, ctx));
+    } else {
+      for (const [key, role] of Object.entries(OPAQUE_BODY_KEYS))
+        roles.push({ role, node: initArg, key: `body.${key}` });
+    }
+    const modelInUrl = urlModel(call.arguments[0], ctx.checker);
+    if (modelInUrl && !roles.some((role) => role.role === "model"))
+      roles.unshift({ role: "model", node: modelInUrl });
+    if (modelInUrl) {
+      const index = roles.findIndex((role) => role.role === "model" && role.key?.startsWith("body."));
+      if (index >= 0)
+        roles[index] = { role: "model", node: modelInUrl };
+    }
+    return {
+      api: "fetch",
+      provider: /anthropic/.test(url) ? "anthropic" : /openrouter/.test(url) ? "openrouter" : /openai/.test(url) ? "openai" : /generativelanguage/.test(url) ? "google" : undefined,
+      roles
+    };
+  }
+};
+var AGENT_ENTRY_METHODS = new Set(["run", "chat", "saveMessages", "sendMessage", "submitMessage", "prompt"]);
+var AGENT_BASES = new Set(["Think", "Agent", "AIChatAgent"]);
+var ENTRY_FIELDS = ["message", "context", "brief"];
+var STUB_GETTERS = new Set(["get", "getByName", "getAgentByName", "getServerByName", "routeAgentRequest", "getStub"]);
+function classOfDeclaration(declaration) {
+  if (!declaration)
+    return;
+  if (import_typescript5.default.isClassDeclaration(declaration) || import_typescript5.default.isClassExpression(declaration))
+    return declaration;
+  return;
+}
+function classesInType(type, checker, out = []) {
+  if (!type || out.length > 4)
+    return out;
+  if (import_typescript5.default.isTypeReferenceNode(type)) {
+    const name = import_typescript5.default.isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
+    const cls = classOfDeclaration(valueDeclaration(resolvedSymbol(name, checker)));
+    if (cls)
+      out.push(cls);
+    for (const argument of type.typeArguments ?? [])
+      classesInType(argument, checker, out);
+  } else if (import_typescript5.default.isUnionTypeNode(type) || import_typescript5.default.isIntersectionTypeNode(type)) {
+    for (const member of type.types)
+      classesInType(member, checker, out);
+  }
+  return out;
+}
+function receiverClasses(expression, checker, depth = 0) {
+  const expr = unwrap(expression);
+  if (depth > 4)
+    return [];
+  if (expr.kind === import_typescript5.default.SyntaxKind.ThisKeyword) {
+    for (let current = expr.parent;current; current = current.parent) {
+      if (import_typescript5.default.isClassDeclaration(current) || import_typescript5.default.isClassExpression(current))
+        return [current];
+    }
+    return [];
+  }
+  if (import_typescript5.default.isNewExpression(expr)) {
+    const cls = classOfDeclaration(valueDeclaration(resolvedSymbol(import_typescript5.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name : expr.expression, checker)));
+    return cls ? [cls] : [];
+  }
+  if (import_typescript5.default.isCallExpression(expr)) {
+    const callee = unwrap(expr.expression);
+    const name = import_typescript5.default.isPropertyAccessExpression(callee) ? callee.name.text : import_typescript5.default.isIdentifier(callee) ? callee.text : "";
+    if (!STUB_GETTERS.has(name))
+      return [];
+    const fromTypeArgs = (expr.typeArguments ?? []).flatMap((argument) => classesInType(argument, checker));
+    if (fromTypeArgs.length > 0)
+      return fromTypeArgs;
+    const namespace = import_typescript5.default.isPropertyAccessExpression(callee) && name !== "getAgentByName" && name !== "getServerByName" ? callee.expression : expr.arguments[0];
+    return namespace ? receiverClasses(namespace, checker, depth + 1) : [];
+  }
+  const nameNode = import_typescript5.default.isPropertyAccessExpression(expr) ? expr.name : import_typescript5.default.isIdentifier(expr) ? expr : undefined;
+  if (!nameNode)
+    return [];
+  const declaration = valueDeclaration(resolvedSymbol(nameNode, checker));
+  if (!declaration)
+    return [];
+  if (import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isParameter(declaration) || import_typescript5.default.isPropertyDeclaration(declaration) || import_typescript5.default.isPropertySignature(declaration)) {
+    const declared = classesInType(declaration.type, checker);
+    if (declared.length > 0)
+      return declared;
+    if ("initializer" in declaration && declaration.initializer)
+      return receiverClasses(declaration.initializer, checker, depth + 1);
+  }
+  return [];
+}
+function firstParamType(declaration) {
+  if (!declaration)
+    return;
+  let parameters;
+  if (import_typescript5.default.isMethodSignature(declaration) || import_typescript5.default.isMethodDeclaration(declaration))
+    parameters = declaration.parameters;
+  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;
+}
+function structuralAgent(receiver, method, ctx) {
+  let declaration;
+  try {
+    declaration = ctx.checker.getTypeAtLocation(receiver).getProperty(method)?.declarations?.[0];
+  } catch {
+    return;
+  }
+  if (!declaration)
+    return;
+  const owner = declaration.parent;
+  if (owner && (import_typescript5.default.isClassDeclaration(owner) || import_typescript5.default.isClassExpression(owner))) {
+    const base = ctx.frameworkBase(owner).base;
+    return base && AGENT_BASES.has(base) ? owner : undefined;
+  }
+  const wanted = firstParamType(declaration);
+  if (!wanted)
+    return;
+  return ctx.agentClasses().find((cls) => cls.members.some((member) => import_typescript5.default.isMethodDeclaration(member) && propertyNameText(member.name) === method && firstParamType(member) === wanted));
+}
+var agentEntrySink = {
+  id: "agent-entry",
+  sdk: "agent-entry",
+  match(call, ctx) {
+    if (!import_typescript5.default.isCallExpression(call) || call.arguments.length === 0)
+      return;
+    const callee = unwrap(call.expression);
+    if (!import_typescript5.default.isPropertyAccessExpression(callee) || !AGENT_ENTRY_METHODS.has(callee.name.text))
+      return;
+    const method = callee.name.text;
+    const cls = receiverClasses(callee.expression, ctx.checker).find((candidate) => {
+      const base = ctx.frameworkBase(candidate).base;
+      return base !== undefined && AGENT_BASES.has(base);
+    });
+    const target = cls ?? structuralAgent(callee.expression, method, ctx);
+    if (!target)
+      return;
+    const argument = call.arguments[0];
+    if (import_typescript5.default.isSpreadElement(argument))
+      return;
+    const roles = [];
+    if (method === "saveMessages") {
+      roles.push({ role: "messages", node: argument });
+    } else {
+      const object = objectLiteralOf(argument, ctx.checker);
+      const fields = object ? ENTRY_FIELDS.filter((field) => propertyValue(object, field)) : [];
+      if (object && unwrap(argument) === object && fields.length > 0) {
+        for (const field of fields)
+          roles.push({ role: "user", node: propertyValue(object, field) });
+      } else {
+        roles.push({ role: "user", node: argument });
+      }
+    }
+    return { api: `${className(target) ?? "agent"}.${method}`, roles };
+  }
+};
+var CHAT_HOOK_MODULE = /^(?:@ai-sdk\/(?:react|svelte|vue|angular|solid)|ai\/(?:react|svelte|vue)|agents\/(?:ai-)?react|@cloudflare\/(?:think|ai-chat|agents)\/react)$/;
+var CHAT_HOOKS = new Set(["useChat", "useAgentChat", "Chat", "useCompletion"]);
+var CHAT_SEND = new Set(["sendMessage", "append", "submitMessage", "complete"]);
+function fromChatHook(expression, checker, depth = 0) {
+  if (!expression || depth > 3)
+    return false;
+  const expr = unwrap(expression);
+  if (import_typescript5.default.isCallExpression(expr) || import_typescript5.default.isNewExpression(expr)) {
+    const root = rootIdentifier(expr.expression);
+    const origin = root ? importOrigin(root, checker) : undefined;
+    return Boolean(origin && CHAT_HOOK_MODULE.test(origin.module) && CHAT_HOOKS.has(origin.imported === "*" || origin.imported === "default" ? import_typescript5.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name.text : "" : origin.imported));
+  }
+  const nameNode = import_typescript5.default.isIdentifier(expr) ? expr : import_typescript5.default.isPropertyAccessExpression(expr) ? expr.name : undefined;
+  const declaration = nameNode ? valueDeclaration(resolvedSymbol(nameNode, checker)) : undefined;
+  if (!declaration)
+    return false;
+  if (import_typescript5.default.isBindingElement(declaration)) {
+    const holder = declaration.parent.parent;
+    return import_typescript5.default.isVariableDeclaration(holder) && fromChatHook(holder.initializer, checker, depth + 1);
+  }
+  if (import_typescript5.default.isVariableDeclaration(declaration))
+    return fromChatHook(declaration.initializer, checker, depth + 1);
+  return false;
+}
+function looksLikeUiMessage(argument) {
+  const object = unwrap(argument);
+  if (!import_typescript5.default.isObjectLiteralExpression(object))
+    return false;
+  const parts = propertyValue(object, "parts");
+  if (parts) {
+    const array = unwrap(parts);
+    return import_typescript5.default.isArrayLiteralExpression(array) && array.elements.some((element) => {
+      const part = unwrap(element);
+      if (!import_typescript5.default.isObjectLiteralExpression(part))
+        return false;
+      const type = propertyValue(part, "type");
+      return Boolean(type && import_typescript5.default.isStringLiteralLike(unwrap(type)) && unwrap(type).text === "text");
+    });
+  }
+  if (propertyValue(object, "text") && object.properties.length <= 3)
+    return true;
+  const role = propertyValue(object, "role");
+  return Boolean(role && import_typescript5.default.isStringLiteralLike(unwrap(role)) && unwrap(role).text === "user" && (propertyValue(object, "content") || propertyValue(object, "parts")));
+}
+var clientChatSink = {
+  id: "client-chat",
+  sdk: "client-chat",
+  match(call, ctx) {
+    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;
+    if (!name || !CHAT_SEND.has(name))
+      return;
+    const argument = call.arguments[0];
+    if (import_typescript5.default.isSpreadElement(argument))
+      return;
+    const hooked = import_typescript5.default.isIdentifier(callee) ? fromChatHook(callee, ctx.checker) : fromChatHook(callee.expression, ctx.checker);
+    if (!hooked && !((name === "sendMessage" || name === "append") && looksLikeUiMessage(argument)))
+      return;
+    return { api: `chat.${name}`, roles: [{ role: "user", node: argument }] };
+  }
+};
+function frameworkName(identifier, checker, member) {
+  if (!identifier)
+    return;
+  const origin = importOrigin(identifier, checker);
+  if (origin) {
+    const name = origin.imported === "*" || origin.imported === "default" ? member ?? identifier.text : origin.imported;
+    return FRAMEWORK_MODULE.test(origin.module) && FRAMEWORK_BASES.has(name) ? { base: name, module: origin.module } : undefined;
+  }
+  return;
+}
+function frameworkBaseOf(cls, checker, memo, depth = 0) {
+  const cached = memo.get(cls);
+  if (cached)
+    return cached;
+  const self = className(cls) ?? "(anonymous)";
+  const result = { chain: [self] };
+  memo.set(cls, result);
+  const heritage = cls.heritageClauses?.find((clause) => clause.token === import_typescript5.default.SyntaxKind.ExtendsKeyword)?.types[0];
+  if (!heritage || depth > 8)
+    return result;
+  const resolveExpression = (expression) => {
+    const expr = unwrap(expression);
+    if (import_typescript5.default.isCallExpression(expr)) {
+      for (const argument of expr.arguments) {
+        const found = resolveExpression(argument);
+        if (found?.base)
+          return found;
+      }
+      return;
+    }
+    const identifier = import_typescript5.default.isIdentifier(expr) ? expr : import_typescript5.default.isPropertyAccessExpression(expr) ? rootIdentifier(expr) : undefined;
+    const member = import_typescript5.default.isPropertyAccessExpression(expr) ? expr.name.text : undefined;
+    const direct = frameworkName(identifier, checker, member);
+    if (direct)
+      return { ...direct, chain: [direct.base] };
+    const declaration = valueDeclaration(resolvedSymbol(import_typescript5.default.isPropertyAccessExpression(expr) ? expr.name : expr, checker));
+    if (!declaration)
+      return;
+    if (import_typescript5.default.isClassDeclaration(declaration) || import_typescript5.default.isClassExpression(declaration))
+      return frameworkBaseOf(declaration, checker, memo, depth + 1);
+    const holder = import_typescript5.default.isBindingElement(declaration) ? declaration.parent.parent : declaration;
+    const name = import_typescript5.default.isBindingElement(declaration) ? propertyNameText(declaration.propertyName ?? declaration.name) : undefined;
+    if (import_typescript5.default.isVariableDeclaration(holder) && holder.initializer) {
+      const init = unwrap(holder.initializer);
+      if (import_typescript5.default.isClassExpression(init))
+        return frameworkBaseOf(init, checker, memo, depth + 1);
+      if (import_typescript5.default.isCallExpression(init)) {
+        for (const argument of init.arguments) {
+          const arg = unwrap(argument);
+          if (!import_typescript5.default.isIdentifier(arg))
+            continue;
+          const found = frameworkName(arg, checker, name);
+          if (found)
+            return { ...found, chain: [found.base] };
+          const nested = resolveExpression(arg);
+          if (nested?.base)
+            return nested;
+        }
+      }
+      if (import_typescript5.default.isIdentifier(init) || import_typescript5.default.isPropertyAccessExpression(init))
+        return resolveExpression(init);
+    }
+    return;
+  };
+  const parent = resolveExpression(heritage.expression);
+  if (parent) {
+    result.base = parent.base;
+    result.module = parent.module;
+    result.chain = [self, ...parent.chain];
+  } else {
+    result.chain = [self, heritage.expression.getText()];
+  }
+  return result;
+}
+function hookSink(memo) {
+  return {
+    id: "think-hook",
+    sdk: "think-hook",
+    match(cls, ctx) {
+      const info = frameworkBaseOf(cls, ctx.checker, memo);
+      if (!info.base || !HOOK_BASES.has(info.base))
+        return [];
+      const roles = [];
+      for (const member of cls.members) {
+        const name = propertyNameText(member.name);
+        if (!name)
+          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) });
+        } else if (import_typescript5.default.isMethodDeclaration(member) && TURN_HOOKS.has(name) && member.body) {
+          const returns = returnExpressions(member);
+          for (const [key, role] of Object.entries(TURN_CONFIG_KEYS)) {
+            if (returns.some((ret) => {
+              const value = unwrap(ret);
+              return import_typescript5.default.isObjectLiteralExpression(value) && hasProperty(value, key);
+            })) {
+              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)) {
+          roles.push({ role: HOOK_PROPERTIES[name], node: member.initializer });
+        }
+      }
+      if (roles.length === 0)
+        return [];
+      return [{ api: `${info.base === "Think" ? "think" : "agents"}.hook`, roles, anchor: cls.name ?? cls }];
+    }
+  };
+}
+function createFrameworkMemo() {
+  return new Map;
+}
+var CALL_SINKS = [anthropicSink, openaiSink, aiSdkSink, workersAiSink, fetchSink, providerFactorySink, agentEntrySink, clientChatSink];
+function registerCallSink(recognizer) {
+  CALL_SINKS.push(recognizer);
+}
+function classSinks(memo) {
+  return [hookSink(memo), ...EXTRA_CLASS_SINKS];
+}
+var EXTRA_CLASS_SINKS = [];
+function registerClassSink(recognizer) {
+  EXTRA_CLASS_SINKS.push(recognizer);
+}
+
+// src/harness-extract/types.ts
+var EXTRACT_SCHEMA_VERSION = 1;
+// src/harness-extract/enumerators/index.ts
+var ENUMERATORS = [];
+// src/harness-extract/tools.ts
+var PASS_THROUGH2 = new Set(["ref", "call", "param", "oneOf", "lookup"]);
+var DEFINITION_KEYS = new Set(["description", "input_schema", "inputSchema", "parameters", "schema", "execute", "type", "strict"]);
+function member(tree, key) {
+  const members = tree.children ?? [];
+  for (let index = members.length - 1;index >= 0; index -= 1)
+    if (members[index].key === key)
+      return members[index];
+  return;
+}
+function singleLiteral2(tree) {
+  if (!tree)
+    return;
+  if (tree.kind === "literal")
+    return tree.text;
+  if (PASS_THROUGH2.has(tree.kind)) {
+    const flow = valueChildren(tree);
+    if (flow.length === 1)
+      return singleLiteral2(flow[0]);
+  }
+  return;
+}
+function objectsOf(tree) {
+  if (tree.kind === "object")
+    return [tree];
+  if (PASS_THROUGH2.has(tree.kind))
+    return valueChildren(tree).flatMap(objectsOf);
+  return [];
+}
+function definitionName(tree) {
+  const fn = member(tree, "function");
+  const fnObject = fn ? objectsOf(fn)[0] : undefined;
+  const fnName = fnObject ? singleLiteral2(member(fnObject, "name")) : undefined;
+  if (fnName && fnObject)
+    return { name: fnName, path: fnObject.path, line: fnObject.line, via: "function.name" };
+  const nameNode = member(tree, "name");
+  const name = singleLiteral2(nameNode);
+  const keys = (tree.children ?? []).map((child) => child.key ?? "");
+  if (name && nameNode && keys.some((key) => DEFINITION_KEYS.has(key)))
+    return { name, path: nameNode.path, line: nameNode.line, via: "name" };
+  return;
+}
+function toolNamesOf(tree) {
+  const out = { names: [], unresolved: [] };
+  const visit = (node, inArray) => {
+    if (node.kind === "array") {
+      for (const child of node.children ?? [])
+        visit(child, true);
+      return;
+    }
+    if (node.kind === "object") {
+      const definition = definitionName(node);
+      if (definition) {
+        out.names.push(definition);
+        return;
+      }
+      if (inArray) {
+        out.unresolved.push({ ...node, note: "tool object without a literal name" });
+        return;
+      }
+      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" });
+      }
+      return;
+    }
+    if (PASS_THROUGH2.has(node.kind) && valueChildren(node).length > 0) {
+      for (const child of valueChildren(node))
+        visit(child, inArray);
+      return;
+    }
+    out.unresolved.push(node);
+  };
+  visit(tree, false);
+  return out;
+}
+
+// src/harness-extract/index.ts
+var PROMPT_ROLES = new Set(["system", "messages", "prompt", "instructions"]);
+var MAX_HELPER_CALLERS = 200;
+var MAX_DERIVED = 5000;
+var MAX_CALLER_CHAIN = 3;
+var cache = new Map;
+function clearExtractCache() {
+  cache.clear();
+}
+function extractHarness(rootDir, options = {}) {
+  return extractHarnessWithContext(rootDir, options).result;
+}
+function extractHarnessWithContext(rootDir, options = {}) {
+  const root = resolve2(rootDir);
+  const { fresh, ...rest } = options;
+  const key = `${root}\x00${JSON.stringify(rest)}`;
+  const cached = fresh ? undefined : cache.get(key);
+  if (cached)
+    return cached;
+  const output = runExtract(root, options);
+  cache.set(key, output);
+  return output;
+}
+function argRef(rootDir, node, key) {
+  const source = node.getSourceFile();
+  const ref = { path: relPath(rootDir, source.fileName), start: node.getStart(source), end: node.getEnd(), line: lineOf(node) };
+  if (key !== undefined)
+    ref.key = key;
+  Object.defineProperty(ref, "node", { value: node, enumerable: false });
+  return ref;
+}
+function namedEnclosingFunction(node) {
+  for (let fn = enclosingFunction(node);fn; fn = enclosingFunction(fn)) {
+    const name = functionName(fn);
+    if (name)
+      return { fn, name };
+  }
+  return;
+}
+function qualifiedName(fn, name) {
+  const cls = enclosingClass(fn);
+  const owner = cls && (fn.parent === cls || fn.parent && fn.parent.parent === cls) ? className(cls) : undefined;
+  return owner ? `${owner}.${name}` : name;
+}
+function functionScope(rootDir, fn, name) {
+  return `${relPath(rootDir, fn.getSourceFile().fileName)}#${qualifiedName(fn, name)}`;
+}
+function scopeOf(rootDir, node) {
+  const named = namedEnclosingFunction(node);
+  if (named)
+    return functionScope(rootDir, named.fn, named.name);
+  const path = relPath(rootDir, node.getSourceFile().fileName);
+  let outermost;
+  for (let fn = enclosingFunction(node);fn; fn = enclosingFunction(fn))
+    outermost = fn;
+  return outermost ? `${path}#L${lineOf(outermost)}` : path;
+}
+function callerChain(rootDir, anchor, calls, memo) {
+  const start = namedEnclosingFunction(anchor);
+  if (!start)
+    return { callers: [], callerScopes: [] };
+  const cached = memo.get(start.fn);
+  if (cached)
+    return cached;
+  const chain = { callers: [], callerScopes: [] };
+  const seen = new Set;
+  let current = start;
+  while (current && !seen.has(current.fn) && chain.callers.length <= MAX_CALLER_CHAIN) {
+    seen.add(current.fn);
+    chain.callers.unshift(qualifiedName(current.fn, current.name));
+    chain.callerScopes.unshift(functionScope(rootDir, current.fn, current.name));
+    const caller = calls.callersOf(current.fn, current.name, 1)[0];
+    current = caller ? namedEnclosingFunction(caller) : undefined;
+  }
+  memo.set(start.fn, chain);
+  return chain;
+}
+var AGENT_CLASS_BASES = new Set(["Think", "Agent", "AIChatAgent"]);
+function findAgentClasses(program, checker, memo) {
+  const out = [];
+  for (const source of program.getSourceFiles()) {
+    if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
+      continue;
+    const visit = (node) => {
+      if ((import_typescript6.default.isClassDeclaration(node) || import_typescript6.default.isClassExpression(node)) && node.heritageClauses) {
+        const base = frameworkBaseOf(node, checker, memo).base;
+        if (base && AGENT_CLASS_BASES.has(base))
+          out.push(node);
+      }
+      import_typescript6.default.forEachChild(node, visit);
+    };
+    visit(source);
+  }
+  return out;
+}
+function describeEnclosing(rootDir, anchor, checker, memo, ownClass) {
+  const fn = ownClass ? undefined : namedEnclosingFunction(anchor);
+  const cls = ownClass ?? enclosingClass(anchor);
+  let enclosingCls;
+  if (cls) {
+    const info = frameworkBaseOf(cls, checker, memo);
+    const at = cls.name ?? cls;
+    enclosingCls = { name: className(cls) ?? "(anonymous)", path: relPath(rootDir, cls.getSourceFile().fileName), line: lineOf(at), extendsChain: info.chain };
+    if (info.base)
+      enclosingCls.base = info.base;
+    if (info.module)
+      enclosingCls.baseModule = info.module;
+  }
+  const parts = [enclosingCls?.name, fn?.name].filter((part) => Boolean(part));
+  return {
+    enclosing: parts.length > 0 ? parts.join(".") : undefined,
+    enclosingClass: enclosingCls,
+    enclosingFunction: fn?.name
+  };
+}
+function siteFields(sources, rootDir) {
+  const out = { promptArgs: [] };
+  for (const source of sources) {
+    const ref = argRef(rootDir, source.arg.node, source.arg.key);
+    if (source.role === "model")
+      out.modelArg ??= ref;
+    else if (source.role === "tools")
+      out.toolsArg ??= ref;
+    else
+      out.promptArgs.push({ role: source.role, arg: ref });
+  }
+  if (!out.modelArg)
+    delete out.modelArg;
+  if (!out.toolsArg)
+    delete out.toolsArg;
+  return out;
+}
+function paramFlow(node, fn, checker, hops = 0) {
+  if (!import_typescript6.default.isExpression(node) || hops > 2)
+    return;
+  const expr = unwrap(node);
+  if (import_typescript6.default.isBinaryExpression(expr) && (expr.operatorToken.kind === import_typescript6.default.SyntaxKind.QuestionQuestionToken || expr.operatorToken.kind === import_typescript6.default.SyntaxKind.BarBarToken)) {
+    return paramFlow(expr.left, fn, checker, hops);
+  }
+  if (import_typescript6.default.isPropertyAccessExpression(expr) && import_typescript6.default.isIdentifier(unwrap(expr.expression))) {
+    const inner = paramFlow(expr.expression, fn, checker, hops);
+    return inner && inner.key === undefined ? { param: inner.param, key: expr.name.text } : undefined;
+  }
+  if (!import_typescript6.default.isIdentifier(expr))
+    return;
+  const declaration = valueDeclaration(resolvedSymbol(expr, checker));
+  if (!declaration)
+    return;
+  if (import_typescript6.default.isParameter(declaration) && declaration.parent === fn && !declaration.dotDotDotToken)
+    return { param: declaration };
+  if (import_typescript6.default.isBindingElement(declaration) && import_typescript6.default.isObjectBindingPattern(declaration.parent) && import_typescript6.default.isParameter(declaration.parent.parent) && declaration.parent.parent.parent === fn && !declaration.dotDotDotToken) {
+    const key = propertyNameText(declaration.propertyName ?? declaration.name);
+    return key ? { param: declaration.parent.parent, key } : undefined;
+  }
+  if (import_typescript6.default.isVariableDeclaration(declaration) && declaration.initializer && enclosingFunction(declaration) === fn && declaration.parent.flags & import_typescript6.default.NodeFlags.Const) {
+    return paramFlow(declaration.initializer, fn, checker, hops + 1);
+  }
+  return;
+}
+function descendArg(argument, path) {
+  let node = argument;
+  let index = 0;
+  for (;index < path.length; index += 1) {
+    let value = unwrap(node);
+    if (import_typescript6.default.isCallExpression(value) && value.expression.getText() === "JSON.stringify" && value.arguments[0])
+      value = unwrap(value.arguments[0]);
+    const next = import_typescript6.default.isObjectLiteralExpression(value) ? propertyValue(value, path[index]) : undefined;
+    if (!next)
+      break;
+    node = next;
+  }
+  return index < path.length ? { node, key: path.slice(index).join(".") } : { node };
+}
+function extendBindings(bindings, caller) {
+  if (bindings.length === 0)
+    return caller;
+  return bindings.map((binding) => ({ ...binding, outer: extendBindings(binding.outer ?? [], caller) }));
+}
+function runExtract(rootDir, options) {
+  const started = Date.now();
+  const timings = {};
+  const warnings = [];
+  const mark = (phase, since) => {
+    const now = Date.now();
+    timings[phase] = (timings[phase] ?? 0) + now - since;
+    return now;
+  };
+  let repo;
+  try {
+    repo = buildPrograms(rootDir, options);
+    warnings.push(...repo.warnings);
+  } catch (error) {
+    warnings.push(`programs: ${error.message}`);
+  }
+  let clock = mark("programs", started);
+  const sites = [];
+  const recognizerMs = {};
+  const memo = createFrameworkMemo();
+  const chainMemo = new Map;
+  const wrapperSinks = {};
+  const tracers = new Map;
+  const toolsFor = (entry) => {
+    let tools = tracers.get(entry);
+    if (!tools) {
+      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);
+    }
+    return tools;
+  };
+  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 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) {
+        const source = entry.program.getSourceFile(file);
+        if (!source)
+          continue;
+        const rel = relPath(rootDir, source.fileName);
+        const add = (anchor, sdk, api, provider, roles2, ownClass) => {
+          const sources = roles2.map((role) => ({ ...role, bindings: [], arg: { node: role.values?.length === 1 ? role.values[0] : role.node, key: role.key } }));
+          const site = {
+            id: `${rel}:${lineOf(anchor)}:${colOf(anchor)}`,
+            path: rel,
+            line: lineOf(anchor),
+            col: colOf(anchor),
+            language: "ts",
+            callee: api,
+            sdk,
+            ...provider ? { provider } : {},
+            ...siteFields(sources, rootDir),
+            ...describeEnclosing(rootDir, anchor, checker, memo, ownClass),
+            ...ownClass ? { scope: `${rel}#${className(ownClass) ?? `L${lineOf(ownClass)}`}`, callers: [className(ownClass) ?? "(anonymous)"], callerScopes: [`${rel}#${className(ownClass) ?? `L${lineOf(ownClass)}`}`] } : { scope: scopeOf(rootDir, anchor), ...callerChain(rootDir, anchor, calls, chainMemo) },
+            isTest: isTestPath(rel),
+            isEval: isEvalPath(rel)
+          };
+          sites.push({ site, entry, anchor, sources, level: 0 });
+        };
+        const visit = (node) => {
+          if (import_typescript6.default.isCallExpression(node) || import_typescript6.default.isNewExpression(node)) {
+            for (const recognizer of CALL_SINKS) {
+              let match;
+              const begin = performance.now();
+              try {
+                match = recognizer.match(node, ctx2);
+              } catch (error) {
+                warnings.push(`${rel}:${lineOf(node)} ${recognizer.id}: ${error.message}`);
+              }
+              recognizerMs[recognizer.id] = (recognizerMs[recognizer.id] ?? 0) + performance.now() - begin;
+              if (match) {
+                add(match.anchor ?? node, recognizer.sdk, match.api, match.provider, match.roles);
+                break;
+              }
+            }
+          } else if (import_typescript6.default.isClassDeclaration(node) || import_typescript6.default.isClassExpression(node)) {
+            for (const recognizer of classRecognizers) {
+              try {
+                for (const match of recognizer.match(node, ctx2))
+                  add(match.anchor ?? node, recognizer.sdk, match.api, match.provider, match.roles, node);
+              } catch (error) {
+                warnings.push(`${rel}:${lineOf(node)} ${recognizer.id}: ${error.message}`);
+              }
+            }
+          }
+          import_typescript6.default.forEachChild(node, visit);
+        };
+        visit(source);
+      }
+    } catch (error) {
+      warnings.push(`sinks ${entry.configPath ?? "(fallback)"}: ${error.message}`);
+    }
+  }
+  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 rounds = options.helperDepth ?? 8;
+  let frontier = sites.filter((entry) => entry.sources.every((source) => !source.values));
+  let derivedCount = 0;
+  for (let level = 1;level <= rounds && frontier.length > 0; level += 1) {
+    const next = [];
+    for (const inner of frontier) {
+      if (derivedCount >= MAX_DERIVED)
+        break;
+      try {
+        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));
+        if (flowing.length === 0)
+          continue;
+        const fnSource = named.fn.getSourceFile();
+        const fnId = `${relPath(rootDir, fnSource.fileName)}:${lineOf(named.fn)}:${colOf(named.fn)}`;
+        const wrapper = wrapperSinks[fnId] ??= { name: qualifiedName(named.fn, named.name), sinkId: inner.site.viaHelper ?? inner.site.id, roles: [] };
+        for (const { source, flow } of flowing) {
+          const param = flow.param.name.getText();
+          if (!wrapper.roles.some((role) => role.role === source.role && role.param === param && role.key === flow.key)) {
+            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)) {
+          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))
+            continue;
+          const callerBindings = named.fn.parameters.map((param, index) => ({ param, expr: call.arguments[index] }));
+          const sources = [];
+          for (const { source: role, flow } of flowing) {
+            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)));
+            sources.push({ ...role, bindings: extendBindings(role.bindings, callerBindings), arg });
+          }
+          if (sources.length === 0)
+            continue;
+          seenIds.add(id);
+          const site = {
+            id,
+            path: rel,
+            line: lineOf(call),
+            col: colOf(call),
+            language: "ts",
+            callee: named.name,
+            sdk: inner.site.sdk,
+            ...inner.site.provider ? { provider: inner.site.provider } : {},
+            ...siteFields(sources, rootDir),
+            viaHelper: inner.site.viaHelper ?? inner.site.id,
+            ...describeEnclosing(rootDir, call, checker, memo),
+            scope: scopeOf(rootDir, call),
+            ...callerChain(rootDir, call, calls, chainMemo),
+            isTest: isTestPath(rel),
+            isEval: isEvalPath(rel)
+          };
+          const derived = { site, entry: inner.entry, anchor: call, sources, level };
+          sites.push(derived);
+          next.push(derived);
+          derivedCount += 1;
+        }
+      } catch (error) {
+        warnings.push(`helpers ${inner.site.id}: ${error.message}`);
+      }
+    }
+    frontier = next;
+    if (level === rounds && next.length > 0)
+      warnings.push(`wrapper-sink closure stopped after ${rounds} rounds`);
+  }
+  if (derivedCount >= MAX_DERIVED)
+    warnings.push(`helper propagation stopped at ${MAX_DERIVED} derived call sites`);
+  clock = mark("helpers", clock);
+  const roles = [];
+  const tracePrompts = options.tracePrompts ?? true;
+  for (const entry of sites) {
+    const { tracer } = toolsFor(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) {
+          for (const segment of source.key.split("."))
+            tree = selectKey(tree, segment, tracer.missing(source.arg.node, `property ${source.key} not found`));
+        }
+      } catch (error) {
+        warnings.push(`trace ${entry.site.id} ${source.role}: ${error.message}`);
+        tree = tracer.missing(source.arg.node, "trace failed");
+      }
+      if (source.role === "messages") {
+        for (const split of splitMessages(tree)) {
+          roles.push({ sink: entry.site, role: split.role, tree: split.tree, resolution: split.tree.resolution, ...split.message ? { message: split.message } : {} });
+        }
+      } else {
+        roles.push({ sink: entry.site, role: source.role, tree, resolution: tree.resolution, ...source.message ? { message: source.message } : {} });
+      }
+    }
+  }
+  clock = mark("trace", clock);
+  if (options.status ?? true) {
+    try {
+      const reach = buildImportGraphReachability(rootDir);
+      for (const { site } of sites) {
+        site.status = reach.inProd.has(site.path) ? "in_prod" : reach.reachable.has(site.path) ? "reachable" : "defined_only";
+      }
+    } catch (error) {
+      warnings.push(`status: ${error.message}`);
+    }
+    mark("status", clock);
+  }
+  const result = {
+    schemaVersion: EXTRACT_SCHEMA_VERSION,
+    rootDir,
+    files: repo?.files ?? 0,
+    programs: repo?.entries.length ?? 0,
+    durationMs: Date.now() - started,
+    timings,
+    callSites: sites.map((entry) => entry.site),
+    roles,
+    toolDefinitions: [],
+    wrapperSinks,
+    warnings
+  };
+  const fileKey = (path) => {
+    const abs = resolve2(rootDir, path);
+    return /\.svelte$/i.test(abs) ? svelteVirtualName(abs) : abs;
+  };
+  const lookup = (path) => repo?.owner.get(fileKey(path));
+  const sourceFile = (path) => lookup(path)?.program.getSourceFile(fileKey(path));
+  let files;
+  const ctx = {
+    rootDir,
+    programs: repo?.entries.map((entry) => entry.program) ?? [],
+    programFor: (path) => lookup(path)?.program,
+    checkerFor: (path) => lookup(path)?.checker(),
+    sourceFiles: () => files ??= [...repo?.owner.entries() ?? []].filter(([file]) => !isTestPath(relPath(rootDir, file))).map(([file, entry]) => entry.program.getSourceFile(file)).filter((file) => Boolean(file)),
+    nodeAt: (ref) => {
+      const source = sourceFile(ref.path);
+      return source ? nodeSpanning(source, ref.start, ref.end) : undefined;
+    }
+  };
+  return { result, ctx };
+}
+function nodeSpanning(source, start, end) {
+  let best;
+  const visit = (node) => {
+    const nodeStart = node.getStart(source);
+    if (nodeStart > start || node.getEnd() < end)
+      return;
+    if (nodeStart === start && node.getEnd() === end) {
+      best = node;
+      return;
+    }
+    best = node;
+    import_typescript6.default.forEachChild(node, visit);
+  };
+  visit(source);
+  return best;
+}
+function serializeExtractResult(result) {
+  return JSON.parse(JSON.stringify(result));
+}
+function runEnumerators(enumerators, input, ctx) {
+  const out = { runtimeAgents: [], artifacts: [], relationships: [], unknowns: [], warnings: [] };
+  for (const enumerator of enumerators) {
+    try {
+      const part = enumerator.enumerate(input, ctx);
+      out.runtimeAgents.push(...part.runtimeAgents ?? []);
+      out.artifacts.push(...part.artifacts ?? []);
+      out.relationships.push(...part.relationships ?? []);
+      out.unknowns.push(...part.unknowns ?? []);
+      out.warnings.push(...part.warnings ?? []);
+    } catch (error) {
+      out.warnings.push(`enumerator ${enumerator.id}: ${error.message}`);
+    }
+  }
+  return out;
+}
+function assignAgentIds(result, agentForScope) {
+  const owners = (item) => {
+    let ids = agentForScope(item.scope);
+    for (const entry of item.callerScopes ?? []) {
+      if (ids.length > 0)
+        break;
+      ids = agentForScope(entry);
+    }
+    return [...new Set(ids)];
+  };
+  for (const site of result.callSites) {
+    const ids = owners(site);
+    if (ids.length > 0)
+      site.agentIds = ids;
+  }
+  for (const tool of result.toolDefinitions ?? []) {
+    const ids = owners(tool);
+    if (ids.length > 0)
+      tool.agentIds = ids;
+  }
+}
+export {
+  valueChildren,
+  toolNamesOf,
+  serializeExtractResult,
+  selectKey,
+  runEnumerators,
+  renderings,
+  registerClassSink,
+  registerCallSink,
+  extractHarnessWithContext,
+  extractHarness,
+  clearExtractCache,
+  assignAgentIds,
+  allValues,
+  EXTRACT_SCHEMA_VERSION,
+  ENUMERATORS,
+  CALL_SINKS
+};