@moda-ai/cli 1.55.87 → 1.55.89

package/dist/cli-xc4gq7pv.js

@@ -0,0 +1,4506 @@
+import {
+  require_typescript
+} from "./cli-gmvbapx7.js";
+import {
+  __toESM
+} from "./cli-0v6na3yp.js";
+
+// src/harness-extract/prompts/resolver.ts
+var import_typescript5 = __toESM(require_typescript(), 1);
+import { dirname, relative as relative2, resolve as resolvePath } from "node:path";
+
+// src/harness-extract/calls.ts
+var import_typescript4 = __toESM(require_typescript(), 1);
+
+// 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/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 STRING_METHODS = {
+  trim: (text) => text.trim(),
+  trimStart: (text) => text.trimStart(),
+  trimEnd: (text) => text.trimEnd(),
+  toLowerCase: (text) => text.toLowerCase(),
+  toUpperCase: (text) => text.toUpperCase()
+};
+var EMPTY_ENV = new Map;
+function envFrom(bindings) {
+  const env = new Map;
+  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;
+        const count = node.arguments[1] ? unwrap(node.arguments[1]) : undefined;
+        add({
+          op,
+          at: node,
+          target,
+          values: [...node.arguments.slice(2)],
+          index: first && import_typescript2.default.isNumericLiteral(first) ? Number(first.text) : undefined,
+          deleteCount: count && import_typescript2.default.isNumericLiteral(count) ? Number(count.text) : undefined,
+          deleteUnknown: count !== undefined && !import_typescript2.default.isNumericLiteral(count)
+        });
+      } else {
+        add({ op, at: node, target, values: [...node.arguments] });
+      }
+    }
+    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;
+  program;
+  maxDepth;
+  maxCallers;
+  maxNodes;
+  maxCallerDepth;
+  count = 0;
+  callerLevel = 0;
+  stack = new Set;
+  reassigning = new Set;
+  writes = new Map;
+  constructor(rootDir, checker, calls, options = {}, modelArgOf, program) {
+    this.rootDir = rootDir;
+    this.checker = checker;
+    this.calls = calls;
+    this.modelArgOf = modelArgOf;
+    this.program = program;
+    this.maxDepth = options.maxDepth ?? DEFAULT_TRACE_DEPTH;
+    this.maxCallers = options.maxCallers ?? DEFAULT_MAX_CALLERS;
+    this.maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
+    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, note: "number", resolution: "resolved" });
+    if (expr.kind === import_typescript2.default.SyntaxKind.TrueKeyword || expr.kind === import_typescript2.default.SyntaxKind.FalseKeyword) {
+      return this.node("literal", expr, { text: expr.getText(), note: "boolean", resolution: "resolved" });
+    }
+    if (expr.kind === import_typescript2.default.SyntaxKind.NullKeyword || import_typescript2.default.isVoidExpression(expr) || import_typescript2.default.isIdentifier(expr) && expr.text === "undefined") {
+      return this.node("external", expr, { resolution: "unresolved", note: "nullish", name: expr.kind === import_typescript2.default.SyntaxKind.NullKeyword ? "null" : "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.CommaToken) {
+      const child = this.value(expr.right, depth, env);
+      return this.node("oneOf", expr, { children: [child], resolution: child.resolution, note: "," });
+    }
+    if (operator === import_typescript2.default.SyntaxKind.AmpersandAmpersandToken) {
+      const left = this.value(expr.left, depth, env);
+      if (provenFalsy(left))
+        return left;
+      const right = this.value(expr.right, depth, env);
+      const children = provenTruthy(left) ? [right] : [{ ...left, note: "falsy left of &&" }, right];
+      return this.node("oneOf", expr, { children, resolution: rollup(children), note: "&&" });
+    }
+    return this.external(expr, `binary ${import_typescript2.default.tokenToString(operator) ?? import_typescript2.default.SyntaxKind[operator]}`);
+  }
+  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 = mutationsReaching(this.mutations(symbol, declaration), id);
+      if (mutations.some((mutation) => mutation.op !== "="))
+        return this.assembled(id, declaration, mutations, depth, env);
+      const sources = [];
+      if (declaration.initializer)
+        sources.push(this.hop(declaration.initializer, depth, env));
+      for (const mutation of mutations) {
+        if (mutation.op === "=" && !mayNotRun(mutation.at, declaration))
+          sources.length = 0;
+        sources.push(...this.reassignments(declaration, [mutation], depth, env));
+      }
+      if (sources.length === 0)
+        return this.external(id, "declared without a value", id.text);
+      const written = this.propertyWrites(symbol, declaration, id, sources, depth, env);
+      if (written)
+        return this.node("ref", id, { name: id.text, children: [written], resolution: written.resolution, note: "properties assigned" });
+      return this.node("ref", id, { name: id.text, children: sources, resolution: rollup(sources), note: sources.length > 1 ? "reassigned" : undefined });
+    }
+    if (import_typescript2.default.isEnumMember(declaration) || import_typescript2.default.isPropertyAssignment(declaration) || import_typescript2.default.isPropertyDeclaration(declaration)) {
+      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 mutationsReaching(mutations, id)) {
+        const uncertain = mayNotRun(mutation.at, declaration);
+        const traced = (value) => {
+          const element = unwrap(value);
+          if (mutation.op === "concat" && import_typescript2.default.isArrayLiteralExpression(element))
+            return element.elements.slice(0, MAX_MEMBERS).map((item) => this.element(item, depth + 1, env));
+          if (mutation.op === "concat" && !import_typescript2.default.isSpreadElement(value)) {
+            const traced2 = this.value(value, depth + 1, env);
+            const type = this.checker.getTypeAtLocation(value);
+            return [this.checker.isArrayType(type) || this.checker.isTupleType(type) ? { ...traced2, key: "..." } : traced2];
+          }
+          return [this.element(value, depth + 1, env)];
+        };
+        const values = mutation.values.slice(0, MAX_MEMBERS).flatMap(traced).map((value) => tag(uncertain ? atMostPartial(value) : value, mutation.op));
+        if (mutation.op === "=") {
+          if (uncertain)
+            items.splice(0, items.length, ...items.map(atMostPartial));
+          else
+            items.length = 0;
+          items.push(...values);
+        } else if (mutation.op === "unshift") {
+          items.unshift(...values);
+        } else if (mutation.op === "splice" && mutation.index !== undefined && !mutation.deleteUnknown && !uncertain) {
+          const start = mutation.index < 0 ? Math.max(items.length + mutation.index, 0) : Math.min(mutation.index, items.length);
+          items.splice(start, mutation.deleteCount ?? items.length, ...values);
+        } else if (mutation.op === "splice") {
+          items.splice(0, items.length, ...items.map(atMostPartial), ...values);
+        } else {
+          items.push(...values);
+        }
+      }
+    } 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
+    });
+  }
+  propertyWrites(symbol, declaration, at, sources, depth, env) {
+    const writes = this.writesOf(symbol, declaration);
+    if (writes.size === 0)
+      return;
+    const initial = sources.length === 1 ? sources[0] : this.node("oneOf", at, { children: sources, resolution: rollup(sources), note: "reassigned" });
+    const children = [{ ...initial, key: "..." }];
+    for (const [key, all] of writes) {
+      const replacements = mutationsReaching(this.mutations(symbol, declaration), at).filter((mutation) => mutation.op === "=" && !mayNotRun(mutation.at, declaration));
+      const lastReplacement = replacements.at(-1)?.at.pos ?? -1;
+      const list = all.filter((write) => mutationsReaching([{ at: write.node }], at).length > 0 && write.node.pos > lastReplacement);
+      if (list.length === 0)
+        continue;
+      const lastDirect = list.reduce((found, write, index) => write.direct ? index : found, -1);
+      const values = list.slice(Math.max(lastDirect, 0)).map((write) => this.hop(write.node.right, depth, env));
+      if (lastDirect < 0) {
+        const missing = this.node("external", at, { resolution: "unresolved", note: "nullish", name: "undefined" });
+        const before = selectKey(initial, key, missing);
+        values.unshift(before);
+      }
+      const value = values.length === 1 ? values[0] : this.node("oneOf", at, { children: values, resolution: rollup(values), note: "property assignment" });
+      children.push({ ...value, key });
+    }
+    if (children.length === 1)
+      return;
+    return this.node("object", at, { children, resolution: rollup(children), note: "properties assigned" });
+  }
+  writesOf(symbol, declaration) {
+    const cached = this.writes.get(symbol);
+    if (cached)
+      return cached;
+    const scope = enclosingScope(declaration);
+    const statement = import_typescript2.default.findAncestor(declaration, import_typescript2.default.isVariableStatement);
+    const writes = new Map;
+    let count = 0;
+    const visit = (node) => {
+      if (count >= MAX_RETURNS)
+        return;
+      if (import_typescript2.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript2.default.SyntaxKind.EqualsToken && (import_typescript2.default.isPropertyAccessExpression(node.left) || import_typescript2.default.isElementAccessExpression(node.left))) {
+        const receiver = unwrap(node.left.expression);
+        const key = import_typescript2.default.isPropertyAccessExpression(node.left) ? node.left.name.text : import_typescript2.default.isStringLiteralLike(node.left.argumentExpression) ? node.left.argumentExpression.text : undefined;
+        if (key && import_typescript2.default.isIdentifier(receiver) && receiver.text === symbol.name && resolvedSymbol(receiver, this.checker) === symbol) {
+          count += 1;
+          const holder = node.parent;
+          const direct = Boolean(statement && import_typescript2.default.isExpressionStatement(holder) && holder.parent === statement.parent && holder.pos > statement.pos);
+          const list = writes.get(key);
+          if (list)
+            list.push({ node, direct });
+          else
+            writes.set(key, [{ node, direct }]);
+        }
+      }
+      import_typescript2.default.forEachChild(node, visit);
+    };
+    visit(scope);
+    this.writes.set(symbol, writes);
+    return writes;
+  }
+  reuse(traced, at) {
+    this.count += treeSize(traced);
+    if (this.count > this.maxNodes)
+      return this.external(at, "node budget reached", undefined, "depth-limit");
+    return traced;
+  }
+  parameter(declaration, at, depth, env) {
+    const name = import_typescript2.default.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
+    const fn = declaration.parent;
+    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.reuse(bound.traced, declaration) : 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, this.program) : [];
+        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) };
+    const takesDefault = (node) => node === missing || isUndefinedValue(node);
+    if (element.initializer && hasWhere(selected, takesDefault)) {
+      const fallback = this.hop(element.initializer, depth, env);
+      selected = substituteWhere(selected, takesDefault, fallback);
+      return this.node("lookup", at, { ...extra, children: [selected], resolution: selected.resolution, note: "with default" });
+    }
+    return this.node("lookup", at, { ...extra, children: [selected], resolution: selected.resolution });
+  }
+  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);
+      const apply = Object.hasOwn(STRING_METHODS, method) ? STRING_METHODS[method] : undefined;
+      if (apply && expr.arguments.length === 0) {
+        const receiver = this.value(callee.expression, depth, env);
+        const texts = receiver.resolution === "resolved" ? renderings(receiver) : [];
+        if (texts.length > 0 && !texts.some((text) => text.includes("${...}"))) {
+          const children = [...new Set(texts.map(apply))].map((text) => this.node("literal", expr, { text, resolution: "resolved" }));
+          return children.length === 1 ? children[0] : this.node("oneOf", expr, { children, resolution: "resolved", note: method });
+        }
+        return this.node("call", expr, { name: method, children: [receiver], resolution: receiver.resolution === "resolved" ? "partial" : receiver.resolution });
+      }
+    }
+    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" });
+    const embedded = embeddedNodes(calleeTree, new Set(args));
+    const listed = args.map((arg) => embedded.has(arg) ? { ...shallow(arg), note: "bound in callee (see callee bindings)" } : arg);
+    return this.node("call", expr, { name, callee: calleeTree, args: listed, ...anchor, resolution: calleeTree.resolution });
+  }
+  reachableReturn(ret, fn, depth, env) {
+    let node = ret;
+    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);
+    let filtered = false;
+    while (import_typescript2.default.isCallExpression(receiver) && import_typescript2.default.isPropertyAccessExpression(receiver.expression) && receiver.expression.name.text === "filter" && receiver.arguments.length === 1 && import_typescript2.default.isIdentifier(receiver.arguments[0]) && receiver.arguments[0].text === "Boolean") {
+      filtered = true;
+      receiver = unwrap(receiver.expression.expression);
+    }
+    const separatorArg = expr.arguments[0];
+    const separator = separatorArg === undefined ? "," : import_typescript2.default.isStringLiteral(separatorArg) || import_typescript2.default.isNoSubstitutionTemplateLiteral(separatorArg) ? separatorArg.text : undefined;
+    let children = import_typescript2.default.isArrayLiteralExpression(receiver) ? receiver.elements.slice(0, MAX_MEMBERS).map((element) => this.element(element, depth, env)) : [{ ...this.value(receiver, depth, env), key: "..." }];
+    if (filtered) {
+      const expanded = joinElements(children);
+      if (expanded)
+        children = expanded.filter((child) => !provenFalsy(child));
+    }
+    const resolution = children.length === 0 ? "resolved" : separator === undefined && rollup(children) === "resolved" ? "partial" : rollup(children);
+    const notes = [separator === undefined ? "computed separator" : undefined, filtered ? "filter(Boolean)" : undefined].filter(Boolean);
+    return this.node("arrayJoin", expr, { text: separator, children, resolution, note: notes.length > 0 ? notes.join("; ") : undefined });
+  }
+}
+function alwaysReturns(statement) {
+  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) {
+          const mayLack = hasWhere(fromSpread, (node) => node === missing);
+          if (mayLack || fromSpread.resolution === "unresolved") {
+            const prior = selectKey({ ...tree, children: members.slice(0, index) }, key, missing);
+            if (prior !== missing && mayLack)
+              return substituteWhere(fromSpread, (node) => node === missing, prior);
+            if (prior !== missing)
+              return { ...fromSpread, kind: "oneOf", children: [prior, fromSpread], resolution: "partial", note: "unknown spread may override property" };
+          }
+          return fromSpread;
+        }
+      }
+    }
+    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 isUndefinedValue(node) {
+  return node.kind === "external" && node.note === "nullish" && node.name === "undefined";
+}
+function provenFalsy(node) {
+  if (node.kind === "literal")
+    return node.text === "" || node.note === "boolean" && node.text === "false" || node.note === "number" && /^0n?$/.test(node.text ?? "");
+  if (node.kind === "external")
+    return node.note === "nullish";
+  const flow = FLOW_KINDS.has(node.kind) ? valueChildren(node) : [];
+  return flow.length > 0 && flow.every(provenFalsy);
+}
+function provenTruthy(node) {
+  if (node.kind === "literal")
+    return !provenFalsy(node);
+  if (node.kind === "object" || node.kind === "array")
+    return true;
+  const flow = FLOW_KINDS.has(node.kind) ? valueChildren(node) : [];
+  return flow.length > 0 && flow.every(provenTruthy);
+}
+function leaves(tree) {
+  const flow = valueChildren(tree);
+  return flow.length > 0 && tree.kind !== "template" ? flow.flatMap(leaves) : [tree];
+}
+function hasWhere(tree, match) {
+  return match(tree) || FLOW_KINDS.has(tree.kind) && valueChildren(tree).some((child) => hasWhere(child, match));
+}
+function substituteWhere(tree, match, replacement) {
+  if (match(tree))
+    return tree.key !== undefined ? { ...replacement, key: tree.key } : replacement;
+  if (!hasWhere(tree, match))
+    return tree;
+  return mapFlow(tree, (child) => substituteWhere(child, match, 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 "arrayJoin": {
+      const elements = tree.text === undefined ? undefined : joinElements(tree.children ?? []);
+      if (!elements)
+        return ["${...}"];
+      const pieces = [];
+      elements.forEach((element, index) => {
+        if (index > 0)
+          pieces.push([tree.text ?? ""]);
+        pieces.push(renderings(element, limit));
+      });
+      return combine(pieces);
+    }
+    case "ref":
+    case "lookup":
+    case "param":
+    case "call":
+    case "oneOf": {
+      const out = valueChildren(tree).flatMap((child) => renderings(child, limit)).slice(0, limit);
+      return out.length > 0 ? out : ["${...}"];
+    }
+    default:
+      return ["${...}"];
+  }
+}
+function joinElements(children) {
+  const out = [];
+  for (const child of children) {
+    if (child.key !== "...") {
+      out.push(child);
+      continue;
+    }
+    let array = child;
+    while (array && array.kind !== "array") {
+      const flow = FLOW_KINDS.has(array.kind) ? valueChildren(array) : [];
+      array = flow.length === 1 ? flow[0] : undefined;
+    }
+    const inner = array ? joinElements(array.children ?? []) : undefined;
+    if (!inner)
+      return;
+    out.push(...inner);
+  }
+  return out;
+}
+function queryParamValue(tree, param) {
+  const pattern = new RegExp(`[?&]${param}=([^&#]*)`);
+  const span = { id: tree.id, path: tree.path, line: tree.line, endLine: tree.endLine, start: tree.start, end: tree.end };
+  const children = [];
+  for (const url of new Set(renderings(tree))) {
+    const value = pattern.exec(url)?.[1];
+    if (value !== undefined && value !== "" && !value.includes("${")) {
+      let text = value;
+      try {
+        text = decodeURIComponent(value);
+      } catch {}
+      if (!children.some((child) => child.text === text))
+        children.push({ ...span, kind: "literal", text, resolution: "resolved" });
+    } else {
+      children.push({ ...span, kind: "external", resolution: "unresolved", note: `query parameter ${param} not literal`, unresolvedReason: "external" });
+    }
+  }
+  if (children.length === 1)
+    return { ...children[0], key: param };
+  return { ...span, kind: "oneOf", key: param, children, resolution: rollup(children), note: "query parameter" };
+}
+function subtrees(tree) {
+  const out = [...tree.children ?? [], ...tree.bindings ?? [], ...tree.args ?? []];
+  if (tree.callee)
+    out.push(tree.callee);
+  if (tree.object)
+    out.push(tree.object);
+  if (tree.keyNode)
+    out.push(tree.keyNode);
+  return out;
+}
+var sizes = new WeakMap;
+function treeSize(tree) {
+  const cached = sizes.get(tree);
+  if (cached !== undefined)
+    return cached;
+  const size = 1 + subtrees(tree).reduce((sum, child) => sum + treeSize(child), 0);
+  sizes.set(tree, size);
+  return size;
+}
+function embeddedNodes(tree, targets) {
+  const found = new Set;
+  if (targets.size === 0)
+    return found;
+  const seen = new Set;
+  const visit = (node) => {
+    if (seen.has(node) || found.size === targets.size)
+      return;
+    seen.add(node);
+    if (targets.has(node)) {
+      found.add(node);
+      return;
+    }
+    subtrees(node).forEach(visit);
+  };
+  visit(tree);
+  return found;
+}
+function atMostPartial(node) {
+  return node.resolution === "resolved" ? { ...node, resolution: "partial" } : node;
+}
+function isLoop(node) {
+  return import_typescript2.default.isForStatement(node) || import_typescript2.default.isForOfStatement(node) || import_typescript2.default.isForInStatement(node) || import_typescript2.default.isWhileStatement(node) || import_typescript2.default.isDoStatement(node);
+}
+function mutationsReaching(mutations, read) {
+  const readFn = import_typescript2.default.findAncestor(read.parent, isFunctionLike);
+  return mutations.filter((mutation) => {
+    if (mutation.at.getSourceFile() !== read.getSourceFile() || mutation.at.pos < read.pos)
+      return true;
+    if (import_typescript2.default.findAncestor(mutation.at.parent, isFunctionLike) !== readFn)
+      return true;
+    for (let node = read.parent;node && node !== readFn; node = node.parent) {
+      if (isLoop(node) && mutation.at.pos >= node.pos && mutation.at.end <= node.end)
+        return true;
+    }
+    return false;
+  });
+}
+function mayNotRun(at, declaration) {
+  const scope = enclosingScope(declaration);
+  for (let node = at.parent;node && node !== scope; node = node.parent) {
+    if (import_typescript2.default.isIfStatement(node) || import_typescript2.default.isConditionalExpression(node) || import_typescript2.default.isSwitchStatement(node) || import_typescript2.default.isCatchClause(node) || isLoop(node) || isFunctionLike(node))
+      return true;
+    if (import_typescript2.default.isBinaryExpression(node) && (node.operatorToken.kind === import_typescript2.default.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === import_typescript2.default.SyntaxKind.BarBarToken || node.operatorToken.kind === import_typescript2.default.SyntaxKind.QuestionQuestionToken))
+      return true;
+  }
+  return false;
+}
+
+// src/harness-extract/sinks.ts
+var import_typescript3 = __toESM(require_typescript(), 1);
+var URL_MODEL_KEY = "?model";
+var ANTHROPIC_MODULE = /^@anthropic-ai\//;
+var OPENAI_MODULE = /^openai(?:\/|$)/;
+var OPENAI_COMPATIBLE_MODULE = /^(?:groq-sdk|together-ai|@cerebras\/cerebras_cloud_sdk|fireworks-ai|portkey-ai|@portkey-ai\/|@azure\/openai|deepseek|@helicone\/|cohere-ai)/;
+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 SPEECH_ENDPOINT = /^https?:\/\/api\.elevenlabs\.io\/v\d+\/(?:text-to-speech|speech-to-text|speech-to-speech|text-to-dialogue|sound-generation)\b/;
+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",
+  getTools: "tools",
+  getSystemPrompt: "system",
+  configureContext: "system",
+  getInstructions: "system",
+  instructions: "system",
+  system: "system",
+  systemPrompt: "system",
+  buildSystemPrompt: "system",
+  formatAgentToolInput: "messages"
+};
+var HOOK_PROPERTIES = { model: "model", systemPrompt: "system", instructions: "system", system: "system" };
+var TURN_HOOKS = new Set(["beforeTurn", "beforeStep", "prepareStep"]);
+var TURN_CONFIG_KEYS = { model: "model", system: "system", tools: "tools", messages: "messages" };
+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 && !spreadAfter(object, key))
+        roles.push({ role, node: value });
+      else if ((value || !hasProperty(object, key)) && object.properties.some((property) => import_typescript3.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_typescript3.default.isSpreadAssignment(property))) {
+      roles.push({ role, node: argument, key });
+    }
+  }
+  return dedupeRoles(roles);
+}
+function spreadAfter(object, key) {
+  let last = -1;
+  object.properties.forEach((property, index) => {
+    if (!import_typescript3.default.isSpreadAssignment(property) && property.name && propertyNameText(property.name) === key)
+      last = index;
+  });
+  return object.properties.some((property, index) => index > last && import_typescript3.default.isSpreadAssignment(property));
+}
+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_typescript3.default.isUnionTypeNode(type) || import_typescript3.default.isIntersectionTypeNode(type)) {
+    for (const member of type.types) {
+      const origin = typeOrigin(member, checker);
+      if (origin)
+        return origin;
+    }
+    return;
+  }
+  if (import_typescript3.default.isTypeReferenceNode(type)) {
+    let name = type.typeName;
+    while (import_typescript3.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_typescript3.default.isNewExpression(expr) || import_typescript3.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_typescript3.default.isIdentifier(expr)) {
+    const origin = importOrigin(expr, checker);
+    if (origin)
+      return origin;
+    declaration = valueDeclaration(resolvedSymbol(expr, checker));
+  } else if (import_typescript3.default.isPropertyAccessExpression(expr)) {
+    declaration = valueDeclaration(resolvedSymbol(expr.name, checker));
+  }
+  if (!declaration)
+    return;
+  if (import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.default.isParameter(declaration) || import_typescript3.default.isPropertySignature(declaration) || import_typescript3.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_typescript3.default.isPropertyDeclaration(declaration)) {
+      const key = propertyNameText(declaration.name);
+      let found;
+      const visit = (node) => {
+        if (found)
+          return;
+        if (import_typescript3.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript3.default.SyntaxKind.EqualsToken && import_typescript3.default.isPropertyAccessExpression(node.left) && node.left.expression.kind === import_typescript3.default.SyntaxKind.ThisKeyword && node.left.name.text === key) {
+          found = valueOrigin(node.right, checker, depth + 1, seen);
+        }
+        import_typescript3.default.forEachChild(node, visit);
+      };
+      import_typescript3.default.forEachChild(declaration.parent, visit);
+      return found;
+    }
+  }
+  return;
+}
+function providerInstance(expression, checker, depth = 0) {
+  const expr = unwrap(expression);
+  if (depth > 6)
+    return;
+  if (import_typescript3.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_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)) && declaration.initializer) {
+      const initializer = declaration.initializer;
+      return memoized(declaration, () => providerInstance(initializer, checker, depth + 1));
+    }
+    return;
+  }
+  if (import_typescript3.default.isPropertyAccessExpression(expr)) {
+    const declaration = valueDeclaration(resolvedSymbol(expr.name, checker));
+    if (declaration && (import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration) || import_typescript3.default.isVariableDeclaration(declaration)) && declaration.initializer) {
+      const initializer = declaration.initializer;
+      return memoized(declaration, () => providerInstance(initializer, checker, depth + 1));
+    }
+    return;
+  }
+  if (import_typescript3.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_typescript3.default.isSpreadElement(model) || import_typescript3.default.isObjectLiteralExpression(unwrap(model)))
+    return;
+  const callee = unwrap(call.expression);
+  if (import_typescript3.default.isIdentifier(callee)) {
+    const module = providerInstance(callee, checker);
+    return module ? { module, model } : undefined;
+  }
+  if (import_typescript3.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_typescript3.default.isPropertyAccessExpression(current); index += 1)
+    current = unwrap(current.expression);
+  return current;
+}
+var anthropicSink = {
+  id: "anthropic",
+  sdk: "anthropic",
+  match(call, ctx) {
+    if (!import_typescript3.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 OPENAI_MODEL_ONLY_TAILS = [["embeddings", "create"], ["audio", "speech", "create"], ["audio", "transcriptions", "create"], ["audio", "translations", "create"], ["images", "generate"], ["images", "edit"]];
+function openaiModelOnly(call, chain, ctx) {
+  const tail = OPENAI_MODEL_ONLY_TAILS.find((candidate) => chainEndsWith(chain, candidate));
+  if (!tail)
+    return;
+  const origin = valueOrigin(receiverOf(call.expression, tail.length), ctx.checker);
+  const object = objectLiteralOf(call.arguments[0], ctx.checker);
+  if (origin ? !OPENAI_MODULE.test(origin.module) : !object || !hasProperty(object, "model"))
+    return;
+  return { api: `openai.${tail.join(".")}`, provider: "openai", roles: requestRoles(call.arguments[0], { model: "model" }, ctx) };
+}
+var openaiSink = {
+  id: "openai",
+  sdk: "openai",
+  match(call, ctx) {
+    if (!import_typescript3.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 openaiModelOnly(call, chain, ctx);
+    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_typescript3.default.isPropertyAccessExpression(callee) ? callee.name : import_typescript3.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_typescript3.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_typescript3.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_typescript3.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 WORKERS_AI_MODEL = /^@(?:cf|hf)\/[\w.-]+\/[\w.:-]+$/;
+function isWorkersAiBinding(callee, checker) {
+  const target = unwrap(callee);
+  if (!import_typescript3.default.isPropertyAccessExpression(target))
+    return false;
+  const receiver = unwrap(target.expression);
+  const declaration = import_typescript3.default.isIdentifier(receiver) || import_typescript3.default.isPropertyAccessExpression(receiver) ? valueDeclaration(resolvedSymbol(import_typescript3.default.isIdentifier(receiver) ? receiver : receiver.name, checker)) : undefined;
+  const type = declaration && (import_typescript3.default.isParameter(declaration) || import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.default.isPropertySignature(declaration)) ? declaration.type : undefined;
+  return Boolean(type && import_typescript3.default.isTypeReferenceNode(type) && type.typeName.getText() === "Ai");
+}
+var workersAiSink = {
+  id: "workers-ai",
+  sdk: "workers-ai",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call))
+      return;
+    const chain = calleeChain(call.expression);
+    if (!chain || chain[chain.length - 1] !== "run" || call.arguments.length === 0)
+      return;
+    const [model, input] = call.arguments;
+    if (!chainEndsWith(chain, ["AI", "run"]) && !isWorkersAiBinding(call.expression, ctx.checker) && !ctx.urlTexts(model).some((text) => WORKERS_AI_MODEL.test(text)))
+      return;
+    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", model_id: "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_typescript3.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_typescript3.default.isTemplateExpression(expr))
+    return expr;
+  if (depth < 3 && import_typescript3.default.isIdentifier(expr)) {
+    const declaration = valueDeclaration(resolvedSymbol(expr, checker));
+    if (declaration && import_typescript3.default.isVariableDeclaration(declaration) && declaration.initializer)
+      return urlTemplate(declaration.initializer, checker, depth + 1);
+  }
+  return;
+}
+var MODEL_SOCKET = /^wss:\/\/(?:api\.openai\.com\/v1\/realtime|[\w.-]+\.openai\.azure\.com\/openai\/realtime|generativelanguage\.googleapis\.com\/ws\/[\w.]+BidiGenerateContent|gateway\.ai\.cloudflare\.com\/)/;
+function urlModel(url, checker) {
+  const template = urlTemplate(url, checker);
+  if (!template)
+    return;
+  let before = template.head.text;
+  for (const span of template.templateSpans) {
+    if (/\/models\/$/.test(before) && /^[:/?#]/.test(span.literal.text) || /[?&]model=$/.test(before) && /^(?:[&#]|$)/.test(span.literal.text))
+      return span.expression;
+    before = span.literal.text;
+  }
+  return;
+}
+var fetchSink = {
+  id: "fetch",
+  sdk: "fetch",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length < 2)
+      return;
+    const callee = unwrap(call.expression);
+    const calleeText = import_typescript3.default.isCallExpression(callee) ? callee.expression.getText() : callee.getText();
+    if (!FETCH_LIKE.test(calleeText))
+      return;
+    if (import_typescript3.default.isIdentifier(callee) && callee.text === "fetch" && resolvedFunction(callee, ctx.checker))
+      return;
+    const second = unwrap(call.arguments[1]);
+    if (import_typescript3.default.isArrowFunction(second) || import_typescript3.default.isFunctionExpression(second))
+      return;
+    const first = unwrap(call.arguments[0]);
+    if ((import_typescript3.default.isStringLiteral(first) || import_typescript3.default.isNoSubstitutionTemplateLiteral(first)) && !MODEL_HOST.test(first.text) && !MODEL_PATH.test(first.text) && !SPEECH_ENDPOINT.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) => SPEECH_ENDPOINT.test(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_typescript3.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: /elevenlabs/.test(url) ? "elevenlabs" : /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", "runTurn", "executeRun", "chat", "saveMessages", "sendMessage", "submitMessage", "prompt", "runAgentTool"]);
+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_typescript3.default.isClassDeclaration(declaration) || import_typescript3.default.isClassExpression(declaration))
+    return declaration;
+  return;
+}
+function classesInType(type, checker, out = []) {
+  if (!type || out.length > 4)
+    return out;
+  if (import_typescript3.default.isTypeReferenceNode(type)) {
+    const name = import_typescript3.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_typescript3.default.isUnionTypeNode(type) || import_typescript3.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_typescript3.default.SyntaxKind.ThisKeyword) {
+    for (let current = expr.parent;current; current = current.parent) {
+      if (import_typescript3.default.isClassDeclaration(current) || import_typescript3.default.isClassExpression(current))
+        return [current];
+    }
+    return [];
+  }
+  if (import_typescript3.default.isNewExpression(expr)) {
+    const cls = classOfDeclaration(valueDeclaration(resolvedSymbol(import_typescript3.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name : expr.expression, checker)));
+    return cls ? [cls] : [];
+  }
+  if (import_typescript3.default.isCallExpression(expr)) {
+    const callee = unwrap(expr.expression);
+    const name = import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name.text : import_typescript3.default.isIdentifier(callee) ? callee.text : "";
+    if (name === "get" && import_typescript3.default.isPropertyAccessExpression(callee) && import_typescript3.default.isPropertyAccessExpression(callee.expression) && callee.expression.name.text === "dynamicAgents" && expr.arguments[0]) {
+      const target = classOfDeclaration(valueDeclaration(resolvedSymbol(expr.arguments[0], checker)));
+      if (target)
+        return [target];
+    }
+    if (!STUB_GETTERS.has(name)) {
+      const fn = resolvedFunction(callee, checker);
+      return fn ? returnExpressions(fn).flatMap((value) => receiverClasses(value, checker, depth + 1)) : [];
+    }
+    const fromTypeArgs = (expr.typeArguments ?? []).flatMap((argument) => classesInType(argument, checker));
+    if (fromTypeArgs.length > 0)
+      return fromTypeArgs;
+    const namespace = import_typescript3.default.isPropertyAccessExpression(callee) && name !== "getAgentByName" && name !== "getServerByName" ? callee.expression : expr.arguments[0];
+    return namespace ? receiverClasses(namespace, checker, depth + 1) : [];
+  }
+  const nameNode = import_typescript3.default.isPropertyAccessExpression(expr) ? expr.name : import_typescript3.default.isIdentifier(expr) ? expr : undefined;
+  if (!nameNode)
+    return [];
+  const declaration = valueDeclaration(resolvedSymbol(nameNode, checker));
+  if (!declaration)
+    return [];
+  if (import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isParameter(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.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, checker) {
+  if (!declaration)
+    return;
+  let parameters;
+  if (import_typescript3.default.isMethodSignature(declaration) || import_typescript3.default.isMethodDeclaration(declaration))
+    parameters = declaration.parameters;
+  else if ((import_typescript3.default.isPropertySignature(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)) && declaration.type && import_typescript3.default.isFunctionTypeNode(declaration.type))
+    parameters = declaration.type.parameters;
+  const type = parameters?.[0]?.type;
+  if (!type || !import_typescript3.default.isTypeReferenceNode(type))
+    return;
+  const name = import_typescript3.default.isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
+  return valueDeclarationOrType(resolvedSymbol(name, checker));
+}
+function valueDeclarationOrType(symbol) {
+  return symbol?.declarations?.[0];
+}
+function structuralAgent(receiver, method, ctx) {
+  let declaration;
+  try {
+    declaration = ctx.checker.getTypeAtLocation(receiver).getProperty(method)?.declarations?.[0];
+  } catch {
+    return;
+  }
+  declaration ??= declaredMethod(receiver, method, ctx.checker);
+  if (!declaration)
+    return;
+  const owner = declaration.parent;
+  if (owner && (import_typescript3.default.isClassDeclaration(owner) || import_typescript3.default.isClassExpression(owner))) {
+    const base = ctx.frameworkBase(owner).base;
+    return base && AGENT_BASES.has(base) ? owner : undefined;
+  }
+  const wanted = firstParamType(declaration, ctx.checker);
+  if (!wanted)
+    return;
+  return ctx.agentClasses().find((cls) => cls.members.some((member) => import_typescript3.default.isMethodDeclaration(member) && propertyNameText(member.name) === method && firstParamType(member, ctx.checker) === wanted));
+}
+var agentEntrySink = {
+  id: "agent-entry",
+  sdk: "agent-entry",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length === 0)
+      return;
+    const callee = unwrap(call.expression);
+    if (!import_typescript3.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 seam = method === "runAgentTool" && !cls && hasMethod(callee.expression, method, ctx) ? callee.expression : undefined;
+    const target = cls ?? structuralAgent(callee.expression, method, ctx);
+    if (!target && !seam)
+      return;
+    const argument = method === "runAgentTool" ? call.arguments[1] : call.arguments[0];
+    if (!argument || import_typescript3.default.isSpreadElement(argument))
+      return;
+    const roles = [];
+    if (method === "runAgentTool") {
+      const object = objectLiteralOf(argument, ctx.checker);
+      const input = object ? propertyValue(object, "input") : undefined;
+      roles.push(input ? { role: "user", node: input } : { role: "user", node: argument, key: "input" });
+    } else if (method === "runTurn") {
+      const object = objectLiteralOf(argument, ctx.checker);
+      const input = object ? propertyValue(object, "input") : undefined;
+      roles.push(input ? { role: "messages", node: input } : { role: "messages", node: argument, key: "input" });
+    } else 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: `${(target && className(target)) ?? "agent"}.${method}`, roles };
+  }
+};
+function declaredMethod(receiver, method, checker) {
+  const root = unwrap(receiver);
+  if (!import_typescript3.default.isIdentifier(root))
+    return;
+  let annotation;
+  try {
+    const declaration = checker.getSymbolAtLocation(root)?.valueDeclaration;
+    if (declaration && (import_typescript3.default.isParameter(declaration) || import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertySignature(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)))
+      annotation = declaration.type;
+  } catch {
+    return;
+  }
+  const seen = new Set;
+  const search = (type, depth) => {
+    if (!type || depth > 4 || seen.has(type))
+      return;
+    seen.add(type);
+    if (import_typescript3.default.isIntersectionTypeNode(type) || import_typescript3.default.isUnionTypeNode(type)) {
+      for (const member of type.types) {
+        const found = search(member, depth + 1);
+        if (found)
+          return found;
+      }
+      return;
+    }
+    if (import_typescript3.default.isParenthesizedTypeNode(type))
+      return search(type.type, depth + 1);
+    const members = import_typescript3.default.isTypeLiteralNode(type) ? type.members : undefined;
+    if (members)
+      return members.find((member) => (import_typescript3.default.isMethodSignature(member) || import_typescript3.default.isPropertySignature(member)) && propertyNameText(member.name) === method);
+    if (!import_typescript3.default.isTypeReferenceNode(type))
+      return;
+    return fromName(type.typeName, depth);
+  };
+  const fromName = (name, depth) => {
+    let symbol;
+    try {
+      symbol = checker.getSymbolAtLocation(name);
+      if (symbol && symbol.flags & import_typescript3.default.SymbolFlags.Alias)
+        symbol = checker.getAliasedSymbol(symbol);
+    } catch {
+      return;
+    }
+    for (const declaration of symbol?.declarations ?? []) {
+      if (seen.has(declaration))
+        continue;
+      seen.add(declaration);
+      if (import_typescript3.default.isInterfaceDeclaration(declaration)) {
+        const own = declaration.members.find((member) => (import_typescript3.default.isMethodSignature(member) || import_typescript3.default.isPropertySignature(member)) && propertyNameText(member.name) === method);
+        if (own)
+          return own;
+        for (const clause of declaration.heritageClauses ?? []) {
+          for (const base of clause.types) {
+            const found = fromName(base.expression, depth + 1);
+            if (found)
+              return found;
+          }
+        }
+      }
+      if (import_typescript3.default.isTypeAliasDeclaration(declaration)) {
+        const found = search(declaration.type, depth + 1);
+        if (found)
+          return found;
+      }
+    }
+    return;
+  };
+  return search(annotation, 0);
+}
+function hasMethod(receiver, method, ctx) {
+  try {
+    return Boolean(ctx.checker.getTypeAtLocation(receiver).getProperty(method));
+  } catch {
+    return false;
+  }
+}
+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_typescript3.default.isCallExpression(expr) || import_typescript3.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_typescript3.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name.text : "" : origin.imported));
+  }
+  const nameNode = import_typescript3.default.isIdentifier(expr) ? expr : import_typescript3.default.isPropertyAccessExpression(expr) ? expr.name : undefined;
+  const declaration = nameNode ? valueDeclaration(resolvedSymbol(nameNode, checker)) : undefined;
+  if (!declaration)
+    return false;
+  if (import_typescript3.default.isBindingElement(declaration)) {
+    const holder = declaration.parent.parent;
+    return import_typescript3.default.isVariableDeclaration(holder) && fromChatHook(holder.initializer, checker, depth + 1);
+  }
+  if (import_typescript3.default.isVariableDeclaration(declaration))
+    return fromChatHook(declaration.initializer, checker, depth + 1);
+  return false;
+}
+function looksLikeUiMessage(argument) {
+  const object = unwrap(argument);
+  if (!import_typescript3.default.isObjectLiteralExpression(object))
+    return false;
+  const parts = propertyValue(object, "parts");
+  if (parts) {
+    const array = unwrap(parts);
+    return import_typescript3.default.isArrayLiteralExpression(array) && array.elements.some((element) => {
+      const part = unwrap(element);
+      if (!import_typescript3.default.isObjectLiteralExpression(part))
+        return false;
+      const type = propertyValue(part, "type");
+      return Boolean(type && import_typescript3.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_typescript3.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_typescript3.default.isCallExpression(call) || call.arguments.length === 0)
+      return;
+    const callee = unwrap(call.expression);
+    const binding = import_typescript3.default.isIdentifier(callee) ? valueDeclaration(resolvedSymbol(callee, ctx.checker)) : undefined;
+    const bound = binding && import_typescript3.default.isBindingElement(binding) && binding.propertyName ? propertyNameText(binding.propertyName) : undefined;
+    const name = bound ?? (import_typescript3.default.isIdentifier(callee) ? callee.text : import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name.text : undefined);
+    if (!name || !CHAT_SEND.has(name))
+      return;
+    const argument = call.arguments[0];
+    if (import_typescript3.default.isSpreadElement(argument))
+      return;
+    const hooked = import_typescript3.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 }] };
+  }
+};
+var websocketSink = {
+  id: "websocket",
+  sdk: "websocket",
+  match(call, ctx) {
+    if (!import_typescript3.default.isNewExpression(call) || !call.arguments?.length)
+      return;
+    const callee = unwrap(call.expression);
+    if (!import_typescript3.default.isIdentifier(callee) || callee.text !== "WebSocket")
+      return;
+    const url = ctx.urlTexts(call.arguments[0]).find((candidate) => MODEL_SOCKET.test(candidate));
+    if (!url)
+      return;
+    const modelInUrl = urlModel(call.arguments[0], ctx.checker);
+    const roles = modelInUrl ? [{ role: "model", node: modelInUrl }] : /[?&]model=/.test(url) ? [{ role: "model", node: call.arguments[0], key: URL_MODEL_KEY }] : [];
+    return {
+      api: "websocket",
+      provider: /openai/.test(url) ? "openai" : /generativelanguage/.test(url) ? "google" : undefined,
+      roles
+    };
+  }
+};
+function frameworkName(identifier, checker, member) {
+  if (!identifier)
+    return;
+  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_typescript3.default.SyntaxKind.ExtendsKeyword)?.types[0];
+  if (!heritage || depth > 8)
+    return result;
+  const resolveExpression = (expression) => {
+    const expr = unwrap(expression);
+    if (import_typescript3.default.isCallExpression(expr)) {
+      for (const argument of expr.arguments) {
+        const found = resolveExpression(argument);
+        if (found?.base)
+          return found;
+      }
+      return;
+    }
+    const identifier = import_typescript3.default.isIdentifier(expr) ? expr : import_typescript3.default.isPropertyAccessExpression(expr) ? rootIdentifier(expr) : undefined;
+    const member = import_typescript3.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_typescript3.default.isPropertyAccessExpression(expr) ? expr.name : expr, checker));
+    if (!declaration)
+      return;
+    if (import_typescript3.default.isClassDeclaration(declaration) || import_typescript3.default.isClassExpression(declaration))
+      return frameworkBaseOf(declaration, checker, memo, depth + 1);
+    const holder = import_typescript3.default.isBindingElement(declaration) ? declaration.parent.parent : declaration;
+    const name = import_typescript3.default.isBindingElement(declaration) ? propertyNameText(declaration.propertyName ?? declaration.name) : undefined;
+    if (import_typescript3.default.isVariableDeclaration(holder) && holder.initializer) {
+      const init = unwrap(holder.initializer);
+      if (import_typescript3.default.isClassExpression(init))
+        return frameworkBaseOf(init, checker, memo, depth + 1);
+      if (import_typescript3.default.isCallExpression(init)) {
+        for (const argument of init.arguments) {
+          const arg = unwrap(argument);
+          if (!import_typescript3.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_typescript3.default.isIdentifier(init) || import_typescript3.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 returnedField(expr, key, checker, seen = new Set, depth = 0) {
+  expr = unwrap(expr);
+  if (depth > 8 || seen.has(expr))
+    return false;
+  const next = new Set(seen).add(expr);
+  const visit = (value) => returnedField(value, key, checker, next, depth + 1);
+  if (import_typescript3.default.isObjectLiteralExpression(expr)) {
+    return hasProperty(expr, key) || expr.properties.some((property) => import_typescript3.default.isSpreadAssignment(property) && visit(property.expression));
+  }
+  if (import_typescript3.default.isConditionalExpression(expr))
+    return visit(expr.whenTrue) || visit(expr.whenFalse);
+  if (import_typescript3.default.isBinaryExpression(expr) && [import_typescript3.default.SyntaxKind.BarBarToken, import_typescript3.default.SyntaxKind.AmpersandAmpersandToken, import_typescript3.default.SyntaxKind.QuestionQuestionToken].includes(expr.operatorToken.kind)) {
+    return visit(expr.left) || visit(expr.right);
+  }
+  if (import_typescript3.default.isCallExpression(expr)) {
+    const fn = resolvedFunction(expr.expression, checker);
+    return !!fn && returnExpressions(fn).some(visit);
+  }
+  if (import_typescript3.default.isIdentifier(expr) || import_typescript3.default.isPropertyAccessExpression(expr)) {
+    const declaration = valueDeclaration(resolvedSymbol(expr, checker));
+    if (declaration && (import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration)) && declaration.initializer) {
+      return visit(declaration.initializer);
+    }
+  }
+  return false;
+}
+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 || import_typescript3.default.getCombinedModifierFlags(member) & import_typescript3.default.ModifierFlags.Static)
+          continue;
+        if ((import_typescript3.default.isMethodDeclaration(member) || import_typescript3.default.isGetAccessorDeclaration(member)) && HOOK_METHODS[name] && member.body) {
+          roles.push({ role: HOOK_METHODS[name], node: member, values: returnExpressions(member) });
+        } else if (import_typescript3.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) => returnedField(ret, key, ctx.checker))) {
+              roles.push({ role, node: member, values: returns, key });
+            }
+          }
+        } else if (import_typescript3.default.isPropertyDeclaration(member) && HOOK_PROPERTIES[name] && member.initializer) {
+          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 HOSTED_MODEL_SDKS = [
+  { module: /^@fal-ai\/(?:client|serverless-client)$/, methods: new Set(["run", "subscribe", "stream"]), provider: "fal" },
+  { module: /^replicate$/, methods: new Set(["run", "stream"]), provider: "replicate" }
+];
+var hostedModelSink = {
+  id: "hosted-model",
+  sdk: "hosted-model",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length === 0)
+      return;
+    const callee = unwrap(call.expression);
+    if (!import_typescript3.default.isPropertyAccessExpression(callee))
+      return;
+    const origin = valueOrigin(callee.expression, ctx.checker);
+    const sdk = origin && HOSTED_MODEL_SDKS.find((candidate) => candidate.module.test(origin.module) && candidate.methods.has(callee.name.text));
+    if (!sdk)
+      return;
+    const [model, options] = call.arguments;
+    const input = options ? objectLiteralOf(options, ctx.checker) : undefined;
+    const inner = input ? propertyValue(input, "input") : undefined;
+    return {
+      api: `${sdk.provider}.${callee.name.text}`,
+      provider: sdk.provider,
+      roles: [{ role: "model", node: model }, ...inner ? requestRoles(inner, { prompt: "prompt" }, ctx) : []]
+    };
+  }
+};
+var REALTIME_SEND = /send|emit|transmit|dispatch/i;
+var realtimeEventSink = {
+  id: "realtime-event",
+  sdk: "realtime",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length !== 1)
+      return;
+    const callee = import_typescript3.default.isPropertyAccessExpression(call.expression) ? call.expression.name : call.expression;
+    if (!import_typescript3.default.isIdentifier(callee) || !REALTIME_SEND.test(callee.text))
+      return;
+    let sent = unwrap(call.arguments[0]);
+    if (import_typescript3.default.isCallExpression(sent) && sent.expression.getText() === "JSON.stringify" && sent.arguments[0])
+      sent = unwrap(sent.arguments[0]);
+    const argument = objectLiteralOf(sent, ctx.checker);
+    if (!argument)
+      return;
+    const type = propertyValue(argument, "type");
+    const kind = type && (import_typescript3.default.isStringLiteral(type) || import_typescript3.default.isNoSubstitutionTemplateLiteral(type)) ? type.text : undefined;
+    if (kind === "session.update") {
+      const session = propertyValue(argument, "session");
+      const object = session ? objectLiteralOf(session, ctx.checker) : undefined;
+      const instructions = object ? propertyValue(object, "instructions") : undefined;
+      return instructions ? { api: "realtime.session.update", provider: "openai", roles: [{ role: "system", node: instructions }] } : undefined;
+    }
+    if (kind === "conversation.item.create") {
+      const item = propertyValue(argument, "item");
+      const object = item ? objectLiteralOf(item, ctx.checker) : undefined;
+      const role = object ? propertyValue(object, "role") : undefined;
+      const roleText = role && import_typescript3.default.isStringLiteral(role) ? role.text : undefined;
+      const content = object ? propertyValue(object, "content") : undefined;
+      if (!content || roleText !== "system" && roleText !== "user")
+        return;
+      return { api: "realtime.conversation.item.create", provider: "openai", roles: [{ role: roleText === "system" ? "system" : "messages", node: content }] };
+    }
+    return;
+  }
+};
+function effectiveField(object, key) {
+  let last = -1;
+  object.properties.forEach((property, index) => {
+    if (!import_typescript3.default.isSpreadAssignment(property) && propertyNameText(property.name) === key)
+      last = index;
+  });
+  const fields = [];
+  const value = last >= 0 ? propertyValue(object, key) : undefined;
+  if (value)
+    fields.push({ node: value });
+  object.properties.forEach((property, index) => {
+    if (index > last && import_typescript3.default.isSpreadAssignment(property))
+      fields.push({ node: property.expression, key });
+  });
+  return fields;
+}
+var WRITTEN_SYMBOLS = new WeakMap;
+function writtenSymbols(file, checker) {
+  let written = WRITTEN_SYMBOLS.get(file);
+  if (written)
+    return written;
+  const found = new Set;
+  const add = (node) => {
+    const root = rootIdentifier(node);
+    const symbol = root ? resolvedSymbol(root, checker) : undefined;
+    if (symbol)
+      found.add(symbol);
+  };
+  const visit = (node) => {
+    if (import_typescript3.default.isBinaryExpression(node) && node.operatorToken.kind >= import_typescript3.default.SyntaxKind.FirstAssignment && node.operatorToken.kind <= import_typescript3.default.SyntaxKind.LastAssignment)
+      add(node.left);
+    else if (import_typescript3.default.isDeleteExpression(node))
+      add(node.expression);
+    else if ((import_typescript3.default.isPrefixUnaryExpression(node) || import_typescript3.default.isPostfixUnaryExpression(node)) && (node.operator === import_typescript3.default.SyntaxKind.PlusPlusToken || node.operator === import_typescript3.default.SyntaxKind.MinusMinusToken))
+      add(node.operand);
+    else if (import_typescript3.default.isCallExpression(node) && node.arguments.length > 0) {
+      const callee = unwrap(node.expression);
+      if (import_typescript3.default.isPropertyAccessExpression(callee) && callee.name.text === "assign")
+        add(node.arguments[0]);
+    }
+    import_typescript3.default.forEachChild(node, visit);
+  };
+  visit(file);
+  written = found;
+  WRITTEN_SYMBOLS.set(file, written);
+  return written;
+}
+function gatewayRequestLiteral(argument, checker) {
+  const value = unwrap(argument);
+  if (import_typescript3.default.isObjectLiteralExpression(value))
+    return value;
+  if (!import_typescript3.default.isIdentifier(value))
+    return;
+  const symbol = resolvedSymbol(value, checker);
+  const declaration = valueDeclaration(symbol);
+  if (!symbol || !declaration || !import_typescript3.default.isVariableDeclaration(declaration) || !declaration.initializer)
+    return;
+  if (!(import_typescript3.default.getCombinedNodeFlags(declaration) & import_typescript3.default.NodeFlags.Const))
+    return;
+  const literal = unwrap(declaration.initializer);
+  if (!import_typescript3.default.isObjectLiteralExpression(literal))
+    return;
+  return writtenSymbols(declaration.getSourceFile(), checker).has(symbol) ? undefined : literal;
+}
+var GATEWAY_METHODS = new Set(["call", "stream"]);
+var GATEWAY_BODY_KEYS = { system: "system", messages: "messages", prompt: "prompt", model: "model", tools: "tools" };
+var modelGatewaySink = {
+  id: "model-gateway",
+  sdk: "model-gateway",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length !== 1)
+      return;
+    const callee = unwrap(call.expression);
+    if (!import_typescript3.default.isPropertyAccessExpression(callee) || !GATEWAY_METHODS.has(callee.name.text))
+      return;
+    const receiver = unwrap(callee.expression);
+    if (!import_typescript3.default.isPropertyAccessExpression(receiver) || receiver.name.text !== "models")
+      return;
+    const request = gatewayRequestLiteral(call.arguments[0], ctx.checker);
+    if (!request || !propertyValue(request, "kind"))
+      return;
+    const roles = [];
+    for (const body of effectiveField(request, "body")) {
+      for (const [key, role] of Object.entries(GATEWAY_BODY_KEYS)) {
+        if (body.key) {
+          roles.push({ role, node: body.node, key: `${body.key}.${key}` });
+          continue;
+        }
+        const literal = unwrap(body.node);
+        if (!import_typescript3.default.isObjectLiteralExpression(literal)) {
+          roles.push({ role, node: body.node, key });
+          continue;
+        }
+        for (const field of effectiveField(literal, key))
+          roles.push({ role, ...field });
+      }
+    }
+    for (const field of effectiveField(request, "prompt"))
+      roles.push({ role: "prompt", ...field });
+    return roles.length > 0 ? { api: `models.${callee.name.text}`, roles } : undefined;
+  }
+};
+var CALL_SINKS = [modelGatewaySink, realtimeEventSink, anthropicSink, openaiSink, aiSdkSink, workersAiSink, fetchSink, websocketSink, providerFactorySink, agentEntrySink, clientChatSink, hostedModelSink];
+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/calls.ts
+class CallIndex {
+  program;
+  checker;
+  byName;
+  aliases = new Map;
+  members = new Map;
+  checkingDefaults = new Set;
+  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 imported = importAliases(source);
+      const visit = (node) => {
+        if ((import_typescript4.default.isParameter(node) || import_typescript4.default.isVariableDeclaration(node)) && node.initializer && import_typescript4.default.isIdentifier(node.name)) {
+          let init = unwrap(node.initializer);
+          if (import_typescript4.default.isBinaryExpression(init) && (init.operatorToken.kind === import_typescript4.default.SyntaxKind.QuestionQuestionToken || init.operatorToken.kind === import_typescript4.default.SyntaxKind.BarBarToken))
+            init = unwrap(init.right);
+          if (import_typescript4.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_typescript4.default.isPropertyAssignment(node) || import_typescript4.default.isShorthandPropertyAssignment(node)) && import_typescript4.default.isObjectLiteralExpression(node.parent)) {
+          const value = import_typescript4.default.isShorthandPropertyAssignment(node) ? node.name : unwrap(node.initializer);
+          const property = import_typescript4.default.isIdentifier(node.name) || import_typescript4.default.isStringLiteral(node.name) ? node.name.text : undefined;
+          if (property && import_typescript4.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_typescript4.default.isCallExpression(node)) {
+          const callee = unwrap(node.expression);
+          const name = import_typescript4.default.isIdentifier(callee) ? callee.text : import_typescript4.default.isPropertyAccessExpression(callee) ? callee.name.text : undefined;
+          if (name) {
+            const original = import_typescript4.default.isIdentifier(callee) ? imported.get(name) : undefined;
+            for (const key of original && original !== name ? [name, original] : [name]) {
+              const list = byName.get(key);
+              if (list)
+                list.push(node);
+              else
+                byName.set(key, [node]);
+            }
+          }
+        }
+        import_typescript4.default.forEachChild(node, visit);
+      };
+      visit(source);
+    }
+    return byName;
+  }
+  callersOf(fn, name, limit, within) {
+    const all = this.allCallersOf(fn, name, within ? Number.MAX_SAFE_INTEGER : limit);
+    if (!within)
+      return all;
+    return all.filter((call) => within.getSourceFile(call.getSourceFile().fileName) === call.getSourceFile()).slice(0, limit);
+  }
+  allCallersOf(fn, name, limit) {
+    this.byName ??= this.build();
+    const signatures = contextualSignatures(fn, name, this.checker);
+    const out = this.direct(name, limit, (declaration, call) => declares(declaration, fn) || signatures.has(declaration) && contextualReceiverMatches(call, fn, this.checker));
+    if (isDefaultExport(fn) && name !== "default" && out.length < limit)
+      out.push(...this.direct("default", limit - out.length, (declaration) => declares(declaration, fn), new Set(out)));
+    for (const alias of this.aliases.get(name) ?? []) {
+      if (out.length >= limit)
+        break;
+      const symbol = resolvedSymbol(alias.target, this.checker);
+      if (!symbol?.declarations?.some((declaration) => declares(declaration, fn)))
+        continue;
+      if (!this.defaultCanApply(alias.declaration))
+        continue;
+      const aliasName = alias.declaration.name.text;
+      out.push(...this.direct(aliasName, limit - out.length, (declaration) => declaration === alias.declaration));
+    }
+    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_typescript4.default.isParenthesizedExpression(node.parent) || import_typescript4.default.isAsExpression(node.parent) || import_typescript4.default.isSatisfiesExpression(node.parent)))
+      node = node.parent;
+    const parent = node.parent;
+    const out = [];
+    if (parent && import_typescript4.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_typescript4.default.isParameter(parent) && parent.initializer === node) {
+      out.push(parent);
+    } else if (parent && import_typescript4.default.isVariableDeclaration(parent) && parent.initializer === node && import_typescript4.default.isIdentifier(parent.name)) {
+      for (const alias of this.aliases.get(parent.name.text) ?? []) {
+        if (import_typescript4.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_typescript4.default.isPropertyAccessExpression(callee)) {
+        const receiver = unwrap(callee.expression);
+        if (import_typescript4.default.isIdentifier(receiver) && valueDeclaration(resolvedSymbol(receiver, this.checker)) === param)
+          out.push(call);
+      } else if (import_typescript4.default.isIdentifier(callee)) {
+        const declaration = valueDeclaration(resolvedSymbol(callee, this.checker));
+        if (!declaration || !import_typescript4.default.isBindingElement(declaration))
+          continue;
+        const holder = declaration.parent.parent;
+        const init = import_typescript4.default.isVariableDeclaration(holder) && holder.initializer ? unwrap(holder.initializer) : undefined;
+        if (holder === param || init && import_typescript4.default.isIdentifier(init) && valueDeclaration(resolvedSymbol(init, this.checker)) === param)
+          out.push(call);
+      }
+    }
+    return out;
+  }
+  defaultCanApply(declaration) {
+    if (!import_typescript4.default.isParameter(declaration) || this.checkingDefaults.has(declaration))
+      return true;
+    const init = declaration.initializer ? unwrap(declaration.initializer) : undefined;
+    if (!init || !import_typescript4.default.isIdentifier(init))
+      return true;
+    const fn = declaration.parent;
+    const name = isFunctionLike(fn) ? functionName(fn) : undefined;
+    if (!name || !isFunctionLike(fn))
+      return true;
+    const index = fn.parameters.indexOf(declaration);
+    this.checkingDefaults.add(declaration);
+    try {
+      const callers = this.callersOf(fn, name, 20);
+      if (callers.length === 0 || callers.length >= 20)
+        return true;
+      return callers.some((call) => {
+        if (call.arguments.slice(0, index + 1).some((argument2) => import_typescript4.default.isSpreadElement(argument2)))
+          return true;
+        const argument = call.arguments[index];
+        if (!argument)
+          return true;
+        const inner = unwrap(argument);
+        if (import_typescript4.default.isIdentifier(inner) && inner.text === "undefined" || import_typescript4.default.isVoidExpression(inner))
+          return true;
+        const passed = import_typescript4.default.isIdentifier(inner) ? valueDeclaration(resolvedSymbol(inner, this.checker)) : undefined;
+        if (passed && declaration.initializer && declares(passed, resolvedFunction(declaration.initializer, this.checker) ?? fn))
+          return true;
+        return !definitelyDefined(inner, this.checker);
+      });
+    } finally {
+      this.checkingDefaults.delete(declaration);
+    }
+  }
+  direct(name, limit, matches, found) {
+    const candidates = this.byName.get(name) ?? [];
+    const out = [];
+    let checked = 0;
+    for (const call of candidates) {
+      if (found?.has(call))
+        continue;
+      if (out.length >= limit || checked >= limit * 20)
+        break;
+      checked += 1;
+      const callee = unwrap(call.expression);
+      const nameNode = import_typescript4.default.isPropertyAccessExpression(callee) ? callee.name : callee;
+      const symbol = resolvedSymbol(nameNode, this.checker);
+      const members = import_typescript4.default.isPropertyAccessExpression(callee) ? receiverClasses(callee.expression, this.checker).flatMap((cls) => cls.members.filter((member) => member.name?.getText() === name)) : [];
+      if (symbol?.declarations?.some((declaration) => matches(declaration, call)) || members.some((declaration) => matches(declaration, call)))
+        out.push(call);
+    }
+    return out;
+  }
+}
+
+class RepoCallIndex {
+  entries;
+  indexes = new Map;
+  owned = new Map;
+  constructor(entries) {
+    this.entries = entries;
+  }
+  indexFor(entry) {
+    let index = this.indexes.get(entry);
+    if (!index) {
+      index = new CallIndex(entry.program, entry.checker());
+      this.indexes.set(entry, index);
+    }
+    return index;
+  }
+  indexedCallersOf(fn, name, limit, within) {
+    const out = [];
+    const seen = new Set;
+    const fnFile = fn.getSourceFile().fileName;
+    for (const entry of this.entries) {
+      if (out.length >= limit)
+        break;
+      if (!entry.program.getSourceFile(fnFile))
+        continue;
+      let owned = this.owned.get(entry);
+      if (!owned) {
+        owned = new Set(entry.owned);
+        this.owned.set(entry, owned);
+      }
+      for (const call of this.indexFor(entry).callersOf(fn, name, Number.MAX_SAFE_INTEGER)) {
+        const source = call.getSourceFile();
+        if (!owned.has(source.fileName))
+          continue;
+        const key = `${source.fileName}:${call.pos}`;
+        if (seen.has(key))
+          continue;
+        if (within && within.getSourceFile(source.fileName) !== source)
+          continue;
+        seen.add(key);
+        out.push({ call, entry });
+        if (out.length >= limit)
+          break;
+      }
+    }
+    return out;
+  }
+  callersOf(fn, name, limit, within) {
+    const own = within ? this.entries.find((entry) => entry.program === within) : undefined;
+    if (own)
+      return this.indexFor(own).callersOf(fn, name, limit);
+    return this.indexedCallersOf(fn, name, limit, within).map((indexed) => indexed.call);
+  }
+}
+function importAliases(source) {
+  const aliases = new Map;
+  for (const statement of source.statements) {
+    const clause = import_typescript4.default.isImportDeclaration(statement) ? statement.importClause : undefined;
+    if (!clause || clause.isTypeOnly)
+      continue;
+    if (clause.name)
+      aliases.set(clause.name.text, "default");
+    if (clause.namedBindings && import_typescript4.default.isNamedImports(clause.namedBindings)) {
+      for (const element of clause.namedBindings.elements) {
+        if (element.propertyName)
+          aliases.set(element.name.text, element.propertyName.text);
+      }
+    }
+  }
+  return aliases;
+}
+function isDefaultExport(fn) {
+  const holder = import_typescript4.default.isVariableDeclaration(fn.parent) ? fn.parent : fn;
+  if (import_typescript4.default.canHaveModifiers(holder) && import_typescript4.default.getModifiers(holder)?.some((modifier) => modifier.kind === import_typescript4.default.SyntaxKind.DefaultKeyword))
+    return true;
+  if (import_typescript4.default.isExportAssignment(fn.parent))
+    return true;
+  const name = functionName(fn);
+  return Boolean(name && fn.getSourceFile().statements.some((statement) => import_typescript4.default.isExportAssignment(statement) && !statement.isExportEquals && import_typescript4.default.isIdentifier(statement.expression) && statement.expression.text === name));
+}
+function sameNode(a, b) {
+  return a === b || a.kind === b.kind && a.pos === b.pos && a.end === b.end && a.getSourceFile().fileName === b.getSourceFile().fileName;
+}
+function declares(declaration, fn) {
+  if (sameNode(declaration, fn))
+    return true;
+  if ((import_typescript4.default.isVariableDeclaration(declaration) || import_typescript4.default.isPropertyAssignment(declaration) || import_typescript4.default.isPropertyDeclaration(declaration)) && declaration.initializer && sameNode(unwrap(declaration.initializer), fn))
+    return true;
+  if (import_typescript4.default.isExportAssignment(declaration) && sameNode(unwrap(declaration.expression), fn))
+    return true;
+  return false;
+}
+function definitelyDefined(expression, checker, seen = new Set) {
+  const node = unwrap(expression);
+  if (seen.has(node))
+    return false;
+  seen.add(node);
+  if (import_typescript4.default.isStringLiteralLike(node) || import_typescript4.default.isNumericLiteral(node) || import_typescript4.default.isObjectLiteralExpression(node) || import_typescript4.default.isArrayLiteralExpression(node) || import_typescript4.default.isArrowFunction(node) || import_typescript4.default.isFunctionExpression(node) || node.kind === import_typescript4.default.SyntaxKind.NullKeyword || node.kind === import_typescript4.default.SyntaxKind.TrueKeyword || node.kind === import_typescript4.default.SyntaxKind.FalseKeyword)
+    return true;
+  if (import_typescript4.default.isIdentifier(node)) {
+    const declaration = valueDeclaration(resolvedSymbol(node, checker));
+    if (declaration && (import_typescript4.default.isFunctionDeclaration(declaration) || import_typescript4.default.isClassDeclaration(declaration)))
+      return true;
+    if (declaration && import_typescript4.default.isVariableDeclaration(declaration) && declaration.initializer && import_typescript4.default.getCombinedNodeFlags(declaration) & import_typescript4.default.NodeFlags.Const)
+      return definitelyDefined(declaration.initializer, checker, seen);
+  }
+  return false;
+}
+function contextualSignatures(fn, name, checker) {
+  const member = import_typescript4.default.isArrowFunction(fn) || import_typescript4.default.isFunctionExpression(fn) ? fn.parent : fn;
+  if (!(import_typescript4.default.isMethodDeclaration(member) || import_typescript4.default.isPropertyAssignment(member)) || !import_typescript4.default.isObjectLiteralExpression(member.parent))
+    return new Set;
+  const property = checker.getContextualType(member.parent)?.getProperty(name);
+  return new Set((property?.declarations ?? []).filter((declaration) => import_typescript4.default.isMethodSignature(declaration) || import_typescript4.default.isPropertySignature(declaration)));
+}
+function contextualReceiverMatches(call, fn, checker) {
+  const member = import_typescript4.default.isArrowFunction(fn) || import_typescript4.default.isFunctionExpression(fn) ? fn.parent : fn;
+  const callee = unwrap(call.expression);
+  if (!import_typescript4.default.isPropertyAccessExpression(callee))
+    return true;
+  const seen = new Set;
+  const objectOf = (expression) => {
+    const node = unwrap(expression);
+    if (seen.has(node))
+      return;
+    seen.add(node);
+    if (import_typescript4.default.isObjectLiteralExpression(node))
+      return node;
+    const declaration = valueDeclaration(resolvedSymbol(import_typescript4.default.isPropertyAccessExpression(node) ? node.name : node, checker));
+    if (declaration && (import_typescript4.default.isVariableDeclaration(declaration) || import_typescript4.default.isPropertyAssignment(declaration)) && declaration.initializer)
+      return objectOf(declaration.initializer);
+    return;
+  };
+  const object = objectOf(callee.expression);
+  if (!object || object === member.parent)
+    return true;
+  const origin = (literal, visited = new Set) => {
+    if (visited.has(literal))
+      return;
+    const next = new Set(visited).add(literal);
+    for (const property of [...literal.properties].reverse()) {
+      if (import_typescript4.default.isSpreadAssignment(property)) {
+        const spread = objectOf(property.expression);
+        if (!spread)
+          return;
+        const inherited = origin(spread, next);
+        if (inherited !== null)
+          return inherited;
+      } else if (property.name?.getText().replace(/^['"]|['"]$/g, "") === callee.name.text) {
+        return property;
+      }
+    }
+    return null;
+  };
+  const implementation = origin(object);
+  return implementation === undefined || implementation === member;
+}
+
+// src/harness-extract/prompts/resolver.ts
+var DEFAULT_MAX_DEPTH = 24;
+var DEFAULT_MAX_PARAM_LEVELS = 8;
+var PROMPT_FIELDS = new Set([
+  "content",
+  "parts",
+  "text",
+  "system",
+  "prompt",
+  "instructions",
+  "instruction",
+  "systemPrompt",
+  "system_prompt",
+  "systemMessage",
+  "system_message",
+  "systemInstruction",
+  "system_instruction",
+  "messages",
+  "user",
+  "question",
+  "questions",
+  "task",
+  "brief",
+  "criteria",
+  "rubric",
+  "template",
+  "backstory",
+  "goal",
+  "provider",
+  "get",
+  "render"
+]);
+var PROMPT_FIELD_NAME = /(?:prompt|instructions?|system|brief|intent|task|questions?|directive|guidance|rules?|context|section|block|persona|role|criteria|rubric|template|content|text|preamble|framing|nudge|reminder|policy)$/i;
+var TEXT_PRESERVING_METHODS = new Set([
+  "trim",
+  "trimStart",
+  "trimEnd",
+  "replace",
+  "replaceAll",
+  "concat",
+  "slice",
+  "toString",
+  "normalize",
+  "padEnd",
+  "padStart"
+]);
+var ARRAY_ASSEMBLY_METHODS = new Set(["join", "concat", "flat", "filter", "slice", "reverse", "sort", "toSorted"]);
+var CALLBACK_METHODS = new Set(["map", "flatMap", "then", "catch"]);
+var ARRAY_ELEMENT = "<array-element>";
+var FLATMAP_ELEMENT = "<flatmap-element>";
+var TEST_SOURCE = /(?:^|\/)(?:__tests__|__mocks__|fixtures?|test-fixtures)\/|(?:^|\/)[^/]*\.(?:test|spec)\.[^/]+$/i;
+var TEXT_MODULE = /\.(?:md|mdx|txt|prompt)(?:\?raw)?$/;
+var LOCAL_ONLY_SITE = /^(?:scripts|evals?)\//;
+function readsAsInstructions(text) {
+  const plain = text.replace(/\{\{[^}]*\}\}/g, " x ");
+  if (/^\s*(?:SELECT|WITH|INSERT|UPDATE|DELETE|CREATE|ALTER)\b/i.test(plain))
+    return false;
+  if (/^\s*(?:https?:\/\/|\/[\w-]+\/)\S*\s*$/.test(plain))
+    return false;
+  if (/^[\s\w,.()'"=]+$/.test(plain) && (plain.match(/,/g) ?? []).length >= 3 && !/[.!?:]\s/.test(plain))
+    return false;
+  if ((plain.match(/[{};=]/g) ?? []).length > plain.length / 25)
+    return false;
+  const words = plain.match(/[A-Za-z]{2,}/g) ?? [];
+  return words.length >= 6 && /\s/.test(plain.trim());
+}
+function isDataWrapper(text) {
+  const lines = text.split(`
+`).map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0)
+    return true;
+  return lines.every((line) => (stripMarkup(line).match(/[A-Za-z]{2,}/g) ?? []).length < 4);
+}
+function stripMarkup(line) {
+  const phrase = (value) => (value.match(/[A-Za-z]{2,}/g) ?? []).length >= 4 ? ` ${value} ` : " ";
+  return line.replace(/\{\{[^}]*\}\}/g, " ").replace(/<\/?[\w-]+((?:\s+[\w-]+(?:="[^"]*")?)*)\s*\/?>/g, (_, attrs) => attrs.replace(/[\w-]+="([^"]*)"|[\w-]+/g, (_name, value) => value === undefined ? " " : phrase(value))).replace(/<\/?[\w-]+|\/?>/g, " ");
+}
+var SHORT_TEXT = 300;
+var DIRECTIVE_ANYWHERE = /\b(?:you(?! were)|must|should|do not|don't|never|always|only|avoid|make sure|ensure|instead)\b/i;
+var DIRECTIVE_VERB = /(?:^|[.!?:;\n]\s*|\]\s*)(?:keep|write|reply|respond|return|answer|use|include|output|list|describe|summari[sz]e|explain|decide|pick|choose|rate|score|classify|label|extract|generate|draft|revise|rewrite|translate|tell|ask|call|check|verify|follow|format|limit|stop|continue|focus|consider|act|identify|compare|judge|review|repair|fix|plan|propose|suggest|recommend|find|search|read|treat|cite|flag|mark|rank|group|merge|drop|skip|wait|confirm)\b/i;
+function hasDirective(text) {
+  const plain = text.replace(/\{\{[^}]*\}\}/g, " ").trim();
+  return DIRECTIVE_ANYWHERE.test(plain) || DIRECTIVE_VERB.test(plain);
+}
+var ERROR_TEXT = /^\s*(?:error\b|failed\b|could not\b|couldn't\b|cannot\b|can't\b|unable to\b|invalid\b|unknown\b|missing\b|not found\b)/i;
+function toolResultIsPrompt(owner, pieces) {
+  if (!owner)
+    return false;
+  if (import_typescript5.default.isShorthandPropertyAssignment(owner) || import_typescript5.default.isPropertyAssignment(owner) && !isNamedTableEntry(owner))
+    return false;
+  const own = pieces.map((piece) => piece.trim()).filter(Boolean);
+  if (own.length === 0)
+    return false;
+  const text = withoutLabels(own.join(`
+`)).replace(/(^|[.!?;\n]\s*)[A-Za-z][\w-]*\s+(?:(?:was|were|is|are|has been|have been)\s+)?(?:saved|cleared|completed|created|updated|deleted|removed|scheduled|sent|loaded|finished|cancelled|canceled)\b(?=\s*(?:$|[.!?,;:(\n]))/gi, "$1");
+  if (own.every((piece) => ERROR_TEXT.test(piece)) && !IMPERATIVE.test(text))
+    return false;
+  if (!hasDirective(text) && !IMPERATIVE.test(text))
+    return false;
+  const fn = import_typescript5.default.isFunctionLike(owner) ? owner : import_typescript5.default.isVariableDeclaration(owner) && owner.initializer && import_typescript5.default.isFunctionLike(unwrapNode(owner.initializer)) ? unwrapNode(owner.initializer) : undefined;
+  return !fn || isTextBuilder(fn);
+}
+function isNamedTableEntry(property) {
+  const object = property.parent;
+  if (object.properties.some((entry) => entry.name && import_typescript5.default.isIdentifier(entry.name) && entry.name.text === "type"))
+    return false;
+  let node = object;
+  while (import_typescript5.default.isObjectLiteralExpression(node) || import_typescript5.default.isPropertyAssignment(node) || import_typescript5.default.isParenthesizedExpression(node) || import_typescript5.default.isAsExpression(node) || import_typescript5.default.isSatisfiesExpression(node) || import_typescript5.default.isTypeAssertionExpression(node)) {
+    node = node.parent;
+  }
+  return import_typescript5.default.isVariableDeclaration(node) || import_typescript5.default.isPropertyDeclaration(node) || import_typescript5.default.isExportAssignment(node);
+}
+function withoutLabels(text) {
+  return text.replace(/\{\{[^}]*\}\}/g, " ").replace(/(^|[.!?\n]\s*)[A-Za-z][\w -]{0,24}:(?=\s)/g, "$1");
+}
+var IMPERATIVE_VERBS = "keep|write|reply|respond|return|answer|use|include|output|list|describe|summari[sz]e|explain|decide|pick|choose|rate|score|label|extract|generate|draft|revise|rewrite|translate|tell|ask|call|check|verify|follow|format|limit|stop|continue|focus|consider|act|identify|compare|judge|review|repair|fix|plan|propose|suggest|recommend|find|search|read|treat|cite|flag|mark|rank|group|merge|drop|skip|wait|confirm|send|offer|share|re-share|lean|vary|retry|resend|retell|replace|unschedule|reschedule|reconnect|connect|attach|pass|move|open|try|run|re-run|rerun|load|save|update|delete|remove|add|create|edit|post|publish|schedule|mention|note|let|give|show|present|announce|surface|ping|text|message|forward|route|hand|escalate|report|log";
+var IMPERATIVE = new RegExp(`(?:^|[.!?:;\\n]\\s*|\\bif\\b[^.!?\\n]{0,160},\\s*)(?:then\\s+)?(?:${IMPERATIVE_VERBS})\\b`, "i");
+function unwrapNode(node) {
+  let current = node;
+  while (import_typescript5.default.isParenthesizedExpression(current) || import_typescript5.default.isAsExpression(current) || import_typescript5.default.isSatisfiesExpression(current))
+    current = current.expression;
+  return current;
+}
+function isTextBuilder(fn) {
+  const modifiers = import_typescript5.default.canHaveModifiers(fn) ? import_typescript5.default.getModifiers(fn) ?? [] : [];
+  if (modifiers.some((modifier) => modifier.kind === import_typescript5.default.SyntaxKind.AsyncKeyword))
+    return false;
+  const declared = fn.type?.getText().replace(/\s+/g, "");
+  if (declared && !/^(?:Promise<)?(?:(?:readonly)?string(?:\[\])?|null|undefined)(?:\|(?:(?:readonly)?string(?:\[\])?|null|undefined))*>?$/.test(declared))
+    return false;
+  let builder = true;
+  let returns = 0;
+  let failures = 0;
+  const visit = (node) => {
+    if (!builder)
+      return;
+    if (node !== fn && import_typescript5.default.isFunctionLike(node))
+      return;
+    if (import_typescript5.default.isAwaitExpression(node))
+      builder = false;
+    else if (import_typescript5.default.isReturnStatement(node) && node.expression) {
+      if (returnsRecord(node.expression))
+        builder = false;
+      returns += 1;
+      if (ERROR_TEXT.test(leadingText(node.expression)))
+        failures += 1;
+      import_typescript5.default.forEachChild(node, visit);
+    } else
+      import_typescript5.default.forEachChild(node, visit);
+  };
+  const body = fn.body;
+  if (body && !import_typescript5.default.isBlock(body))
+    return !returnsRecord(body);
+  if (body)
+    import_typescript5.default.forEachChild(body, visit);
+  return builder && !(returns > 1 && failures > 0 && takesContext(fn));
+}
+function takesContext(fn) {
+  return fn.parameters.some((parameter) => {
+    const name = import_typescript5.default.isIdentifier(parameter.name) ? parameter.name.text : "";
+    return /^(?:ctx|context|env|sql|db|tx)$/.test(name) || /(?:Context|Env)\b/.test(parameter.type?.getText() ?? "");
+  });
+}
+function leadingText(expr) {
+  const value = unwrapNode(expr);
+  if (import_typescript5.default.isStringLiteral(value) || import_typescript5.default.isNoSubstitutionTemplateLiteral(value))
+    return value.text;
+  if (import_typescript5.default.isTemplateExpression(value))
+    return value.head.text;
+  if (import_typescript5.default.isBinaryExpression(value) && value.operatorToken.kind === import_typescript5.default.SyntaxKind.PlusToken)
+    return leadingText(value.left);
+  return "";
+}
+function returnsRecord(expr) {
+  const value = unwrapNode(expr);
+  if (import_typescript5.default.isObjectLiteralExpression(value))
+    return true;
+  if (import_typescript5.default.isConditionalExpression(value))
+    return returnsRecord(value.whenTrue) || returnsRecord(value.whenFalse);
+  return value.kind === import_typescript5.default.SyntaxKind.TrueKeyword || value.kind === import_typescript5.default.SyntaxKind.FalseKeyword || import_typescript5.default.isNumericLiteral(value);
+}
+function isInstructionDescription(text) {
+  if (text.length >= 2000)
+    return true;
+  if (text.length < 600)
+    return false;
+  return /\b(?:you must|always|never|do not|don't|only (?:use|call)|use this (?:tool|when)|call this (?:tool|when|before|after)|before (?:calling|using)|when to use)\b/i.test(text);
+}
+function toolDefinitionSite(tool) {
+  return {
+    id: `tool:${tool.toolId}`,
+    path: tool.definition.path,
+    line: tool.definition.line,
+    col: 1,
+    callee: tool.name,
+    sdk: "tool-definition",
+    language: "ts",
+    scope: tool.scope,
+    promptArgs: [],
+    isTest: false,
+    isEval: false
+  };
+}
+function resolvePromptArguments(callSites, context, options = {}) {
+  const resolver = new PromptResolver(context, options);
+  for (const tool of options.toolDefinitions ?? []) {
+    const node = nodeOf(tool.definition, context);
+    if (node)
+      resolver.resolveTools(toolDefinitionSite(tool), node);
+  }
+  for (const site of callSites) {
+    if (!/\.[cm]?[jt]sx?$/.test(site.path))
+      continue;
+    for (const { role, arg } of site.promptArgs) {
+      const node = nodeOf(arg, context);
+      if (!node)
+        continue;
+      resolver.resolveArgument(site, role, node, arg.key ? arg.key.split(".") : []);
+    }
+    const tools = site.toolsArg ? nodeOf(site.toolsArg, context) : undefined;
+    if (tools)
+      resolver.resolveTools(site, tools);
+  }
+  return resolver.result();
+}
+
+class PromptResolver {
+  context;
+  refs = new Map;
+  unresolved = new Map;
+  maxDepth;
+  maxParamLevels;
+  keepAll;
+  callersByName = new Map;
+  aliasesByName = new Map;
+  callersIndexed = false;
+  resolvedCallers = new WeakMap;
+  locallyWrittenParameters = new WeakMap;
+  methodIndex;
+  constructor(context, options) {
+    this.context = context;
+    this.maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    this.maxParamLevels = options.maxParamLevels ?? DEFAULT_MAX_PARAM_LEVELS;
+    this.keepAll = options.keepAll === true;
+  }
+  resolveArgument(site, role, node, project = []) {
+    const walk = { site, role, depth: 0, paramLevels: 0, bindings: new Map, hops: [], seen: new Set, project, flags: [] };
+    this.value(node, undefined, walk);
+  }
+  resolveTools(site, node) {
+    const walk = { site, role: "tool-description", depth: 0, paramLevels: 0, bindings: new Map, hops: [], seen: new Set, project: [], flags: [] };
+    this.toolDefinitions(node, walk, 0, new Set);
+  }
+  toolDefinitions(node, walk, depth, seen) {
+    if (depth > 8 || seen.has(node))
+      return;
+    seen.add(node);
+    const expr = unwrap2(node);
+    if (import_typescript5.default.isArrayLiteralExpression(expr)) {
+      for (const element of expr.elements)
+        this.toolDefinitions(import_typescript5.default.isSpreadElement(element) ? element.expression : element, walk, depth + 1, seen);
+      return;
+    }
+    if (import_typescript5.default.isObjectLiteralExpression(expr)) {
+      const description = expr.properties.find((p) => propertyName(p) === "description");
+      const handler = expr.properties.find((p) => /^(?:execute|handler|run|invoke|call|func)$/.test(propertyName(p) ?? ""));
+      if (description || handler) {
+        if (description && import_typescript5.default.isPropertyAssignment(description)) {
+          this.value(description.initializer, { node: description, name: toolName(expr) ? `${toolName(expr)} description` : "description", kind: "literal" }, walk);
+        }
+        if (handler) {
+          const fn = import_typescript5.default.isPropertyAssignment(handler) ? unwrap2(handler.initializer) : handler;
+          const resultWalk = { ...walk, role: "tool-result", namedOnly: true };
+          if (import_typescript5.default.isArrowFunction(fn) || import_typescript5.default.isFunctionExpression(fn) || import_typescript5.default.isMethodDeclaration(fn))
+            this.builderBody(fn, { node: fn, kind: "builder" }, resultWalk);
+          else
+            this.value(fn, undefined, resultWalk);
+        }
+        return;
+      }
+      for (const property of expr.properties) {
+        if (import_typescript5.default.isPropertyAssignment(property))
+          this.toolDefinitions(property.initializer, walk, depth + 1, seen);
+        else if (import_typescript5.default.isShorthandPropertyAssignment(property))
+          this.toolDefinitions(property.name, walk, depth + 1, seen);
+        else if (import_typescript5.default.isSpreadAssignment(property))
+          this.toolDefinitions(property.expression, walk, depth + 1, seen);
+      }
+      return;
+    }
+    if (import_typescript5.default.isIdentifier(expr) || import_typescript5.default.isPropertyAccessExpression(expr)) {
+      for (const declaration of this.declarationsOf(import_typescript5.default.isPropertyAccessExpression(expr) ? expr.name : expr)) {
+        const init = import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isPropertyAssignment(declaration) || import_typescript5.default.isPropertyDeclaration(declaration) ? declaration.initializer : undefined;
+        if (init)
+          this.toolDefinitions(init, walk, depth + 1, seen);
+        const fn = functionOf(declaration);
+        if (fn?.body)
+          this.returnsOf(fn, (value) => this.toolDefinitions(value, walk, depth + 1, seen));
+      }
+      return;
+    }
+    if (import_typescript5.default.isCallExpression(expr)) {
+      const callee = import_typescript5.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name : expr.expression;
+      const fns = this.declarationsOf(callee).map(functionOf).filter((fn) => fn?.body);
+      if (fns.length > 0)
+        for (const fn of fns)
+          this.returnsOf(fn, (value) => this.toolDefinitions(value, walk, depth + 1, seen));
+      for (const argument of expr.arguments)
+        this.toolDefinitions(argument, walk, depth + 1, seen);
+    }
+  }
+  returnsOf(fn, each) {
+    const body = fn.body;
+    if (!body)
+      return;
+    if (!import_typescript5.default.isBlock(body)) {
+      each(body);
+      return;
+    }
+    const visit = (node) => {
+      if (node !== fn && import_typescript5.default.isFunctionLike(node))
+        return;
+      if (import_typescript5.default.isReturnStatement(node) && node.expression)
+        each(node.expression);
+      import_typescript5.default.forEachChild(node, visit);
+    };
+    visit(body);
+  }
+  result() {
+    const firstOnLine = new Map;
+    for (const ref of this.refs.values()) {
+      const line = `${ref.path}:${ref.line}`;
+      firstOnLine.set(line, Math.min(firstOnLine.get(line) ?? Infinity, ref.start));
+    }
+    const refs = [...this.refs.values()].filter((ref) => this.keepAll || ref.role !== "tool-result" || toolResultIsPrompt(ref.ownerNode, [...ref.pieces.values()])).map(({ pieces, start, ownerNode: _owner, ...ref }) => {
+      const later = start > firstOnLine.get(`${ref.path}:${ref.line}`);
+      const column = later ? this.columnOf(ref.path, start) : undefined;
+      return {
+        ...ref,
+        ...column ? { id: `${ref.id}:${column}`, column } : {},
+        text: [...pieces.entries()].sort((a, b) => a[0] - b[0]).map(([, text]) => text).join(`
+`)
+      };
+    });
+    return {
+      refs: refs.filter((ref) => this.keepAll || ref.kind === "file" || readsAsInstructions(ref.text) && !isDataWrapper(ref.text) && (ref.text.length >= SHORT_TEXT || ref.role === "questions" || ref.role === "tool-description" || hasDirective(ref.text)) && (ref.role !== "tool-description" || isInstructionDescription(ref.text))),
+      unresolved: [...this.unresolved.values()]
+    };
+  }
+  value(node, owner, walk) {
+    if (walk.depth > this.maxDepth) {
+      this.markUnresolved(node, "depth-limit", walk);
+      return;
+    }
+    const expr = unwrap2(node);
+    if (walk.project[0] === FLATMAP_ELEMENT && (import_typescript5.default.isStringLiteral(expr) || import_typescript5.default.isNoSubstitutionTemplateLiteral(expr) || import_typescript5.default.isTemplateExpression(expr) || import_typescript5.default.isObjectLiteralExpression(expr))) {
+      walk = { ...walk, project: walk.project.slice(1) };
+    }
+    if (walk.project.length > 0 && (import_typescript5.default.isStringLiteral(expr) || import_typescript5.default.isNoSubstitutionTemplateLiteral(expr) || import_typescript5.default.isTemplateExpression(expr) || import_typescript5.default.isBinaryExpression(expr) && expr.operatorToken.kind === import_typescript5.default.SyntaxKind.PlusToken)) {
+      return;
+    }
+    if (import_typescript5.default.isStringLiteral(expr) || import_typescript5.default.isNoSubstitutionTemplateLiteral(expr)) {
+      this.text(expr, expr.text, owner, walk);
+      return;
+    }
+    if (import_typescript5.default.isTemplateExpression(expr)) {
+      const sf = expr.getSourceFile();
+      let text = expr.head.text;
+      for (const span of expr.templateSpans) {
+        text += `{{${span.expression.getText(sf).replace(/\s+/g, " ").slice(0, 60)}}}${span.literal.text}`;
+      }
+      this.text(expr, text, owner ?? { node: expr, kind: "template" }, walk);
+      for (const span of expr.templateSpans)
+        this.value(span.expression, undefined, flag(walk, "interpolated"));
+      return;
+    }
+    if (import_typescript5.default.isBinaryExpression(expr)) {
+      if (expr.operatorToken.kind === import_typescript5.default.SyntaxKind.PlusToken) {
+        this.value(expr.left, owner, walk);
+        this.value(expr.right, owner, walk);
+      } else if (expr.operatorToken.kind === import_typescript5.default.SyntaxKind.BarBarToken || expr.operatorToken.kind === import_typescript5.default.SyntaxKind.QuestionQuestionToken) {
+        this.value(expr.left, owner, walk);
+        this.value(expr.right, owner, walk);
+      }
+      return;
+    }
+    if (import_typescript5.default.isConditionalExpression(expr)) {
+      this.value(expr.whenTrue, owner, walk);
+      this.value(expr.whenFalse, owner, walk);
+      return;
+    }
+    if (import_typescript5.default.isArrayLiteralExpression(expr)) {
+      if (walk.project[0] === ARRAY_ELEMENT || walk.project[0] === FLATMAP_ELEMENT) {
+        const inner = { ...walk, project: walk.project.slice(1) };
+        for (const element of expr.elements) {
+          if (import_typescript5.default.isSpreadElement(element))
+            this.value(element.expression, owner, walk);
+          else
+            this.value(element, owner, inner);
+        }
+        return;
+      }
+      if (/^\d+$/.test(walk.project[0] ?? "")) {
+        const [index, ...rest] = walk.project;
+        const selected = Number(index);
+        if (expr.elements.slice(0, selected + 1).some(import_typescript5.default.isSpreadElement)) {
+          this.markUnresolved(expr, "dynamic-key", walk);
+          return;
+        }
+        const element = expr.elements[selected];
+        if (element)
+          this.value(element, owner, { ...walk, project: rest });
+        return;
+      }
+      for (const element of expr.elements) {
+        this.value(import_typescript5.default.isSpreadElement(element) ? element.expression : element, owner, walk);
+      }
+      return;
+    }
+    if (import_typescript5.default.isObjectLiteralExpression(expr)) {
+      this.objectValue(expr, walk);
+      return;
+    }
+    if (import_typescript5.default.isIdentifier(expr)) {
+      this.identifier(expr, owner, walk);
+      return;
+    }
+    if (import_typescript5.default.isPropertyAccessExpression(expr)) {
+      this.propertyAccess(expr, owner, walk);
+      return;
+    }
+    if (import_typescript5.default.isElementAccessExpression(expr)) {
+      this.elementAccess(expr, owner, walk);
+      return;
+    }
+    if (import_typescript5.default.isCallExpression(expr)) {
+      this.call(expr, owner, walk);
+      return;
+    }
+    if (import_typescript5.default.isTaggedTemplateExpression(expr)) {
+      this.value(expr.template, owner, walk);
+      return;
+    }
+    if (import_typescript5.default.isArrowFunction(expr) || import_typescript5.default.isFunctionExpression(expr)) {
+      this.builderBody(expr, { node: expr, name: owner?.name, kind: "builder" }, walk);
+      return;
+    }
+    if ((import_typescript5.default.isMethodDeclaration(expr) || import_typescript5.default.isGetAccessorDeclaration(expr) || import_typescript5.default.isFunctionDeclaration(expr)) && expr.body) {
+      this.builderBody(expr, { node: expr, name: declarationName(expr), kind: "builder" }, walk);
+    }
+  }
+  objectValue(object, walk) {
+    if (walk.project.length > 0) {
+      const [field, ...rest] = walk.project;
+      const inner = { ...walk, project: rest };
+      for (const property of object.properties) {
+        if (import_typescript5.default.isSpreadAssignment(property)) {
+          this.value(property.expression, undefined, walk);
+          continue;
+        }
+        if (propertyName(property) !== field)
+          continue;
+        if (import_typescript5.default.isPropertyAssignment(property))
+          this.value(property.initializer, { node: property, name: field, kind: "literal" }, inner);
+        else if (import_typescript5.default.isShorthandPropertyAssignment(property))
+          this.identifier(property.name, undefined, inner);
+        else if (import_typescript5.default.isMethodDeclaration(property) || import_typescript5.default.isGetAccessorDeclaration(property))
+          this.builderBody(property, { node: property, name: field, kind: "builder" }, inner);
+      }
+      return;
+    }
+    if (walk.messageParts) {
+      const field = (expression, key, seen = new Set) => {
+        const node = unwrap2(expression);
+        if (seen.has(node))
+          return { known: false };
+        const next = new Set(seen).add(node);
+        if (import_typescript5.default.isIdentifier(node)) {
+          const declaration = this.declarationsOf(node).find((entry) => import_typescript5.default.isVariableDeclaration(entry) && entry.initializer);
+          return declaration && import_typescript5.default.isVariableDeclaration(declaration) && declaration.initializer ? field(declaration.initializer, key, next) : { known: false };
+        }
+        if (!import_typescript5.default.isObjectLiteralExpression(node))
+          return { known: false };
+        for (const property of [...node.properties].reverse()) {
+          if (import_typescript5.default.isSpreadAssignment(property)) {
+            const spread = field(property.expression, key, next);
+            if (spread.value || !spread.known)
+              return spread;
+          } else if (propertyName(property) === key) {
+            return { known: true, value: import_typescript5.default.isPropertyAssignment(property) ? property.initializer : import_typescript5.default.isShorthandPropertyAssignment(property) ? property.name : undefined };
+          }
+        }
+        return { known: true };
+      };
+      const literalString = (expression, seen = new Set) => {
+        if (!expression || seen.has(expression))
+          return;
+        const node = unwrap2(expression);
+        if (import_typescript5.default.isStringLiteralLike(node))
+          return node.text;
+        if (!import_typescript5.default.isIdentifier(node))
+          return;
+        const declaration = this.declarationsOf(node).find((entry) => import_typescript5.default.isVariableDeclaration(entry) && entry.initializer);
+        return declaration && import_typescript5.default.isVariableDeclaration(declaration) ? literalString(declaration.initializer, new Set(seen).add(expression)) : undefined;
+      };
+      const partType = literalString(field(object, "type").value);
+      if (partType === "text" || partType === "input_text") {
+        const text = field(object, "text").value;
+        if (text)
+          this.value(text, { node: text, kind: "message" }, { ...walk, messageParts: false, promptObject: false });
+      }
+      return;
+    }
+    const role = stringField(object, "role");
+    if (role && /^(?:assistant|tool|function|model)$/.test(role))
+      return;
+    for (const property of object.properties) {
+      if (import_typescript5.default.isSpreadAssignment(property)) {
+        this.value(property.expression, undefined, walk);
+        continue;
+      }
+      const key = propertyName(property);
+      if (!key)
+        continue;
+      const promptField = PROMPT_FIELDS.has(key) || walk.promptObject === true;
+      if (!promptField) {
+        if (import_typescript5.default.isPropertyAssignment(property) && import_typescript5.default.isObjectLiteralExpression(unwrap2(property.initializer))) {
+          this.objectValue(unwrap2(property.initializer), walk);
+        }
+        continue;
+      }
+      const inner = key === "parts" ? { ...walk, messageParts: true, promptObject: false } : PROMPT_FIELDS.has(key) && !/^(?:content|text|messages|user|system|prompt)$/.test(key) ? { ...walk, promptObject: true } : walk;
+      if (import_typescript5.default.isPropertyAssignment(property)) {
+        const kind = role ? "message" : "literal";
+        this.value(property.initializer, { node: property, name: role ? undefined : key, kind }, this.messageRole(inner, role));
+      } else if (import_typescript5.default.isShorthandPropertyAssignment(property)) {
+        this.identifier(property.name, undefined, inner);
+      } else if (import_typescript5.default.isMethodDeclaration(property) || import_typescript5.default.isGetAccessorDeclaration(property)) {
+        this.builderBody(property, { node: property, name: key, kind: "builder" }, this.messageRole(inner, role));
+      }
+    }
+  }
+  messageRole(walk, role) {
+    if (!role || walk.role !== "messages")
+      return walk;
+    return { ...walk, role: role === "system" || role === "developer" ? "system" : "user" };
+  }
+  identifier(identifier, owner, walk) {
+    if (identifier.text === "undefined")
+      return;
+    const file = this.importedTextFile(identifier);
+    if (file) {
+      this.fileRef(file, walk);
+      return;
+    }
+    const declarations = this.declarationsOf(identifier);
+    if (declarations.length === 0) {
+      this.markUnresolved(identifier, "external", walk);
+      return;
+    }
+    for (const declaration of declarations)
+      this.declaration(declaration, identifier, owner, walk);
+  }
+  propertyAccess(access, owner, walk) {
+    const sf = access.getSourceFile();
+    const text = access.getText(sf);
+    if (/^(?:process\.env|import\.meta\.env|Deno\.env)\b/.test(text)) {
+      this.markUnresolved(access, "env", walk);
+      return;
+    }
+    const declarations = this.declarationsOf(access.name).filter(hasValue);
+    if (walk.flags.includes("interpolated") && !PROMPT_FIELD_NAME.test(access.name.text) && declarations.length >= 3 && declarations.every((d) => import_typescript5.default.isPropertyAssignment(d) || import_typescript5.default.isShorthandPropertyAssignment(d))) {
+      return;
+    }
+    if (declarations.length > 0) {
+      for (const declaration of declarations)
+        this.declaration(declaration, access, owner, walk);
+      return;
+    }
+    if (walk.project.length === 0 && !PROMPT_FIELD_NAME.test(access.name.text) && !(walk.role !== "tool-result" && /^messages?$/.test(access.name.text)))
+      return;
+    this.value(access.expression, owner, { ...flag(walk, "projected"), project: [access.name.text, ...walk.project] });
+  }
+  elementAccess(access, owner, walk) {
+    const key = unwrap2(access.argumentExpression);
+    const literalKey = import_typescript5.default.isStringLiteral(key) || import_typescript5.default.isNumericLiteral(key) || import_typescript5.default.isNoSubstitutionTemplateLiteral(key) ? key.text : undefined;
+    if (literalKey !== undefined) {
+      const declarations = this.declarationsOf(access.argumentExpression);
+      if (declarations.length > 0) {
+        for (const declaration of declarations)
+          this.declaration(declaration, access, owner, walk);
+        return;
+      }
+    }
+    const table = this.objectLiteralOf(access.expression);
+    if (!table) {
+      this.value(access.expression, owner, literalKey === undefined ? walk : { ...flag(walk, "projected"), project: [literalKey, ...walk.project] });
+      return;
+    }
+    const next = this.step(literalKey ? walk : flag(walk, "dynamic-key"), access, literalKey ? `table field ${literalKey}` : "every field of a table read with a dynamic key");
+    if (!next)
+      return;
+    if (import_typescript5.default.isArrayLiteralExpression(table)) {
+      const elements = literalKey !== undefined && import_typescript5.default.isNumericLiteral(key) ? [table.elements[Number(literalKey)]].filter(Boolean) : table.elements;
+      for (const element of elements)
+        this.value(import_typescript5.default.isSpreadElement(element) ? element.expression : element, undefined, next);
+      return;
+    }
+    for (const property of table.properties) {
+      const name = propertyName(property);
+      if (literalKey !== undefined && name !== literalKey)
+        continue;
+      if (import_typescript5.default.isPropertyAssignment(property))
+        this.value(property.initializer, { node: property, name, kind: "literal" }, next);
+      else if (import_typescript5.default.isMethodDeclaration(property))
+        this.builderBody(property, { node: property, name, kind: "builder" }, next);
+      else if (import_typescript5.default.isShorthandPropertyAssignment(property))
+        this.identifier(property.name, undefined, next);
+    }
+  }
+  call(call, owner, walk) {
+    const callee = unwrap2(call.expression);
+    if (import_typescript5.default.isPropertyAccessExpression(callee)) {
+      const method = callee.name.text;
+      if (method === "finally") {
+        this.value(callee.expression, owner, walk);
+        return;
+      }
+      const checker = this.context.checkerFor(this.relative(callee.expression.getSourceFile().fileName));
+      const arrayType = (type, awaited = false) => {
+        if (!type)
+          return false;
+        if (import_typescript5.default.isArrayTypeNode(type) || import_typescript5.default.isTupleTypeNode(type))
+          return true;
+        if (import_typescript5.default.isTypeOperatorNode(type))
+          return arrayType(type.type, awaited);
+        if (!import_typescript5.default.isTypeReferenceNode(type))
+          return false;
+        const name = type.typeName.getText();
+        return /^(?:Readonly)?Array$/.test(name) || awaited && name === "Promise" && arrayType(type.typeArguments?.[0]);
+      };
+      const arraySeen = new Set;
+      const isArrayReceiver = (expression, awaited = false) => {
+        let raw = expression;
+        while (import_typescript5.default.isParenthesizedExpression(raw) || import_typescript5.default.isAsExpression(raw) || import_typescript5.default.isSatisfiesExpression(raw) || import_typescript5.default.isNonNullExpression(raw) || import_typescript5.default.isTypeAssertionExpression(raw))
+          raw = raw.expression;
+        if (import_typescript5.default.isAwaitExpression(raw))
+          return isArrayReceiver(raw.expression, true);
+        const receiver = unwrap2(expression);
+        if (arraySeen.has(receiver))
+          return false;
+        arraySeen.add(receiver);
+        if (import_typescript5.default.isIdentifier(receiver)) {
+          for (const declaration of this.declarationsOf(receiver)) {
+            if ((import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isParameter(declaration)) && (arrayType(declaration.type) || declaration.initializer && isArrayReceiver(declaration.initializer)))
+              return true;
+          }
+        }
+        if (import_typescript5.default.isCallExpression(receiver)) {
+          for (const declaration of this.declarationsOf(import_typescript5.default.isPropertyAccessExpression(receiver.expression) ? receiver.expression.name : receiver.expression)) {
+            const fn = functionOf(declaration);
+            if (fn && arrayType(fn.type, awaited))
+              return true;
+          }
+        }
+        const type = checker?.getTypeAtLocation(receiver);
+        if (import_typescript5.default.isArrayLiteralExpression(this.objectLiteralOf(receiver) ?? receiver) || !!checker && !!type && (type.isUnion() ? type.types : [type]).every((item) => checker.isArrayType(item) || checker.isTupleType(item)))
+          return true;
+        return import_typescript5.default.isCallExpression(receiver) && import_typescript5.default.isPropertyAccessExpression(receiver.expression) && ARRAY_ASSEMBLY_METHODS.has(receiver.expression.name.text) && receiver.expression.name.text !== "join" && isArrayReceiver(receiver.expression.expression);
+      };
+      const arrayReceiver = isArrayReceiver(callee.expression);
+      if ((method === "find" || method === "findLast") && arrayReceiver) {
+        this.value(callee.expression, owner, { ...flag(walk, "dynamic-key"), project: [ARRAY_ELEMENT, ...walk.project] });
+        return;
+      }
+      if ((method === "map" || method === "flatMap") && arrayReceiver && call.arguments[0]) {
+        const callback = unwrap2(call.arguments[0]);
+        const functions2 = import_typescript5.default.isArrowFunction(callback) || import_typescript5.default.isFunctionExpression(callback) ? [callback] : this.declarationsOf(callback).map(functionOf).filter((fn) => !!fn?.body);
+        const output = walk.project[0];
+        const indexed = /^\d+$/.test(output ?? "");
+        if (method === "flatMap" && indexed) {
+          this.markUnresolved(call, "dynamic-key", walk);
+          return;
+        }
+        const eachOutput = output === ARRAY_ELEMENT || output === FLATMAP_ELEMENT;
+        const callbackProject = eachOutput ? method === "flatMap" ? [FLATMAP_ELEMENT, ...walk.project.slice(1)] : walk.project.slice(1) : indexed ? walk.project.slice(1) : walk.project;
+        const sourceProject = method === "map" && indexed ? output : ARRAY_ELEMENT;
+        for (const fn of functions2) {
+          const next = this.step({ ...walk, project: callbackProject }, fn, `array callback at ${this.where(call)}`);
+          if (!next || walk.seen.has(fn))
+            continue;
+          next.bindings = new Map(next.bindings);
+          bindParameters(fn, [callee.expression], walk.bindings, next.bindings);
+          const first = fn.parameters[0];
+          if (first && import_typescript5.default.isArrayBindingPattern(first.name)) {
+            first.name.elements.forEach((element, index) => {
+              if (import_typescript5.default.isBindingElement(element) && !element.dotDotDotToken && !element.initializer) {
+                next.bindings.set(element, { expr: callee.expression, bindings: walk.bindings, project: [String(index)] });
+              }
+            });
+          }
+          for (const [declaration, binding] of next.bindings) {
+            if (declaration === first || import_typescript5.default.isBindingElement(declaration) && parameterOf(declaration) === first) {
+              next.bindings.set(declaration, { ...binding, project: [sourceProject, ...binding.project ?? []] });
+            }
+          }
+          this.builderBody(fn, owner ?? { node: fn, kind: "builder" }, next);
+        }
+        if (functions2.length)
+          return;
+      }
+      if (CALLBACK_METHODS.has(method)) {
+        const callbacks = call.arguments.map(unwrap2).filter((a) => import_typescript5.default.isArrowFunction(a) || import_typescript5.default.isFunctionExpression(a));
+        for (const callback of callbacks)
+          this.builderBody(callback, owner ?? { node: callback, kind: "builder" }, walk);
+        if (callbacks.length === 0)
+          for (const argument of call.arguments)
+            this.value(argument, owner, walk);
+        if (method === "catch")
+          this.value(callee.expression, owner, walk);
+        return;
+      }
+      if (ARRAY_ASSEMBLY_METHODS.has(method) && /^\d+$/.test(walk.project[0] ?? "")) {
+        this.markUnresolved(call, "dynamic-key", walk);
+        return;
+      }
+      if (TEXT_PRESERVING_METHODS.has(method) || ARRAY_ASSEMBLY_METHODS.has(method)) {
+        this.value(callee.expression, owner, walk);
+        if (method === "concat")
+          for (const argument of call.arguments)
+            this.value(argument, owner, walk);
+        return;
+      }
+    }
+    if (walk.project.length > 0 && import_typescript5.default.isPropertyAccessExpression(callee) && callee.getText() === "JSON.stringify" && call.arguments[0]) {
+      this.value(call.arguments[0], owner, walk);
+      return;
+    }
+    if (import_typescript5.default.isIdentifier(callee) && /^(?:String|dedent|outdent|stripIndent|stripIndents|trim)$/.test(callee.text)) {
+      for (const argument of call.arguments)
+        this.value(argument, owner, walk);
+      return;
+    }
+    if (import_typescript5.default.isArrowFunction(callee) || import_typescript5.default.isFunctionExpression(callee)) {
+      const next = this.step(walk, callee, `immediately invoked builder at ${this.where(call)}`);
+      if (!next || walk.seen.has(callee))
+        return;
+      next.bindings = new Map(next.bindings);
+      bindParameters(callee, call.arguments, walk.bindings, next.bindings);
+      this.builderBody(callee, { node: callee, kind: "builder" }, next);
+      return;
+    }
+    if (import_typescript5.default.isPropertyAccessExpression(callee) && /^Promise\.(?:resolve|all)$/.test(callee.getText()) && call.arguments[0]) {
+      this.value(call.arguments[0], owner, walk);
+      return;
+    }
+    const declarations = this.declarationsOf(import_typescript5.default.isPropertyAccessExpression(callee) ? callee.name : callee);
+    if (call.arguments.length === 0 && declarations.some((declaration) => import_typescript5.default.isParameter(declaration) || import_typescript5.default.isBindingElement(declaration) && isParameterBinding(declaration))) {
+      this.value(callee, owner, walk);
+      return;
+    }
+    let functions = declarations.map(functionOf).filter((fn) => Boolean(fn));
+    if (functions.length === 0 && import_typescript5.default.isPropertyAccessExpression(callee)) {
+      const methods = this.methodsNamed(callee.name.text);
+      if (methods.length === 1)
+        functions = methods;
+    }
+    functions = functions.filter((fn) => fn.body);
+    if (functions.length === 0) {
+      this.markUnresolved(call, /\b(?:fetch|read|load|get|query|select|find)\w*\s*$/i.test(callee.getText(call.getSourceFile())) ? "io" : "external", walk);
+      return;
+    }
+    for (const fn of functions) {
+      if (walk.seen.has(fn))
+        continue;
+      const name = functionName2(fn);
+      if (walk.depth + 1 > this.maxDepth) {
+        this.markUnresolved(call, "depth-limit", walk);
+        continue;
+      }
+      const next = this.step(walk, fn, `builder ${name ?? "function"} called at ${this.where(call)}`);
+      if (!next)
+        continue;
+      next.bindings = new Map(next.bindings);
+      bindParameters(fn, call.arguments, walk.bindings, next.bindings);
+      this.builderBody(fn, { node: fn, name, kind: "builder" }, next);
+    }
+  }
+  builderBody(fn, owner, walk) {
+    const body = fn.body;
+    if (!body)
+      return;
+    const inner = { ...walk, seen: new Set(walk.seen).add(fn) };
+    if (!import_typescript5.default.isBlock(body)) {
+      this.value(body, owner, inner);
+      return;
+    }
+    const visit = (node) => {
+      if (node !== fn && import_typescript5.default.isFunctionLike(node))
+        return;
+      if (import_typescript5.default.isReturnStatement(node) && node.expression)
+        this.value(node.expression, owner, inner);
+      import_typescript5.default.forEachChild(node, visit);
+    };
+    visit(body);
+  }
+  declaration(declaration, at, owner, walk) {
+    if (walk.seen.has(declaration))
+      return;
+    if (import_typescript5.default.isParameter(declaration) || import_typescript5.default.isBindingElement(declaration) && isParameterBinding(declaration)) {
+      this.parameter(declaration, at, owner, walk);
+      return;
+    }
+    const sf = declaration.getSourceFile();
+    if (this.isExternal(sf)) {
+      this.markUnresolved(at, "external", walk);
+      return;
+    }
+    const name = declarationName(declaration);
+    const next = this.step(walk, declaration, `${name ?? "value"} defined here`);
+    if (!next)
+      return;
+    next.seen = new Set(next.seen).add(declaration);
+    if (import_typescript5.default.isBindingElement(declaration)) {
+      const fields = [];
+      let current = declaration;
+      let root;
+      for (;; ) {
+        const pattern = current.parent;
+        if (!import_typescript5.default.isObjectBindingPattern(pattern) && !import_typescript5.default.isArrayBindingPattern(pattern))
+          break;
+        if (current.dotDotDotToken) {
+          if (!import_typescript5.default.isObjectBindingPattern(pattern) || next.project.length === 0 || pattern.elements.some((entry) => entry !== current && bindingField(entry) === next.project[0])) {
+            this.markUnresolved(at, "dynamic-key", next);
+            return;
+          }
+        } else {
+          const field = import_typescript5.default.isArrayBindingPattern(pattern) ? String(pattern.elements.indexOf(current)) : bindingField(current);
+          if (field === undefined)
+            break;
+          fields.unshift(field);
+        }
+        const holder = pattern.parent;
+        if (import_typescript5.default.isVariableDeclaration(holder)) {
+          root = holder;
+          break;
+        }
+        if (!import_typescript5.default.isBindingElement(holder))
+          break;
+        current = holder;
+      }
+      if (declaration.initializer) {
+        const checker = this.context.checkerFor(this.relative(declaration.getSourceFile().fileName));
+        let selected = root?.initializer && checker?.getTypeAtLocation(root.initializer);
+        let optional = false;
+        for (const field of fields) {
+          const property = selected?.getProperty(field);
+          optional ||= !!property && (property.flags & import_typescript5.default.SymbolFlags.Optional) !== 0 && !(root?.initializer && import_typescript5.default.isObjectLiteralExpression(unwrap2(root.initializer)));
+          selected = property && checker ? checker.getTypeOfSymbolAtLocation(property, root.initializer) : undefined;
+        }
+        let literal = root?.initializer ? unwrap2(root.initializer) : undefined;
+        for (const field of fields) {
+          if (literal && import_typescript5.default.isObjectLiteralExpression(literal)) {
+            const property = literal.properties.find((entry) => propertyName(entry) === field);
+            literal = property && import_typescript5.default.isPropertyAssignment(property) ? unwrap2(property.initializer) : property && import_typescript5.default.isShorthandPropertyAssignment(property) ? property.name : undefined;
+          } else if (literal && import_typescript5.default.isArrayLiteralExpression(literal)) {
+            const element = literal.elements[Number(field)];
+            literal = element && !import_typescript5.default.isOmittedExpression(element) && !import_typescript5.default.isSpreadElement(element) ? unwrap2(element) : undefined;
+          } else
+            literal = undefined;
+        }
+        if (literal && checker) {
+          selected = checker.getTypeAtLocation(literal);
+          optional = false;
+        }
+        const mayBeUndefined = optional || !selected || (selected.flags & (import_typescript5.default.TypeFlags.Any | import_typescript5.default.TypeFlags.Unknown | import_typescript5.default.TypeFlags.Undefined | import_typescript5.default.TypeFlags.Void)) !== 0 || selected.isUnion() && selected.types.some((type) => (type.flags & (import_typescript5.default.TypeFlags.Undefined | import_typescript5.default.TypeFlags.Void)) !== 0);
+        if (mayBeUndefined)
+          this.value(declaration.initializer, owner, next);
+      }
+      if (root?.initializer)
+        this.value(root.initializer, owner, { ...next, project: [...fields, ...next.project] });
+      else
+        this.markUnresolved(at, "param-unbound", next);
+      return;
+    }
+    if (import_typescript5.default.isVariableDeclaration(declaration)) {
+      if (/^\d+$/.test(next.project[0] ?? "") && this.assembly(declaration, ownerFor(declaration, name, owner), next, at, true))
+        return;
+      if (!owner && next.flags.includes("interpolated") && declaration.initializer) {
+        let scope = declaration.parent;
+        while (scope && !import_typescript5.default.isFunctionLike(scope))
+          scope = scope.parent;
+        const pieces = [];
+        const fragment = (node) => {
+          const value = unwrap2(node);
+          if (import_typescript5.default.isStringLiteral(value) || import_typescript5.default.isNoSubstitutionTemplateLiteral(value)) {
+            pieces.push(value.text);
+            return true;
+          }
+          if (import_typescript5.default.isTemplateExpression(value)) {
+            pieces.push(value.head.text, ...value.templateSpans.map((span) => span.literal.text));
+            return true;
+          }
+          if (import_typescript5.default.isConditionalExpression(value))
+            return fragment(value.whenTrue) && fragment(value.whenFalse);
+          return false;
+        };
+        const localFragment = fragment(declaration.initializer);
+        const instructionPieces = pieces.map((piece) => piece.replace(/\byou\b(?!['’](?:re|ve|ll|d)\b|\s+(?:are|must|should|need|will|can|may|have to)\b)/gi, ""));
+        if (scope && import_typescript5.default.isFunctionLike(scope) && contains(scope, at) && localFragment && !hasDirective(instructionPieces.join(`
+`)) && !toolResultIsPrompt(declaration, instructionPieces)) {
+          const fnName = scope.name && import_typescript5.default.isIdentifier(scope.name) ? scope.name.text : undefined;
+          owner = { node: scope, name: fnName, kind: "builder" };
+        }
+      }
+      if (declaration.initializer) {
+        const fn2 = unwrap2(declaration.initializer);
+        if (import_typescript5.default.isArrowFunction(fn2) || import_typescript5.default.isFunctionExpression(fn2)) {
+          this.builderBody(fn2, { node: declaration, name, kind: "builder" }, next);
+        } else {
+          const source = unwrap2(declaration.initializer);
+          const checker = this.context.checkerFor(this.relative(source.getSourceFile().fileName));
+          const sourceType = checker?.getTypeAtLocation(source);
+          const sharesArray = sourceType && checker && (sourceType.isUnion() ? sourceType.types : [sourceType]).every((type) => checker.isArrayType(type) || checker.isTupleType(type));
+          const aliasWalk = import_typescript5.default.isIdentifier(source) && sharesArray ? { ...next, assemblyReadAt: next.assemblyReadAt ?? at } : { ...next, assemblyReadAt: undefined };
+          this.value(declaration.initializer, ownerFor(declaration, name, owner), aliasWalk);
+        }
+      }
+      this.assembly(declaration, ownerFor(declaration, name, owner), next, at);
+      return;
+    }
+    if (import_typescript5.default.isPropertyAssignment(declaration)) {
+      this.value(declaration.initializer, ownerFor(declaration, name, owner), next);
+      return;
+    }
+    if (import_typescript5.default.isShorthandPropertyAssignment(declaration)) {
+      this.identifier(declaration.name, owner, next);
+      return;
+    }
+    if (import_typescript5.default.isPropertyDeclaration(declaration)) {
+      if (declaration.initializer)
+        this.value(declaration.initializer, ownerFor(declaration, name, owner), next);
+      if (name && import_typescript5.default.isClassLike(declaration.parent)) {
+        const visit = (node) => {
+          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 === name) {
+            this.value(node.right, undefined, next);
+          }
+          import_typescript5.default.forEachChild(node, visit);
+        };
+        visit(declaration.parent);
+      }
+      return;
+    }
+    if (import_typescript5.default.isEnumMember(declaration) && declaration.initializer) {
+      this.value(declaration.initializer, ownerFor(declaration, name, owner), next);
+      return;
+    }
+    const fn = functionOf(declaration);
+    if (fn)
+      this.builderBody(fn, { node: declaration, name, kind: "builder" }, next);
+  }
+  assembly(declaration, owner, walk, at, probe = false) {
+    if (!import_typescript5.default.isIdentifier(declaration.name))
+      return false;
+    const scope = enclosingScope2(declaration);
+    if (!scope)
+      return false;
+    const assignments = [];
+    const findRebinding = (node) => {
+      if (import_typescript5.default.isFunctionLike(node))
+        return;
+      if (import_typescript5.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript5.default.SyntaxKind.EqualsToken && import_typescript5.default.isIdentifier(node.left) && this.declarationsOf(node.left).includes(declaration))
+        assignments.push(node);
+      import_typescript5.default.forEachChild(node, findRebinding);
+    };
+    findRebinding(scope);
+    const conditional = (assignment) => {
+      for (let node = assignment.parent;node && node !== scope; node = node.parent) {
+        if (import_typescript5.default.isIfStatement(node) || import_typescript5.default.isConditionalExpression(node) || import_typescript5.default.isSwitchStatement(node) || import_typescript5.default.isIterationStatement(node, false) || import_typescript5.default.isTryStatement(node))
+          return true;
+      }
+      return false;
+    };
+    const loopAncestors = (node) => {
+      const loops = new Set;
+      for (let parent = node.parent;parent && parent !== scope; parent = parent.parent) {
+        if (import_typescript5.default.isFunctionLike(parent))
+          break;
+        if (import_typescript5.default.isIterationStatement(parent, false))
+          loops.add(parent);
+      }
+      return loops;
+    };
+    const versionsAt = (node) => {
+      const versions = new Set([declaration]);
+      const loops = loopAncestors(node);
+      for (const assignment of assignments) {
+        const loopBack = [...loopAncestors(assignment)].some((loop) => loops.has(loop));
+        if (assignment.end > node.getStart() && !loopBack)
+          continue;
+        if (!conditional(assignment))
+          versions.clear();
+        versions.add(assignment);
+      }
+      return versions;
+    };
+    const identities = (expression, seen = new Set) => {
+      const value = unwrap2(expression);
+      if (seen.has(value))
+        return new Set;
+      const next = new Set(seen).add(value);
+      if (import_typescript5.default.isIdentifier(value)) {
+        const entry = this.declarationsOf(value).find((item) => import_typescript5.default.isVariableDeclaration(item) || import_typescript5.default.isParameter(item));
+        if (entry === declaration)
+          return versionsAt(value);
+        if (entry && import_typescript5.default.isVariableDeclaration(entry) && entry.initializer && entry.parent.flags & import_typescript5.default.NodeFlags.Const)
+          return identities(entry.initializer, next);
+        return new Set;
+      }
+      if (import_typescript5.default.isConditionalExpression(value))
+        return new Set([...identities(value.whenTrue, next), ...identities(value.whenFalse, next)]);
+      if (import_typescript5.default.isBinaryExpression(value) && (value.operatorToken.kind === import_typescript5.default.SyntaxKind.BarBarToken || value.operatorToken.kind === import_typescript5.default.SyntaxKind.QuestionQuestionToken))
+        return new Set([...identities(value.left, next), ...identities(value.right, next)]);
+      return new Set;
+    };
+    const readVersions = new Map([...versionsAt(at)].map((version) => [version, (walk.assemblyReadAt ?? at).getStart()]));
+    for (let round = 0;round < 8; round += 1) {
+      let changed = false;
+      for (const [version] of [...readVersions]) {
+        if (!import_typescript5.default.isBinaryExpression(version))
+          continue;
+        const predecessors = new Set;
+        const visit2 = (node) => {
+          if (import_typescript5.default.isFunctionLike(node))
+            return;
+          if (import_typescript5.default.isIdentifier(node))
+            for (const identity of identities(node))
+              predecessors.add(identity);
+          import_typescript5.default.forEachChild(node, visit2);
+        };
+        visit2(version.right);
+        for (const previous of predecessors) {
+          const cutoff = version.getStart();
+          if ((readVersions.get(previous) ?? -1) < cutoff) {
+            readVersions.set(previous, cutoff);
+            changed = true;
+          }
+        }
+      }
+      if (!changed)
+        break;
+    }
+    const references = (expression) => [...identities(expression)].some((version) => (readVersions.get(version) ?? -1) >= expression.getStart());
+    const invoked = (fn, seen = new Set) => {
+      if (seen.has(fn))
+        return false;
+      const next = new Set(seen).add(fn);
+      let expression = fn;
+      while (import_typescript5.default.isParenthesizedExpression(expression.parent))
+        expression = expression.parent;
+      const parentCall = expression.parent;
+      const reachableCall = (call) => {
+        if (call.getSourceFile() !== scope.getSourceFile() || !contains(scope, call))
+          return false;
+        for (let parent = call.parent;parent && parent !== scope; parent = parent.parent) {
+          if (import_typescript5.default.isFunctionLike(parent))
+            return invoked(parent, next);
+        }
+        return true;
+      };
+      if (import_typescript5.default.isCallExpression(parentCall)) {
+        if (parentCall.expression === expression)
+          return reachableCall(parentCall);
+        if (import_typescript5.default.isPropertyAccessExpression(parentCall.expression) && parentCall.arguments.some((argument) => argument === expression)) {
+          const method = parentCall.expression.name.text;
+          if (/^(?:forEach|map|flatMap|filter|reduce|reduceRight|some|every|find|findIndex)$/.test(method)) {
+            return reachableCall(parentCall);
+          }
+          if (/^(?:then|catch|finally)$/.test(method)) {
+            const completed = (value, seen2 = new Set) => {
+              if (seen2.has(value))
+                return false;
+              const visited = new Set(seen2).add(value);
+              let completion = value;
+              while (import_typescript5.default.isParenthesizedExpression(completion.parent))
+                completion = completion.parent;
+              const parent = completion.parent;
+              if (import_typescript5.default.isAwaitExpression(parent)) {
+                return parent.end <= (walk.assemblyReadAt ?? at).getStart();
+              }
+              if (import_typescript5.default.isPropertyAccessExpression(parent) && parent.expression === completion && /^(?:then|catch|finally)$/.test(parent.name.text) && import_typescript5.default.isCallExpression(parent.parent) && parent.parent.expression === parent) {
+                return completed(parent.parent, visited);
+              }
+              if (!import_typescript5.default.isVariableDeclaration(parent) || parent.initializer !== completion || !import_typescript5.default.isIdentifier(parent.name) || !(parent.parent.flags & import_typescript5.default.NodeFlags.Const))
+                return false;
+              let found = false;
+              const findCompletion = (node) => {
+                if (found || import_typescript5.default.isFunctionLike(node))
+                  return;
+                if (import_typescript5.default.isIdentifier(node) && node !== parent.name && node.getStart() > parent.end && this.declarationsOf(node).includes(parent) && completed(node, visited)) {
+                  found = true;
+                  return;
+                }
+                import_typescript5.default.forEachChild(node, findCompletion);
+              };
+              findCompletion(scope);
+              return found;
+            };
+            return completed(parentCall) && reachableCall(parentCall);
+          }
+        }
+      }
+      return this.callersOf(fn).some((call) => {
+        if (call.getSourceFile() !== scope.getSourceFile() || !contains(scope, call))
+          return false;
+        for (let parent = call.parent;parent && parent !== scope; parent = parent.parent) {
+          if (import_typescript5.default.isFunctionLike(parent))
+            return invoked(parent, next);
+        }
+        return true;
+      });
+    };
+    const isThis = (identifier) => references(identifier);
+    let indexedMutation = false;
+    const visit = (node) => {
+      if (import_typescript5.default.isFunctionLike(node) && !invoked(node))
+        return;
+      if (import_typescript5.default.isCallExpression(node) && import_typescript5.default.isPropertyAccessExpression(node.expression) && references(node.expression.expression) && /^(?:push|unshift|splice)$/.test(node.expression.name.text)) {
+        if (/^\d+$/.test(walk.project[0] ?? "")) {
+          indexedMutation = true;
+          this.markUnresolved(node, "dynamic-key", walk);
+          return;
+        }
+        if (probe)
+          return;
+        const args = node.expression.name.text === "splice" ? node.arguments.slice(2) : node.arguments;
+        const elementWalk = walk.project[0] === ARRAY_ELEMENT || walk.project[0] === FLATMAP_ELEMENT ? { ...walk, project: walk.project.slice(1) } : walk;
+        for (const argument of args)
+          this.value(argument, owner, elementWalk);
+      }
+      if (!probe && import_typescript5.default.isBinaryExpression(node) && import_typescript5.default.isIdentifier(node.left) && (isThis(node.left) || readVersions.has(node))) {
+        if (node.operatorToken.kind === import_typescript5.default.SyntaxKind.PlusEqualsToken)
+          this.value(node.right, owner, walk);
+        if (node.operatorToken.kind === import_typescript5.default.SyntaxKind.EqualsToken && node.right !== declaration.initializer)
+          this.value(node.right, owner, walk);
+      }
+      import_typescript5.default.forEachChild(node, visit);
+    };
+    visit(scope);
+    return indexedMutation;
+  }
+  parameterHasLocalWrites(parameter) {
+    const cached = this.locallyWrittenParameters.get(parameter);
+    if (cached !== undefined)
+      return cached;
+    let written = false;
+    const name = import_typescript5.default.isIdentifier(parameter.name) ? parameter.name.text : undefined;
+    const scope = enclosingScope2(parameter);
+    const isParameter = (expression) => import_typescript5.default.isIdentifier(expression) && expression.text === name && this.declarationsOf(expression).includes(parameter);
+    const visit = (node) => {
+      if (written)
+        return;
+      if (import_typescript5.default.isBinaryExpression(node) && [import_typescript5.default.SyntaxKind.EqualsToken, import_typescript5.default.SyntaxKind.PlusEqualsToken].includes(node.operatorToken.kind)) {
+        written = isParameter(node.left) || import_typescript5.default.isElementAccessExpression(node.left) && isParameter(node.left.expression);
+      } else if (import_typescript5.default.isCallExpression(node) && import_typescript5.default.isPropertyAccessExpression(node.expression) && /^(?:push|unshift|splice)$/.test(node.expression.name.text)) {
+        written = isParameter(node.expression.expression);
+      }
+      if (!written)
+        import_typescript5.default.forEachChild(node, visit);
+    };
+    if (scope)
+      visit(scope);
+    this.locallyWrittenParameters.set(parameter, written);
+    return written;
+  }
+  parameter(declaration, at, owner, walk) {
+    if (import_typescript5.default.isParameter(declaration) && import_typescript5.default.isIdentifier(declaration.name) && !walk.seen.has(declaration) && this.parameterHasLocalWrites(declaration)) {
+      const local = { ...walk, seen: new Set(walk.seen).add(declaration) };
+      this.assembly(declaration, owner, local, at);
+    }
+    const bound = walk.bindings.get(declaration);
+    if (bound) {
+      const project = [...bound.project ?? [], ...walk.project];
+      if (bound.rest) {
+        const each = project[0] === ARRAY_ELEMENT;
+        const index2 = /^\d+$/.test(project[0] ?? "") ? Number(project[0]) : undefined;
+        const values = index2 === undefined ? bound.rest : bound.rest.slice(index2, index2 + 1);
+        for (const value of values)
+          this.value(value, undefined, {
+            ...walk,
+            bindings: bound.bindings,
+            project: each || index2 !== undefined ? project.slice(1) : project
+          });
+      } else
+        this.value(bound.expr, undefined, { ...walk, bindings: bound.bindings, project });
+      return;
+    }
+    const parameter = import_typescript5.default.isParameter(declaration) ? declaration : parameterOf(declaration);
+    const fn = parameter?.parent;
+    if (!parameter || !fn || !import_typescript5.default.isFunctionLike(fn)) {
+      this.markUnresolved(at, "param-unbound", walk);
+      return;
+    }
+    if (walk.paramLevels >= this.maxParamLevels) {
+      this.markUnresolved(at, "depth-limit", walk);
+      return;
+    }
+    if (parameter.initializer)
+      this.value(parameter.initializer, owner, walk);
+    const callers = this.callersOf(fn);
+    if (callers.length === 0) {
+      if (!parameter.initializer)
+        this.markUnresolved(at, "param-unbound", walk);
+      return;
+    }
+    const index = fn.parameters.indexOf(parameter);
+    for (const caller of callers) {
+      const argument = caller.arguments[index];
+      if (!argument)
+        continue;
+      const next = this.step(flag(walk, "caller-argument"), caller, `argument ${index + 1} at a caller of ${functionName2(fn) ?? "the function"}`);
+      if (!next)
+        continue;
+      next.paramLevels += 1;
+      next.bindings = new Map;
+      if (import_typescript5.default.isBindingElement(declaration)) {
+        const field = bindingField(declaration);
+        const object = import_typescript5.default.isObjectLiteralExpression(unwrap2(argument)) ? unwrap2(argument) : undefined;
+        const property = object?.properties.find((p) => propertyName(p) === field);
+        if (property && import_typescript5.default.isPropertyAssignment(property))
+          this.value(property.initializer, undefined, next);
+        else if (property && import_typescript5.default.isShorthandPropertyAssignment(property))
+          this.identifier(property.name, undefined, next);
+        else if (!object && field)
+          this.value(argument, undefined, { ...next, project: [field, ...next.project] });
+        continue;
+      }
+      this.value(argument, undefined, next);
+    }
+  }
+  callersOf(fn) {
+    const cached = this.resolvedCallers.get(fn);
+    if (cached)
+      return cached;
+    const name = functionName2(fn);
+    if (!name)
+      return [];
+    this.indexCallers();
+    const names = [name, ...this.aliasesByName.get(name) ?? []];
+    const candidates = names.flatMap((alias) => this.callersByName.get(alias) ?? []);
+    const signatures = this.implementedSignatures(fn, name);
+    const callers = candidates.filter((call) => {
+      const callee = import_typescript5.default.isPropertyAccessExpression(call.expression) ? call.expression.name : call.expression;
+      const checker = this.context.checkerFor(this.relative(call.getSourceFile().fileName));
+      const members = checker && import_typescript5.default.isPropertyAccessExpression(call.expression) ? receiverClasses(call.expression.expression, checker).flatMap((cls) => cls.members.filter((member) => member.name?.getText() === name)) : [];
+      return [...this.declarationsOf(callee), ...members].some((declaration) => functionOf(declaration) === fn || declaration === fn || signatures.has(declaration) && !!checker && contextualReceiverMatches(call, fn, checker));
+    });
+    this.resolvedCallers.set(fn, callers);
+    return callers;
+  }
+  implementedSignatures(fn, name) {
+    const checker = this.context.checkerFor(this.relative(fn.getSourceFile().fileName));
+    return checker ? contextualSignatures(fn, name, checker) : new Set;
+  }
+  sourceFiles() {
+    const byName = new Map;
+    for (const program of this.context.programs) {
+      for (const file of program.getSourceFiles()) {
+        if (!this.isExternal(file) && !byName.has(file.fileName))
+          byName.set(file.fileName, file);
+      }
+    }
+    return [...byName.values()];
+  }
+  methodsNamed(name) {
+    if (!this.methodIndex) {
+      this.methodIndex = new Map;
+      for (const file of this.sourceFiles()) {
+        {
+          const visit = (node) => {
+            if (import_typescript5.default.isClassLike(node)) {
+              for (const member of node.members) {
+                if ((import_typescript5.default.isMethodDeclaration(member) || import_typescript5.default.isGetAccessorDeclaration(member)) && member.body && member.name && import_typescript5.default.isIdentifier(member.name)) {
+                  const list = this.methodIndex.get(member.name.text) ?? [];
+                  list.push(member);
+                  this.methodIndex.set(member.name.text, list);
+                }
+              }
+            }
+            import_typescript5.default.forEachChild(node, visit);
+          };
+          visit(file);
+        }
+      }
+    }
+    return this.methodIndex.get(name) ?? [];
+  }
+  indexCallers() {
+    if (this.callersIndexed)
+      return;
+    this.callersIndexed = true;
+    for (const file of this.sourceFiles()) {
+      {
+        const visit = (node) => {
+          if (import_typescript5.default.isCallExpression(node)) {
+            const callee = import_typescript5.default.isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression;
+            if (import_typescript5.default.isIdentifier(callee)) {
+              const list = this.callersByName.get(callee.text) ?? [];
+              list.push(node);
+              this.callersByName.set(callee.text, list);
+            }
+          }
+          if ((import_typescript5.default.isImportSpecifier(node) || import_typescript5.default.isExportSpecifier(node)) && node.propertyName && import_typescript5.default.isIdentifier(node.propertyName)) {
+            const aliases = this.aliasesByName.get(node.propertyName.text) ?? new Set;
+            aliases.add(node.name.text);
+            this.aliasesByName.set(node.propertyName.text, aliases);
+          }
+          import_typescript5.default.forEachChild(node, visit);
+        };
+        visit(file);
+      }
+    }
+  }
+  objectLiteralOf(node) {
+    let current = unwrap2(node);
+    for (let i = 0;i < 6; i++) {
+      if (import_typescript5.default.isObjectLiteralExpression(current) || import_typescript5.default.isArrayLiteralExpression(current))
+        return current;
+      const target = import_typescript5.default.isPropertyAccessExpression(current) ? current.name : current;
+      const declaration = this.declarationsOf(target)[0];
+      if (!declaration)
+        return;
+      const initializer = import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isPropertyAssignment(declaration) || import_typescript5.default.isPropertyDeclaration(declaration) ? declaration.initializer : undefined;
+      if (!initializer)
+        return;
+      current = unwrap2(initializer);
+    }
+    return;
+  }
+  declarationsOf(node) {
+    const path = this.relative(node.getSourceFile().fileName);
+    const checker = this.context.checkerFor(path);
+    if (!checker)
+      return [];
+    let symbol = import_typescript5.default.isShorthandPropertyAssignment(node.parent) && node.parent.name === node ? checker.getShorthandAssignmentValueSymbol(node.parent) : checker.getSymbolAtLocation(node);
+    if (!symbol)
+      return [];
+    if (symbol.flags & import_typescript5.default.SymbolFlags.Alias) {
+      try {
+        symbol = checker.getAliasedSymbol(symbol);
+      } catch {
+        return [];
+      }
+    }
+    return (symbol.declarations ?? []).filter((declaration) => !this.isExternal(declaration.getSourceFile()));
+  }
+  step(walk, node, reason) {
+    if (walk.depth + 1 > this.maxDepth) {
+      this.markUnresolved(node, "depth-limit", walk);
+      return;
+    }
+    const hop = { path: this.relative(node.getSourceFile().fileName), line: lineOf2(node), reason };
+    return { ...walk, depth: walk.depth + 1, hops: [...walk.hops, hop] };
+  }
+  text(at, text, owner, walk) {
+    if (walk.namedOnly && !owner?.name)
+      return;
+    const anchor = owner?.node ?? at;
+    const sf = anchor.getSourceFile();
+    const path = this.relative(sf.fileName);
+    if (TEST_SOURCE.test(path))
+      return;
+    if (LOCAL_ONLY_SITE.test(walk.site.path) && path !== walk.site.path)
+      return;
+    const line = lineOf2(anchor);
+    const id = `${path}:${line}`;
+    const key = owner ? `${path}@${anchor.getStart(sf)}` : id;
+    let ref = this.refs.get(key);
+    if (!ref) {
+      ref = {
+        id,
+        path,
+        line,
+        endLine: sf.getLineAndCharacterOfPosition(anchor.getEnd()).line + 1,
+        ...owner?.name ? { name: owner.name } : {},
+        kind: owner?.kind ?? "literal",
+        role: walk.role,
+        text: "",
+        callSiteIds: [],
+        hops: walk.hops,
+        via: [...walk.flags],
+        pieces: new Map,
+        start: anchor.getStart(sf),
+        ...owner ? { ownerNode: owner.node } : {}
+      };
+      this.refs.set(key, ref);
+    }
+    ref.start = Math.min(ref.start, anchor.getStart(sf));
+    if (!ref.callSiteIds.includes(walk.site.id))
+      ref.callSiteIds.push(walk.site.id);
+    ref.via = ref.via.filter((f) => walk.flags.includes(f));
+    ref.pieces.set(at.getStart(sf), text);
+  }
+  importedTextFile(identifier) {
+    const checker = this.context.checkerFor(this.relative(identifier.getSourceFile().fileName));
+    const clause = checker?.getSymbolAtLocation(identifier)?.declarations?.find(import_typescript5.default.isImportClause);
+    const statement = clause?.parent;
+    if (!statement || !import_typescript5.default.isStringLiteral(statement.moduleSpecifier))
+      return;
+    const spec = statement.moduleSpecifier.text;
+    if (!TEXT_MODULE.test(spec) || !spec.startsWith("."))
+      return;
+    return this.relative(resolvePath(dirname(statement.getSourceFile().fileName), spec.replace(/\?raw$/, "")));
+  }
+  preferModelRole(ref, walk) {
+    const toolPath = walk.role === "tool-result" || walk.role === "tool-description";
+    if (ref.role === "tool-result" && !toolPath) {
+      ref.role = walk.role;
+      ref.hops = walk.hops;
+      ref.via = [...walk.flags];
+    }
+    return ref.role === "tool-result" || walk.role !== "tool-result";
+  }
+  fileRef(path, walk) {
+    if (TEST_SOURCE.test(path))
+      return;
+    const id = path;
+    let ref = this.refs.get(id);
+    if (!ref) {
+      ref = { id, path, line: 1, endLine: 1, start: 0, kind: "file", role: walk.role, text: "", callSiteIds: [], hops: walk.hops, via: [...walk.flags], pieces: new Map };
+      this.refs.set(id, ref);
+    }
+    const counts = this.preferModelRole(ref, walk);
+    if (!ref.callSiteIds.includes(walk.site.id))
+      ref.callSiteIds.push(walk.site.id);
+    if (counts)
+      ref.via = ref.via.filter((f) => walk.flags.includes(f));
+  }
+  markUnresolved(node, reason, walk) {
+    const sf = node.getSourceFile();
+    const path = this.relative(sf.fileName);
+    const line = lineOf2(node);
+    const key = `${walk.site.id}|${path}:${line}|${reason}`;
+    if (this.unresolved.has(key))
+      return;
+    this.unresolved.set(key, {
+      callSiteId: walk.site.id,
+      role: walk.role,
+      path,
+      line,
+      expression: node.getText(sf).replace(/\s+/g, " ").slice(0, 120),
+      reason
+    });
+  }
+  columnOf(path, start) {
+    const sf = this.sourceFiles().find((file) => this.relative(file.fileName) === path);
+    return sf ? sf.getLineAndCharacterOfPosition(start).character + 1 : undefined;
+  }
+  where(node) {
+    return `${this.relative(node.getSourceFile().fileName)}:${lineOf2(node)}`;
+  }
+  relative(fileName) {
+    const rel = relative2(this.context.rootDir, fileName).replace(/\\/g, "/");
+    return rel.startsWith("..") ? fileName : rel;
+  }
+  isExternal(sf) {
+    return sf.isDeclarationFile || /(?:^|\/)node_modules\//.test(sf.fileName);
+  }
+}
+function nodeOf(ref, context) {
+  const node = context.nodeAt(ref);
+  return node && import_typescript5.default.isShorthandPropertyAssignment(node) ? node.name : node;
+}
+function toolName(definition) {
+  const name = stringField(definition, "name");
+  if (name)
+    return name;
+  const parent = definition.parent;
+  if (import_typescript5.default.isPropertyAssignment(parent))
+    return propertyName(parent);
+  if (import_typescript5.default.isCallExpression(parent) && import_typescript5.default.isPropertyAssignment(parent.parent))
+    return propertyName(parent.parent);
+  if (import_typescript5.default.isCallExpression(parent) && import_typescript5.default.isVariableDeclaration(parent.parent) && import_typescript5.default.isIdentifier(parent.parent.name))
+    return parent.parent.name.text;
+  return;
+}
+function flag(walk, f) {
+  return walk.flags.includes(f) ? walk : { ...walk, flags: [...walk.flags, f] };
+}
+function unwrap2(node) {
+  let current = node;
+  for (;; ) {
+    if (import_typescript5.default.isParenthesizedExpression(current) || import_typescript5.default.isAsExpression(current) || import_typescript5.default.isNonNullExpression(current) || import_typescript5.default.isAwaitExpression(current) || import_typescript5.default.isTypeAssertionExpression(current) || import_typescript5.default.isSatisfiesExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    return current;
+  }
+}
+function lineOf2(node) {
+  const sf = node.getSourceFile();
+  return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+}
+function propertyName(property) {
+  const name = property.name;
+  if (!name)
+    return;
+  if (import_typescript5.default.isIdentifier(name) || import_typescript5.default.isStringLiteral(name) || import_typescript5.default.isNumericLiteral(name) || import_typescript5.default.isPrivateIdentifier(name))
+    return name.text;
+  return;
+}
+function stringField(object, field) {
+  for (const property of object.properties) {
+    if (!import_typescript5.default.isPropertyAssignment(property) || propertyName(property) !== field)
+      continue;
+    const value = unwrap2(property.initializer);
+    if (import_typescript5.default.isStringLiteral(value) || import_typescript5.default.isNoSubstitutionTemplateLiteral(value))
+      return value.text;
+  }
+  return;
+}
+function declarationName(declaration) {
+  const name = declaration.name;
+  if (name && (import_typescript5.default.isIdentifier(name) || import_typescript5.default.isStringLiteral(name) || import_typescript5.default.isPrivateIdentifier(name)))
+    return name.text;
+  return;
+}
+function functionName2(fn) {
+  const own = declarationName(fn);
+  if (own)
+    return own;
+  const parent = fn.parent;
+  if (parent && (import_typescript5.default.isVariableDeclaration(parent) || import_typescript5.default.isPropertyAssignment(parent) || import_typescript5.default.isPropertyDeclaration(parent))) {
+    return declarationName(parent);
+  }
+  return;
+}
+function functionOf(declaration) {
+  if (import_typescript5.default.isFunctionDeclaration(declaration) || import_typescript5.default.isMethodDeclaration(declaration) || import_typescript5.default.isGetAccessorDeclaration(declaration) || import_typescript5.default.isArrowFunction(declaration) || import_typescript5.default.isFunctionExpression(declaration)) {
+    return declaration;
+  }
+  if ((import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isPropertyAssignment(declaration) || import_typescript5.default.isPropertyDeclaration(declaration)) && declaration.initializer) {
+    const init = unwrap2(declaration.initializer);
+    if (import_typescript5.default.isArrowFunction(init) || import_typescript5.default.isFunctionExpression(init))
+      return init;
+  }
+  return;
+}
+function hasValue(declaration) {
+  return !import_typescript5.default.isPropertySignature(declaration) && !import_typescript5.default.isMethodSignature(declaration) && !import_typescript5.default.isIndexSignatureDeclaration(declaration);
+}
+function ownerFor(declaration, name, outer) {
+  if (outer?.kind === "builder" && outer.node.getSourceFile() === declaration.getSourceFile() && contains(outer.node, declaration))
+    return outer;
+  return { node: declaration, name, kind: "literal" };
+}
+function contains(outer, inner) {
+  return inner.getStart() >= outer.getStart() && inner.getEnd() <= outer.getEnd();
+}
+function enclosingScope2(declaration) {
+  if (import_typescript5.default.isParameter(declaration) && import_typescript5.default.isFunctionLike(declaration.parent) && "body" in declaration.parent)
+    return declaration.parent.body;
+  for (let node = declaration.parent;node; node = node.parent) {
+    if (import_typescript5.default.isBlock(node) || import_typescript5.default.isSourceFile(node) || import_typescript5.default.isModuleBlock(node))
+      return node;
+  }
+  return;
+}
+function isParameterBinding(element) {
+  return Boolean(parameterOf(element));
+}
+function parameterOf(element) {
+  for (let node = element.parent;node; node = node.parent) {
+    if (import_typescript5.default.isParameter(node))
+      return node;
+    if (!import_typescript5.default.isBindingElement(node) && !import_typescript5.default.isObjectBindingPattern(node) && !import_typescript5.default.isArrayBindingPattern(node))
+      return;
+  }
+  return;
+}
+function bindingField(element) {
+  const name = element.propertyName ?? element.name;
+  return import_typescript5.default.isIdentifier(name) || import_typescript5.default.isStringLiteral(name) ? name.text : undefined;
+}
+function bindParameters(fn, args, outer, into) {
+  fn.parameters.forEach((parameter, index) => {
+    const argument = args[index];
+    if (parameter.dotDotDotToken && import_typescript5.default.isIdentifier(parameter.name)) {
+      into.set(parameter, { expr: argument ?? parameter.name, bindings: outer, rest: args.slice(index) });
+      return;
+    }
+    if (!argument)
+      return;
+    if (import_typescript5.default.isIdentifier(parameter.name)) {
+      into.set(parameter, { expr: argument, bindings: outer });
+      return;
+    }
+    if (import_typescript5.default.isObjectBindingPattern(parameter.name)) {
+      const object = unwrap2(argument);
+      for (const element of parameter.name.elements) {
+        const field = bindingField(element);
+        if (!import_typescript5.default.isObjectLiteralExpression(object)) {
+          if (field)
+            into.set(element, { expr: argument, bindings: outer, project: [field] });
+          continue;
+        }
+        const property = object.properties.find((p) => propertyName(p) === field);
+        if (property && import_typescript5.default.isPropertyAssignment(property))
+          into.set(element, { expr: property.initializer, bindings: outer });
+        else if (property && import_typescript5.default.isShorthandPropertyAssignment(property))
+          into.set(element, { expr: property.name, bindings: outer });
+      }
+    }
+  });
+}
+
+export { SVELTE_VIRTUAL_SUFFIX, svelteVirtualName, relPath, lineOf, colOf, unwrap, propertyNameText, isFunctionLike, enclosingFunction, functionName, enclosingClass, className, returnExpressions, importOrigin, resolvedSymbol, valueDeclaration, propertyValue, valueChildren, ValueTracer, resolvedFunction, selectKey, allValues, renderings, queryParamValue, URL_MODEL_KEY, providerModelCall, frameworkBaseOf, createFrameworkMemo, CALL_SINKS, registerCallSink, classSinks, registerClassSink, CallIndex, RepoCallIndex, readsAsInstructions, isDataWrapper, hasDirective, toolResultIsPrompt, isInstructionDescription, toolDefinitionSite, resolvePromptArguments };