@rasputin-ai/node 0.5.0-alpha.8 → 0.5.0

package/dist/instrument/bun.js

@@ -3,7 +3,7 @@ import { plugin } from "bun";
 
 // src/auto-instrumentation/bun-plugin.ts
 import { readFile } from "node:fs/promises";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
 import { resolve } from "node:path";
@@ -17,6 +17,16 @@ import {
   runtimeFunctionId,
   sourceLocatorFromFile
 } from "@rasputin-ai/core";
+var withPreBodyParameterEvaluation = (plan) => [
+  plan[0],
+  plan[1],
+  plan[2],
+  plan[3],
+  plan[4],
+  plan[5],
+  plan[6],
+  1
+];
 var encodeFunctionPlan = (source) => {
   const locator = sourceLocatorFromFile(source.filePath);
   const definition = {
@@ -39,19 +49,26 @@ var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
 var getRegistry = () => {
   const existing = Reflect.get(globalThis, registrySymbol);
   if (existing?.__rasputinManifestRegistry && existing.files instanceof Map && typeof existing.generation === "number" && typeof existing.uploadedGeneration === "number") {
-    return existing;
+    const registry2 = existing;
+    if (typeof registry2.alreadyInstrumented !== "number") registry2.alreadyInstrumented = 0;
+    return registry2;
   }
   const registry = {
     __rasputinManifestRegistry: true,
     files: /* @__PURE__ */ new Map(),
     generation: 0,
-    uploadedGeneration: 0
+    uploadedGeneration: 0,
+    alreadyInstrumented: 0
   };
   Reflect.set(globalThis, registrySymbol, registry);
   return registry;
 };
 var recordInstrumentationManifestDelta = (filePath, delta) => {
   const registry = getRegistry();
+  if (delta.alreadyInstrumented) {
+    registry.alreadyInstrumented += 1;
+    return;
+  }
   registry.files.set(resolve(filePath), delta);
   registry.generation += 1;
   registry.onDirty?.();
@@ -86,657 +103,74 @@ var isApplicationSource = (filePath, options = {}) => {
   return true;
 };
 
-// src/auto-instrumentation/transform-source.ts
-import { resolve as resolve3 } from "node:path";
-import ts3 from "typescript";
-
-// src/derivation/analyze-function.ts
-import ts from "typescript";
-
-// src/derivation/build-dependency-graph.ts
-var buildDependencyGraph = (functions, edges) => {
-  const names = new Set(functions.map((fn) => fn.name));
-  const localEdges = edges.filter((edge) => names.has(edge.calleeName));
-  const calleesByCaller = /* @__PURE__ */ new Map();
-  for (const edge of localEdges) {
-    const existing = calleesByCaller.get(edge.callerFunctionId) ?? [];
-    existing.push(edge.calleeName);
-    calleesByCaller.set(edge.callerFunctionId, existing);
-  }
-  return {
-    functions: functions.map((fn) => fn.functionId),
-    edges: localEdges,
-    calleesByCaller
-  };
-};
-var topologicalFunctionOrder = (functions, graph) => {
-  const idByName = new Map(functions.map((fn) => [fn.name, fn.functionId]));
-  const remainingCallees = new Map(
-    functions.map((fn) => {
-      const unique = new Set(
-        (graph.calleesByCaller.get(fn.functionId) ?? []).map((name) => idByName.get(name)).filter((id) => Boolean(id) && id !== fn.functionId)
-      );
-      return [fn.functionId, unique.size];
-    })
-  );
-  const callersOf = /* @__PURE__ */ new Map();
-  for (const fn of functions) {
-    for (const calleeName of graph.calleesByCaller.get(fn.functionId) ?? []) {
-      const calleeId = idByName.get(calleeName);
-      if (!calleeId || calleeId === fn.functionId) continue;
-      const callers = callersOf.get(calleeId) ?? [];
-      callers.push(fn.functionId);
-      callersOf.set(calleeId, callers);
-    }
-  }
-  const queue = functions.filter((fn) => (remainingCallees.get(fn.functionId) ?? 0) === 0).map((fn) => fn.functionId);
-  const ordered = [];
-  const queued = new Set(queue);
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current === void 0) break;
-    ordered.push(current);
-    for (const caller of callersOf.get(current) ?? []) {
-      const next = (remainingCallees.get(caller) ?? 0) - 1;
-      remainingCallees.set(caller, next);
-      if (next === 0 && !queued.has(caller)) {
-        queued.add(caller);
-        queue.push(caller);
-      }
-    }
-  }
-  for (const fn of functions) {
-    if (!queued.has(fn.functionId)) ordered.push(fn.functionId);
-  }
-  return ordered;
-};
-
-// src/derivation/derivation-ir.ts
-var DerivationIrBuilder = class {
-  expressions = [];
-  nextId = 0;
-  constValue(value) {
-    return this.add({ id: this.nextId++, kind: "const", value });
-  }
-  param(index) {
-    return this.add({ id: this.nextId++, kind: "param", index });
-  }
-  root(rootId) {
-    return this.add({ id: this.nextId++, kind: "root", rootId });
-  }
-  alias(from) {
-    return this.add({ id: this.nextId++, kind: "alias", from });
-  }
-  binary(op, left, right, guard) {
-    return this.add({ id: this.nextId++, kind: "binary", op, left, right, guard });
-  }
-  unary(op, operand) {
-    return this.add({ id: this.nextId++, kind: "unary", op, operand });
-  }
-  logical(op, left, right) {
-    return this.add({ id: this.nextId++, kind: "logical", op, left, right });
-  }
-  cond(test, consequent, alternate) {
-    return this.add({ id: this.nextId++, kind: "cond", test, consequent, alternate });
-  }
-  object(properties) {
-    return this.add({ id: this.nextId++, kind: "object", properties });
-  }
-  array(elements) {
-    return this.add({ id: this.nextId++, kind: "array", elements });
-  }
-  prop(object, key) {
-    return this.add({ id: this.nextId++, kind: "prop", object, key });
-  }
-  index(array, index) {
-    return this.add({ id: this.nextId++, kind: "index", array, index });
-  }
-  pureCall(calleeFunctionId, args) {
-    return this.add({ id: this.nextId++, kind: "pure_call", calleeFunctionId, args });
-  }
-  template(parts) {
-    return this.add({ id: this.nextId++, kind: "template", parts });
-  }
-  add(expression) {
-    this.expressions.push(expression);
-    return expression.id;
-  }
-};
-var emptyPlan = (functionId) => ({
-  planId: `dp_${functionId}`,
-  functionId,
-  expressions: [],
-  variables: [],
-  captureBoundaries: [],
-  controlFacts: []
-});
+// src/auto-instrumentation/transform-disk-cache.ts
+import { createHash } from "node:crypto";
+import {
+  chmodSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
 
-// src/derivation/derivation-proof.ts
-var functionIsExact = (plan) => plan.fallbackReason === void 0 && plan.captureBoundaries.length === 0 && plan.controlFacts.length === 0;
+// src/sdk-meta.ts
+var SDK_VERSION = "0.5.0";
 
-// src/derivation/analyze-function.ts
-var loc = (node, sourceFile) => {
-  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-  return { line: position.line + 1, column: position.character + 1 };
-};
-var lookup = (ctx, name) => {
-  for (let index = ctx.scopes.length - 1; index >= 0; index--) {
-    const binding = ctx.scopes[index]?.get(name);
-    if (binding) return binding;
-  }
-  return void 0;
-};
-var fallback = (ctx, reason) => {
-  ctx.fallback ??= reason;
-  return { expressionId: ctx.ir.constValue({ type: "undefined" }), shape: "unknown" };
-};
-var capture = (ctx, node, reason) => {
-  const rootId = ctx.nextRootId.value++;
-  const position = loc(node, ctx.sourceFile);
-  const expressionId = ctx.ir.root(rootId);
-  ctx.captureWraps.push({
-    rootId,
-    reason,
-    start: node.getStart(ctx.sourceFile),
-    end: node.end,
-    line: position.line,
-    column: position.column,
-    expressionId
-  });
-  return { expressionId, shape: "unknown", captured: true };
-};
-var binaryOp = (kind) => {
-  switch (kind) {
-    case ts.SyntaxKind.PlusToken:
-      return "add";
-    case ts.SyntaxKind.MinusToken:
-      return "sub";
-    case ts.SyntaxKind.AsteriskToken:
-      return "mul";
-    case ts.SyntaxKind.SlashToken:
-      return "div";
-    case ts.SyntaxKind.PercentToken:
-      return "mod";
-    case ts.SyntaxKind.EqualsEqualsToken:
-      return "eq";
-    case ts.SyntaxKind.ExclamationEqualsToken:
-      return "neq";
-    case ts.SyntaxKind.EqualsEqualsEqualsToken:
-      return "seq";
-    case ts.SyntaxKind.ExclamationEqualsEqualsToken:
-      return "sneq";
-    case ts.SyntaxKind.LessThanToken:
-      return "lt";
-    case ts.SyntaxKind.LessThanEqualsToken:
-      return "lte";
-    case ts.SyntaxKind.GreaterThanToken:
-      return "gt";
-    case ts.SyntaxKind.GreaterThanEqualsToken:
-      return "gte";
-    default:
-      return void 0;
-  }
-};
-var isNumericBinaryOp = (op) => op === "add" || op === "sub" || op === "mul" || op === "div" || op === "mod";
-var unwrapParens = (node) => {
-  while (ts.isParenthesizedExpression(node)) node = node.expression;
-  return node;
-};
-var numericLiteralValue = (node) => {
-  const value = Number(node.text);
-  return { type: "number", value };
-};
-var analyzeExpression = (ctx, node) => {
-  if (ctx.fallback) return fallback(ctx, ctx.fallback);
-  if (ts.isParenthesizedExpression(node)) return analyzeExpression(ctx, node.expression);
-  if (ts.isAsExpression(node) || ts.isNonNullExpression(node)) {
-    return analyzeExpression(ctx, node.expression);
-  }
-  if (node.kind === ts.SyntaxKind.TypeAssertionExpression) {
-    return analyzeExpression(ctx, node.expression);
-  }
-  if (ts.isSatisfiesExpression(node)) return analyzeExpression(ctx, node.expression);
-  if (node.kind === ts.SyntaxKind.NullKeyword) {
-    return { expressionId: ctx.ir.constValue({ type: "null" }), shape: "primitive" };
-  }
-  if (node.kind === ts.SyntaxKind.TrueKeyword) {
-    return {
-      expressionId: ctx.ir.constValue({ type: "boolean", value: true }),
-      shape: "primitive"
-    };
-  }
-  if (node.kind === ts.SyntaxKind.FalseKeyword) {
-    return {
-      expressionId: ctx.ir.constValue({ type: "boolean", value: false }),
-      shape: "primitive"
-    };
-  }
-  if (ts.isNumericLiteral(node)) {
-    return { expressionId: ctx.ir.constValue(numericLiteralValue(node)), shape: "primitive" };
-  }
-  if (ts.isPrefixUnaryExpression(node) && ts.isNumericLiteral(node.operand) && node.operator === ts.SyntaxKind.MinusToken) {
-    const value = -Number(node.operand.text);
-    return {
-      expressionId: ctx.ir.constValue(
-        Object.is(value, -0) ? { type: "number", value: 0, negativeZero: true } : { type: "number", value }
-      ),
-      shape: "primitive"
-    };
-  }
-  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-    return {
-      expressionId: ctx.ir.constValue({ type: "string", value: node.text }),
-      shape: "primitive"
-    };
-  }
-  if (ts.isBigIntLiteral(node)) {
-    return {
-      expressionId: ctx.ir.constValue({ type: "bigint", value: node.text.replace(/n$/, "") }),
-      shape: "primitive"
-    };
-  }
-  if (ts.isIdentifier(node)) {
-    if (node.text === "undefined") {
-      return { expressionId: ctx.ir.constValue({ type: "undefined" }), shape: "primitive" };
-    }
-    const binding = lookup(ctx, node.text);
-    if (!binding) return capture(ctx, node, "external_state");
-    if (binding.mutable) return capture(ctx, node, "mutable_object");
-    return {
-      expressionId: ctx.ir.alias(binding.expressionId),
-      shape: binding.shape
-    };
-  }
-  if (ts.isTemplateExpression(node)) {
-    const parts = [
-      { kind: "lit", value: node.head.text }
-    ];
-    for (const span of node.templateSpans) {
-      const nested = analyzeExpression(ctx, span.expression);
-      if (nested.shape !== "primitive" && !nested.captured) {
-        return capture(ctx, node, "unsupported_expression");
-      }
-      parts.push({ kind: "expr", expressionId: nested.expressionId });
-      parts.push({ kind: "lit", value: span.literal.text });
-    }
-    return { expressionId: ctx.ir.template(parts), shape: "primitive" };
-  }
-  if (ts.isArrayLiteralExpression(node)) {
-    if (node.elements.some((element) => ts.isSpreadElement(element))) {
-      return capture(ctx, node, "unsupported_expression");
-    }
-    const elements = node.elements.map((element) => {
-      if (ts.isOmittedExpression(element)) return { kind: "hole" };
-      return analyzeExpression(ctx, element).expressionId;
-    });
-    return { expressionId: ctx.ir.array(elements), shape: "array" };
-  }
-  if (ts.isObjectLiteralExpression(node)) {
-    const properties = [];
-    for (const property of node.properties) {
-      if (ts.isShorthandPropertyAssignment(property)) {
-        const nested = analyzeExpression(ctx, property.name);
-        if (nested.captured) {
-          const wrap = ctx.captureWraps.find(
-            (candidate) => candidate.expressionId === nested.expressionId
-          );
-          if (wrap) wrap.shorthandPropertyName = property.name.text;
-        }
-        properties.push({ key: property.name.text, value: nested.expressionId });
-        continue;
-      }
-      if (!ts.isPropertyAssignment(property)) {
-        return capture(ctx, node, "unsupported_expression");
-      }
-      if (ts.isPrivateIdentifier(property.name) || ts.isComputedPropertyName(property.name)) {
-        return capture(ctx, node, "unsupported_expression");
-      }
-      const key = ts.isIdentifier(property.name) ? property.name.text : ts.isStringLiteral(property.name) || ts.isNumericLiteral(property.name) ? property.name.text : void 0;
-      if (key === void 0) return capture(ctx, node, "unsupported_expression");
-      properties.push({ key, value: analyzeExpression(ctx, property.initializer).expressionId });
-    }
-    return { expressionId: ctx.ir.object(properties), shape: "object" };
-  }
-  if (ts.isPropertyAccessExpression(node)) {
-    if (node.questionDotToken) return capture(ctx, node, "unknown_property");
-    const object = analyzeExpression(ctx, node.expression);
-    if (object.shape === "object" && ts.isIdentifier(node.name)) {
-      return { expressionId: ctx.ir.prop(object.expressionId, node.name.text), shape: "unknown" };
-    }
-    return capture(ctx, node, "unknown_property");
-  }
-  if (ts.isElementAccessExpression(node)) {
-    if (node.questionDotToken) return capture(ctx, node, "unknown_property");
-    const array = analyzeExpression(ctx, node.expression);
-    if (array.shape === "array" && ts.isNumericLiteral(node.argumentExpression)) {
-      return {
-        expressionId: ctx.ir.index(array.expressionId, Number(node.argumentExpression.text)),
-        shape: "unknown"
-      };
-    }
-    return capture(ctx, node, "unknown_property");
-  }
-  if (ts.isCallExpression(node)) {
-    if (node.questionDotToken || node.typeArguments?.length) {
-      return capture(ctx, node, "unsupported_expression");
-    }
-    if (!ts.isIdentifier(node.expression)) return capture(ctx, node, "dynamic_callee");
-    const calleeName = node.expression.text;
-    if (lookup(ctx, calleeName)) return capture(ctx, node, "opaque_call");
-    const provenId = ctx.provenExact.get(calleeName);
-    ctx.callEdges.push({
-      callerFunctionId: ctx.functionId,
-      calleeName,
-      ...provenId ? { calleeFunctionId: provenId } : {}
-    });
-    if (!provenId) return capture(ctx, node, "opaque_call");
-    const args = node.arguments.map((argument) => {
-      if (ts.isSpreadElement(argument)) return void 0;
-      return analyzeExpression(ctx, argument).expressionId;
-    });
-    if (args.some((argument) => argument === void 0))
-      return capture(ctx, node, "unsupported_expression");
-    return {
-      expressionId: ctx.ir.pureCall(
-        provenId,
-        args.filter((id) => id !== void 0)
-      ),
-      shape: "unknown"
-    };
-  }
-  if (ts.isNewExpression(node) || ts.isAwaitExpression(node) || ts.isYieldExpression(node)) {
-    return capture(
-      ctx,
-      node,
-      node.kind === ts.SyntaxKind.AwaitExpression ? "nondeterministic" : "unsupported_expression"
-    );
-  }
-  if (ts.isConditionalExpression(node)) {
-    const test = analyzeExpression(ctx, node.condition);
-    const consequent = analyzeExpression(ctx, node.whenTrue);
-    const alternate = analyzeExpression(ctx, node.whenFalse);
-    return {
-      expressionId: ctx.ir.cond(test.expressionId, consequent.expressionId, alternate.expressionId),
-      shape: consequent.shape === alternate.shape ? consequent.shape : "unknown"
-    };
-  }
-  if (ts.isBinaryExpression(node)) {
-    if (node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-      ctx.fallback ??= "mutable_state";
-      return capture(ctx, node, "mutable_object");
-    }
-    if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === ts.SyntaxKind.BarBarToken || node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
-      const left2 = analyzeExpression(ctx, node.left);
-      const right2 = analyzeExpression(ctx, node.right);
-      const op2 = node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ? "and" : node.operatorToken.kind === ts.SyntaxKind.BarBarToken ? "or" : "nullish";
-      return {
-        expressionId: ctx.ir.logical(op2, left2.expressionId, right2.expressionId),
-        shape: "unknown"
-      };
-    }
-    const op = binaryOp(node.operatorToken.kind);
-    if (!op) return capture(ctx, node, "unsupported_expression");
-    if (!ts.isExpression(node.left)) return capture(ctx, node, "unsupported_expression");
-    const left = analyzeExpression(ctx, node.left);
-    const right = analyzeExpression(ctx, node.right);
-    const numeric = isNumericBinaryOp(op);
-    const expressionId = ctx.ir.binary(
-      op,
-      left.expressionId,
-      right.expressionId,
-      numeric ? "numeric" : "primitive"
-    );
-    if (numeric && (left.captured || right.captured || left.shape !== "primitive" || right.shape !== "primitive")) {
-      ctx.hasCoercionGuard = true;
-      const fallbackRootId = ctx.nextRootId.value++;
-      ctx.guardWraps.push({
-        fallbackRootId,
-        start: node.getStart(ctx.sourceFile),
-        end: node.end,
-        op
-      });
-    }
-    return { expressionId, shape: "primitive" };
-  }
-  if (ts.isPrefixUnaryExpression(node)) {
-    const operand = analyzeExpression(ctx, node.operand);
-    if (node.operator === ts.SyntaxKind.ExclamationToken) {
-      return { expressionId: ctx.ir.unary("not", operand.expressionId), shape: "primitive" };
-    }
-    if (node.operator === ts.SyntaxKind.PlusToken || node.operator === ts.SyntaxKind.MinusToken) {
-      if (operand.captured || operand.shape !== "primitive") ctx.hasCoercionGuard = true;
-      return {
-        expressionId: ctx.ir.unary(
-          node.operator === ts.SyntaxKind.MinusToken ? "minus" : "plus",
-          operand.expressionId
-        ),
-        shape: "primitive"
-      };
-    }
-    return capture(ctx, node, "unsupported_expression");
-  }
-  if (ts.isTypeOfExpression(node)) {
-    const operand = unwrapParens(node.expression);
-    if (ts.isIdentifier(operand) && operand.text !== "undefined" && !lookup(ctx, operand.text)) {
-      return capture(ctx, node, "external_state");
-    }
-    const inner = analyzeExpression(ctx, node.expression);
-    return { expressionId: ctx.ir.unary("typeof", inner.expressionId), shape: "primitive" };
-  }
-  return capture(ctx, node, "unsupported_expression");
-};
-var bindIdentifier = (ctx, name, result, declaration) => {
-  const current = ctx.scopes[ctx.scopes.length - 1];
-  current?.set(name.text, {
-    expressionId: result.expressionId,
-    shape: result.shape,
-    mutable: false
-  });
-  const position = loc(name, ctx.sourceFile);
-  const available = loc(declaration, ctx.sourceFile);
-  ctx.variables.push({
-    id: ctx.nextVariableId.value++,
-    name: name.text,
-    functionId: ctx.functionId,
-    scopeId: `${ctx.functionId}:${ctx.scopes.length}`,
-    line: position.line,
-    column: position.column,
-    assignmentId: ctx.nextAssignmentId.value++,
-    expressionId: result.expressionId,
-    availableAtLine: available.line,
-    availableAtColumn: available.column
-  });
-};
-var analyzeStatement = (ctx, node) => {
-  if (ctx.fallback) return;
-  if (ts.isEmptyStatement(node) || ts.isDebuggerStatement(node)) return;
-  if (ts.isBlock(node)) {
-    ctx.scopes.push(/* @__PURE__ */ new Map());
-    for (const statement of node.statements) analyzeStatement(ctx, statement);
-    ctx.scopes.pop();
-    return;
-  }
-  if (ts.isReturnStatement(node)) {
-    if (!node.expression) {
-      ctx.returnExpressionId = ctx.ir.constValue({ type: "undefined" });
-      return;
-    }
-    ctx.returnExpressionId = analyzeExpression(ctx, node.expression).expressionId;
-    return;
-  }
-  if (ts.isVariableStatement(node)) {
-    if (node.declarationList.flags & ts.NodeFlags.Using) {
-      fallback(ctx, "side_effect");
-      return;
-    }
-    for (const declaration of node.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
-        fallback(ctx, "unsupported_expression");
-        return;
-      }
-      const result = analyzeExpression(ctx, declaration.initializer);
-      bindIdentifier(ctx, declaration.name, result, declaration);
-    }
-    return;
-  }
-  if (ts.isExpressionStatement(node)) {
-    analyzeExpression(ctx, node.expression);
-    return;
-  }
-  if (ts.isThrowStatement(node)) {
-    ctx.hasThrow = true;
-    analyzeExpression(ctx, node.expression);
-    return;
-  }
-  if (ts.isIfStatement(node) || ts.isSwitchStatement(node) || ts.isTryStatement(node)) {
-    fallback(ctx, "unsupported_expression");
-    return;
-  }
-  if (ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node) || ts.isWhileStatement(node) || ts.isDoStatement(node)) {
-    fallback(ctx, "has_loop");
-    return;
-  }
-  fallback(ctx, "unsupported_expression");
-};
-var bindParams = (ctx, node) => {
-  let index = 0;
-  for (const parameter of node.parameters) {
-    if (ts.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
-    if (!ts.isIdentifier(parameter.name) || parameter.dotDotDotToken) {
-      fallback(ctx, "unsupported_expression");
-      index++;
-      continue;
-    }
-    const expressionId = ctx.ir.param(index);
-    ctx.identifierParams.push(parameter.name.text);
-    bindIdentifier(ctx, parameter.name, { expressionId, shape: "unknown" }, parameter);
-    index++;
-  }
+// src/auto-instrumentation/source-map-locations.ts
+import { readFileSync } from "node:fs";
+import { dirname, isAbsolute as isAbsolute2, join, resolve as resolve3 } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { LEAST_UPPER_BOUND, originalPositionFor, TraceMap } from "@jridgewell/trace-mapping";
+var sourceMapComment = /(?:\/\/[#@][ \t]*sourceMappingURL=([^\s'"]+)|\/\*[#@][ \t]*sourceMappingURL=([^\s*'"]+)[ \t]*\*\/)\s*$/;
+var decodeDataUrl = (url) => {
+  const base64 = /^data:application\/json(?:;charset=[^;,]+)?;base64,(.+)$/i.exec(url);
+  if (base64?.[1]) return Buffer.from(base64[1], "base64").toString("utf8");
+  const raw = /^data:application\/json(?:;charset=[^;,]+)?,(.+)$/i.exec(url);
+  return raw?.[1] ? decodeURIComponent(raw[1]) : void 0;
 };
-var analyzeOne = (node, functionId, name, sourceFile, provenExact) => {
-  const ctx = {
-    sourceFile,
-    functionId,
-    name,
-    ir: new DerivationIrBuilder(),
-    variables: [],
-    captureWraps: [],
-    guardWraps: [],
-    callEdges: [],
-    scopes: [/* @__PURE__ */ new Map()],
-    nextRootId: { value: 0 },
-    nextVariableId: { value: 0 },
-    nextAssignmentId: { value: 0 },
-    hasThrow: false,
-    hasCoercionGuard: false,
-    provenExact,
-    identifierParams: []
-  };
-  if (node.asteriskToken || node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword)) {
-    ctx.fallback = "async";
-  } else {
-    bindParams(ctx, node);
-    if (ts.isBlock(node.body)) {
-      for (const statement of node.body.statements) analyzeStatement(ctx, statement);
-    } else {
-      ctx.returnExpressionId = analyzeExpression(ctx, node.body).expressionId;
-    }
-  }
-  const plan = {
-    ...emptyPlan(functionId),
-    expressions: ctx.ir.expressions,
-    variables: ctx.variables,
-    captureBoundaries: ctx.captureWraps.map((wrap) => ({
-      id: wrap.rootId,
-      reason: wrap.reason,
-      expressionId: wrap.expressionId,
-      line: wrap.line,
-      column: wrap.column
-    })),
-    controlFacts: [],
-    ...ctx.returnExpressionId === void 0 ? {} : { returnExpressionId: ctx.returnExpressionId },
-    ...ctx.fallback ? { fallbackReason: ctx.fallback } : {}
-  };
+var sourceMapFor = (generatedPath, source) => {
+  const match = sourceMapComment.exec(source);
+  const reference = match?.[1] ?? match?.[2];
+  if (reference?.startsWith("data:")) {
+    const payload = decodeDataUrl(reference);
+    return payload ? { payload, mapUrl: pathToFileURL(generatedPath).href } : void 0;
+  }
+  const mapPath = reference ? resolve3(dirname(generatedPath), reference) : `${generatedPath}.map`;
   return {
-    functionId,
-    name,
-    node,
-    plan,
-    captureWraps: ctx.fallback ? [] : ctx.captureWraps,
-    guardWraps: ctx.fallback ? [] : ctx.guardWraps,
-    callEdges: ctx.callEdges,
-    hasThrow: ctx.hasThrow,
-    hasCoercionGuard: ctx.hasCoercionGuard
+    payload: readFileSync(mapPath, "utf8"),
+    mapUrl: pathToFileURL(mapPath).href
   };
 };
-var analyzeModuleFunctions = (sourceFile, targets) => {
-  const nameCounts = /* @__PURE__ */ new Map();
-  for (const target of targets) {
-    nameCounts.set(target.name, (nameCounts.get(target.name) ?? 0) + 1);
-  }
-  const firstPass = targets.map(
-    (target) => analyzeOne(target.node, target.functionId, target.name, sourceFile, /* @__PURE__ */ new Map())
-  );
-  const graph = buildDependencyGraph(
-    firstPass.map((fn) => ({ functionId: fn.functionId, name: fn.name })),
-    firstPass.flatMap((fn) => fn.callEdges)
-  );
-  const order = topologicalFunctionOrder(
-    firstPass.map((fn) => ({ functionId: fn.functionId, name: fn.name })),
-    graph
-  );
-  const byId = new Map(targets.map((target) => [target.functionId, target]));
-  const provenExact = /* @__PURE__ */ new Map();
-  const analyzed = [];
-  for (const functionId of order) {
-    const target = byId.get(functionId);
-    if (!target) continue;
-    const result = analyzeOne(target.node, target.functionId, target.name, sourceFile, provenExact);
-    if (functionIsExact(result.plan) && nameCounts.get(result.name) === 1) {
-      provenExact.set(result.name, result.functionId);
-    }
-    analyzed.push(result);
-  }
-  const remaining = targets.filter(
-    (target) => !analyzed.some((fn) => fn.functionId === target.functionId)
-  );
-  for (const target of remaining) {
-    analyzed.push(analyzeOne(target.node, target.functionId, target.name, sourceFile, provenExact));
+var sourceMapPayloadForCache = (generatedPath, source) => {
+  try {
+    return sourceMapFor(generatedPath, source)?.payload ?? "";
+  } catch {
+    return "";
   }
-  return analyzed;
 };
 
-// src/derivation/emit-capture-plan.ts
-var captureWrapEdits = (wraps, capName) => {
-  const edits = [];
-  let order = 0;
-  for (const wrap of wraps) {
-    edits.push({
-      position: wrap.start,
-      text: `${wrap.shorthandPropertyName ? `${wrap.shorthandPropertyName}:` : ""}${capName}(${wrap.rootId},`,
-      order: order++
-    });
-    edits.push({
-      position: wrap.end,
-      text: ")",
-      order: order++
-    });
-  }
-  return edits;
-};
+// src/auto-instrumentation/transform-source.ts
+import { basename, resolve as resolve4 } from "node:path";
+import { originalPositionFor as originalPositionFor2, TraceMap as TraceMap2 } from "@jridgewell/trace-mapping";
+import ts6 from "typescript";
 
 // src/execution-recorder/automatic-runtime.ts
-var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v3";
 var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
 
 // src/auto-instrumentation/collect-instrumentation-delta.ts
-import ts2 from "typescript";
+import ts from "typescript";
 var paramBindingFromName = (name, sourceFile) => {
-  if (ts2.isIdentifier(name)) return { kind: "identifier", name: name.text };
-  if (ts2.isArrayBindingPattern(name)) {
+  if (ts.isIdentifier(name)) return { kind: "identifier", name: name.text };
+  if (ts.isArrayBindingPattern(name)) {
     const elements = name.elements.map(
       (element) => {
-        if (ts2.isOmittedExpression(element)) return { kind: "omitted" };
+        if (ts.isOmittedExpression(element)) return { kind: "omitted" };
         const binding = paramBindingFromName(element.name, sourceFile);
         if (element.dotDotDotToken) return { kind: "rest", binding };
         return binding;
@@ -746,7 +180,7 @@ var paramBindingFromName = (name, sourceFile) => {
   }
   const properties = name.elements.map((element) => {
     const binding = paramBindingFromName(element.name, sourceFile);
-    const key = element.propertyName ? element.propertyName.getText(sourceFile).replace(/^['"]|['"]$/g, "") : ts2.isIdentifier(element.name) ? element.name.text : element.name.getText(sourceFile);
+    const key = element.propertyName ? element.propertyName.getText(sourceFile).replace(/^['"]|['"]$/g, "") : ts.isIdentifier(element.name) ? element.name.text : element.name.getText(sourceFile);
     if (element.dotDotDotToken) {
       const rest = { kind: "rest", binding };
       return { key, binding: rest };
@@ -758,7 +192,7 @@ var paramBindingFromName = (name, sourceFile) => {
 var collectFunctionParams = (node, sourceFile) => {
   const params = [];
   for (const parameter of node.parameters) {
-    if (ts2.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    if (ts.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
     const binding = paramBindingFromName(parameter.name, sourceFile);
     params.push(parameter.dotDotDotToken ? { kind: "rest", binding } : binding);
   }
@@ -799,18 +233,18 @@ var mappedLocation = (sourceFile, position, absolutePath, mapLocation) => {
 };
 var unwrapExpression = (expression) => {
   let current = expression;
-  while (ts2.isParenthesizedExpression(current) || ts2.isNonNullExpression(current)) {
+  while (ts.isParenthesizedExpression(current) || ts.isNonNullExpression(current)) {
     current = current.expression;
   }
-  if (ts2.isAwaitExpression(current)) return unwrapExpression(current.expression);
+  if (ts.isAwaitExpression(current)) return unwrapExpression(current.expression);
   return current;
 };
 var calleeFromExpression = (expression, sourceFile) => {
   const current = unwrapExpression(expression);
-  if (ts2.isIdentifier(current)) {
+  if (ts.isIdentifier(current)) {
     return { calleeName: current.text, calleeText: current.text };
   }
-  if (ts2.isPropertyAccessExpression(current) && ts2.isIdentifier(current.name)) {
+  if (ts.isPropertyAccessExpression(current) && ts.isIdentifier(current.name)) {
     return {
       calleeName: current.name.text,
       calleeText: current.getText(sourceFile).replace(/\s+/g, "")
@@ -820,9 +254,9 @@ var calleeFromExpression = (expression, sourceFile) => {
 };
 var resultBindingForCall = (call) => {
   let node = call.parent;
-  if (ts2.isAwaitExpression(node)) node = node.parent;
-  if (!ts2.isVariableDeclaration(node)) return null;
-  if (!ts2.isIdentifier(node.name)) return null;
+  if (ts.isAwaitExpression(node)) node = node.parent;
+  if (!ts.isVariableDeclaration(node)) return null;
+  if (!ts.isIdentifier(node.name)) return null;
   const initializer = node.initializer;
   if (!initializer) return null;
   const inner = unwrapExpression(initializer);
@@ -832,18 +266,18 @@ var resultBindingForCall = (call) => {
 var argIdentifiersForCall = (call) => {
   const identifiers = [];
   call.arguments?.forEach((argument, index) => {
-    if (ts2.isIdentifier(argument)) {
+    if (ts.isIdentifier(argument)) {
       identifiers.push({ index, kind: "identifier", name: argument.text });
       return;
     }
-    if (!ts2.isObjectLiteralExpression(argument)) return;
+    if (!ts.isObjectLiteralExpression(argument)) return;
     const properties = [];
     for (const property of argument.properties) {
-      if (ts2.isShorthandPropertyAssignment(property)) {
+      if (ts.isShorthandPropertyAssignment(property)) {
         properties.push({ key: property.name.text, name: property.name.text });
         continue;
       }
-      if (ts2.isPropertyAssignment(property) && ts2.isIdentifier(property.name) && ts2.isIdentifier(property.initializer)) {
+      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && ts.isIdentifier(property.initializer)) {
         properties.push({ key: property.name.text, name: property.initializer.text });
       }
     }
@@ -883,8 +317,8 @@ var collectCallSite = (call, caller, context) => {
   };
 };
 var collectParamDestructure = (declaration, caller, context) => {
-  if (!declaration.initializer || !ts2.isIdentifier(declaration.initializer)) return null;
-  if (!ts2.isObjectBindingPattern(declaration.name) && !ts2.isArrayBindingPattern(declaration.name)) {
+  if (!declaration.initializer || !ts.isIdentifier(declaration.initializer)) return null;
+  if (!ts.isObjectBindingPattern(declaration.name) && !ts.isArrayBindingPattern(declaration.name)) {
     return null;
   }
   const sourceParam = declaration.initializer.text;
@@ -906,58 +340,483 @@ var collectParamDestructure = (declaration, caller, context) => {
   };
 };
 
-// src/auto-instrumentation/transform-source.ts
+// src/auto-instrumentation/parameter-initializer-may-run-code.ts
+import ts2 from "typescript";
+var unwrap = (expression) => {
+  let current = expression;
+  while (ts2.isParenthesizedExpression(current) || ts2.isNonNullExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+};
+var isSafeLiteralInitializer = (expression) => {
+  const current = unwrap(expression);
+  if (ts2.isNumericLiteral(current) || ts2.isStringLiteral(current) || ts2.isNoSubstitutionTemplateLiteral(current) || ts2.isBigIntLiteral(current)) {
+    return true;
+  }
+  if (current.kind === ts2.SyntaxKind.TrueKeyword || current.kind === ts2.SyntaxKind.FalseKeyword || current.kind === ts2.SyntaxKind.NullKeyword) {
+    return true;
+  }
+  if (ts2.isIdentifier(current) && current.text === "undefined") return true;
+  if (ts2.isPrefixUnaryExpression(current) && (current.operator === ts2.SyntaxKind.PlusToken || current.operator === ts2.SyntaxKind.MinusToken)) {
+    return ts2.isNumericLiteral(unwrap(current.operand));
+  }
+  return false;
+};
+var functionHasPreBodyParameterEvaluation = (node) => {
+  for (const parameter of node.parameters) {
+    if (ts2.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    if (!parameter.initializer) continue;
+    if (!isSafeLiteralInitializer(parameter.initializer)) return true;
+  }
+  return false;
+};
+
+// src/auto-instrumentation/suspension-whitelist.ts
+import ts3 from "typescript";
+var nodeFlags = ts3.NodeFlags;
+var AWAIT_USING_FLAG = nodeFlags.AwaitUsing ?? 0;
+var USING_FLAG = nodeFlags.Using ?? 0;
+var KNOWN_SUSPENSION_KIND_NAMES = [
+  "AwaitExpression",
+  "AwaitKeyword",
+  "YieldExpression",
+  "YieldKeyword",
+  "UsingKeyword"
+];
+var isFunctionLike = (node) => ts3.isFunctionLike(node);
+var isAsyncFunctionLike = (node) => (ts3.getCombinedModifierFlags(node) & ts3.ModifierFlags.Async) !== 0;
+var isAsyncGeneratorLike = (node) => isFunctionLike(node) && isAsyncFunctionLike(node) && "asteriskToken" in node && Boolean(node.asteriskToken);
+var isSyncGeneratorLike = (node) => isFunctionLike(node) && "asteriskToken" in node && Boolean(node.asteriskToken) && !isAsyncFunctionLike(node);
+var visitOwnBody = (node, visitNode) => {
+  if (!node.body) return;
+  const visit = (candidate) => {
+    if (candidate !== node && isFunctionLike(candidate)) {
+      visitNode(candidate);
+      return;
+    }
+    if (visitNode(candidate)) return;
+    ts3.forEachChild(candidate, visit);
+  };
+  visit(node.body);
+};
+var nestedFunctionSpans = (node, sourceFile) => {
+  const spans = [];
+  visitOwnBody(node, (candidate) => {
+    if (candidate !== node && isFunctionLike(candidate)) {
+      spans.push([candidate.getStart(sourceFile), candidate.end]);
+    }
+    return void 0;
+  });
+  return spans.sort((left, right) => left[0] - right[0]);
+};
+var slicesOutside = (start, end, spans) => {
+  const slices = [];
+  let cursor = start;
+  for (const [from, to] of spans) {
+    if (to <= cursor) continue;
+    if (from >= end) break;
+    if (from > cursor) slices.push([cursor, Math.min(from, end)]);
+    cursor = Math.max(cursor, to);
+  }
+  if (cursor < end) slices.push([cursor, end]);
+  return slices;
+};
+var sliceHasAwaitKeyword = (source, start, end) => {
+  if (end <= start) return false;
+  const scanner = ts3.createScanner(
+    ts3.ScriptTarget.Latest,
+    true,
+    ts3.LanguageVariant.Standard,
+    source.slice(start, end)
+  );
+  while (true) {
+    const token = scanner.scan();
+    if (token === ts3.SyntaxKind.EndOfFileToken) return false;
+    if (token === ts3.SyntaxKind.AwaitKeyword) return true;
+  }
+};
+var ownBodyHasAwaitKeyword = (node, sourceFile) => {
+  if (!node.body) return false;
+  const spans = nestedFunctionSpans(node, sourceFile);
+  for (const [start, end] of slicesOutside(node.body.getStart(sourceFile), node.body.end, spans)) {
+    if (sliceHasAwaitKeyword(sourceFile.text, start, end)) return true;
+  }
+  return false;
+};
+var isAwaitUsingList = (node) => {
+  const text = node.getText().trimStart();
+  if (text.startsWith("await using")) return true;
+  if (AWAIT_USING_FLAG === 0 || USING_FLAG === 0) return false;
+  return (node.flags & AWAIT_USING_FLAG) === AWAIT_USING_FLAG && (node.flags & USING_FLAG) !== 0;
+};
+var unknownSuspensionKind = (node) => {
+  const name = ts3.SyntaxKind[node.kind];
+  if (typeof name !== "string" || !/Await|Yield|Using/.test(name)) return false;
+  return !KNOWN_SUSPENSION_KIND_NAMES.includes(name);
+};
+var ownSuspensionFacts = (node, sourceFile) => {
+  const facts = {
+    awaitExpressions: false,
+    forAwait: false,
+    awaitUsing: false,
+    unknown: false,
+    awaitKeyword: ownBodyHasAwaitKeyword(node, sourceFile)
+  };
+  visitOwnBody(node, (candidate) => {
+    if (ts3.isAwaitExpression(candidate)) facts.awaitExpressions = true;
+    if (ts3.isForOfStatement(candidate) && candidate.awaitModifier) facts.forAwait = true;
+    if (ts3.isVariableDeclarationList(candidate) && isAwaitUsingList(candidate)) {
+      facts.awaitUsing = true;
+    }
+    if (unknownSuspensionKind(candidate)) facts.unknown = true;
+    return void 0;
+  });
+  return facts;
+};
+var bodyHasDirectEval = (node) => {
+  let found = false;
+  visitOwnBody(node, (candidate) => {
+    if (ts3.isCallExpression(candidate) && ts3.isIdentifier(candidate.expression) && candidate.expression.text === "eval") {
+      found = true;
+    }
+    return found;
+  });
+  return found;
+};
+var decideAsyncInstrumentation = (node, sourceFile) => {
+  if (isAsyncGeneratorLike(node)) return { action: "skip", reason: "unsupported_async_generator" };
+  if (!isAsyncFunctionLike(node)) return { action: "inline" };
+  if (bodyHasDirectEval(node)) return { action: "skip", reason: "direct_eval" };
+  const facts = ownSuspensionFacts(node, sourceFile);
+  if (facts.unknown) return { action: "skip", reason: "unknown_suspension" };
+  if (facts.forAwait) return { action: "skip", reason: "unsupported_for_await" };
+  if (facts.awaitUsing) return { action: "skip", reason: "await_using" };
+  if (facts.awaitKeyword && !facts.awaitExpressions) {
+    return { action: "skip", reason: "unknown_suspension" };
+  }
+  if (facts.awaitExpressions) return { action: "suspend_resume" };
+  return { action: "inline" };
+};
+
+// src/auto-instrumentation/verify-instrumentation-isomorphism.ts
+import ts4 from "typescript";
+var RASPUTIN_IDENT = /^__rasputin/;
 var scriptKindFor = (filePath) => {
-  if (/\.tsx$/i.test(filePath)) return ts3.ScriptKind.TSX;
-  if (/\.jsx$/i.test(filePath)) return ts3.ScriptKind.JSX;
-  if (/\.[cm]?ts$/i.test(filePath)) return ts3.ScriptKind.TS;
-  return ts3.ScriptKind.JS;
+  if (/\.tsx$/i.test(filePath)) return ts4.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts4.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts4.ScriptKind.TS;
+  return ts4.ScriptKind.JS;
+};
+var parse = (filePath, source) => ts4.createSourceFile(filePath, source, ts4.ScriptTarget.Latest, true, scriptKindFor(filePath));
+var isRasputinName = (name) => RASPUTIN_IDENT.test(name);
+var identText = (node) => {
+  if (ts4.isIdentifier(node)) return node.text;
+  if (ts4.isPrivateIdentifier(node)) return node.text;
+  return void 0;
+};
+var calleeName = (expression) => {
+  if (ts4.isIdentifier(expression)) return expression.text;
+  if (ts4.isPropertyAccessExpression(expression)) {
+    const object = identText(expression.expression);
+    const property = identText(expression.name);
+    if (object && isRasputinName(object) && property) return `${object}.${property}`;
+  }
+  return void 0;
+};
+var isRasputinCall = (node, methods) => {
+  if (!ts4.isCallExpression(node)) return false;
+  const name = calleeName(node.expression);
+  if (!name) return false;
+  if (isRasputinName(name)) return !methods || methods.has(name.split(".")[1] ?? "");
+  return false;
+};
+var unwrapCall = (node) => {
+  let current = node;
+  while (isRasputinCall(current) && current.arguments.length === 1 && current.arguments[0]) {
+    current = current.arguments[0];
+    if (ts4.isParenthesizedExpression(current)) current = current.expression;
+  }
+  if (ts4.isParenthesizedExpression(current)) return current.expression;
+  return current;
+};
+var isRasputinStatement = (node) => {
+  if (ts4.isEmptyStatement(node)) return true;
+  if (ts4.isVariableStatement(node)) {
+    return node.declarationList.declarations.every((declaration) => {
+      const name = identText(declaration.name);
+      return Boolean(name && isRasputinName(name));
+    });
+  }
+  if (ts4.isExpressionStatement(node)) {
+    if (!isRasputinCall(node.expression)) return false;
+    const unwrapped = unwrapCall(node.expression);
+    return unwrapped === node.expression;
+  }
+  return false;
+};
+var isRasputinTryWrapper = (node) => {
+  const catchClause = node.catchClause;
+  if (!catchClause || !node.finallyBlock) return false;
+  const catchCalls = catchClause.block.statements.filter(
+    (statement) => !isRasputinStatement(statement)
+  );
+  const leftover = catchCalls[0];
+  const leftoverThrow = catchCalls.length === 1 && leftover !== void 0 && ts4.isThrowStatement(leftover) && ts4.isIdentifier(leftover.expression) && isRasputinName(leftover.expression.text);
+  if (!leftoverThrow && catchCalls.length > 0) return false;
+  return node.finallyBlock.statements.every((statement) => isRasputinStatement(statement));
+};
+var flattenStatements = (statements) => {
+  const flattened = [];
+  for (const statement of statements) {
+    if (isRasputinStatement(statement)) continue;
+    if (ts4.isTryStatement(statement) && isRasputinTryWrapper(statement)) {
+      flattened.push(...flattenStatements(statement.tryBlock.statements));
+      continue;
+    }
+    flattened.push(statement);
+  }
+  return flattened;
+};
+var extra = (node) => {
+  if (ts4.isIdentifier(node) || ts4.isPrivateIdentifier(node)) {
+    return isRasputinName(node.text) ? "" : node.text;
+  }
+  if (ts4.isStringLiteral(node) || ts4.isNumericLiteral(node) || ts4.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+  if (ts4.isToken(node) && !ts4.isIdentifier(node)) return ts4.SyntaxKind[node.kind] ?? "";
+  return "";
+};
+var signatureOf = (node) => {
+  const unwrapped = unwrapCall(node);
+  if (unwrapped !== node) return signatureOf(unwrapped);
+  if (ts4.isEmptyStatement(unwrapped) || isRasputinStatement(unwrapped)) return "";
+  if (ts4.isTryStatement(unwrapped) && isRasputinTryWrapper(unwrapped)) {
+    return flattenStatements(unwrapped.tryBlock.statements).map(signatureOf).filter(Boolean).join("");
+  }
+  if (ts4.isBlock(unwrapped)) {
+    const statements = flattenStatements(unwrapped.statements);
+    return `Block[${statements.map(signatureOf).filter(Boolean).join(",")}]`;
+  }
+  if (ts4.isCatchClause(unwrapped)) {
+    const statements = flattenStatements(unwrapped.block.statements);
+    const variable = unwrapped.variableDeclaration ? signatureOf(unwrapped.variableDeclaration) : "";
+    return `Catch${variable}[${statements.map(signatureOf).filter(Boolean).join(",")}]`;
+  }
+  if (ts4.isArrowFunction(unwrapped) && ts4.isBlock(unwrapped.body)) {
+    const statements = flattenStatements(unwrapped.body.statements);
+    const only = statements[0];
+    if (statements.length === 1 && only && ts4.isReturnStatement(only) && only.expression) {
+      const expression = only.expression;
+      const parts2 = [];
+      ts4.forEachChild(unwrapped, (child) => {
+        if (child === unwrapped.body) {
+          const part2 = signatureOf(expression);
+          if (part2) parts2.push(part2);
+          return;
+        }
+        const part = signatureOf(child);
+        if (part) parts2.push(part);
+      });
+      return `ArrowFunction[${parts2.join(",")}]`;
+    }
+  }
+  const parts = [];
+  ts4.forEachChild(unwrapped, (child) => {
+    const part = signatureOf(child);
+    if (part) parts.push(part);
+  });
+  const kind = ts4.SyntaxKind[unwrapped.kind] ?? "Node";
+  const label = extra(unwrapped);
+  return `${kind}${label}[${parts.join(",")}]`;
+};
+var instrumentationTreesAreIsomorphic = (filePath, original, transformed) => {
+  return signatureOf(parse(filePath, original)) === signatureOf(parse(filePath, transformed));
+};
+
+// src/auto-instrumentation/verify-transformed-source.ts
+import ts5 from "typescript";
+var transpileForVerification = (filePath, code) => ts5.transpileModule(code, {
+  compilerOptions: {
+    // ES2020 downlevel keeps native @decorators out of `new Function`.
+    target: ts5.ScriptTarget.ES2020,
+    module: ts5.ModuleKind.ESNext,
+    allowJs: true,
+    jsx: ts5.JsxEmit.React,
+    experimentalDecorators: true
+  },
+  reportDiagnostics: true,
+  fileName: filePath
+});
+var hasScanOrParseError = (diagnostics) => Boolean(
+  diagnostics?.some(
+    (diagnostic) => diagnostic.category === ts5.DiagnosticCategory.Error && diagnostic.code < 2e3
+  )
+);
+var scriptBodyForEngine = (emitted) => (
+  // File loaders strip a leading shebang; `new Function` does not.
+  emitted.replace(/^#![^\n]*\n/, "").replaceAll("import.meta", "({})")
+);
+var looksTyped = (filePath) => /\.[cm]?tsx?$/i.test(filePath);
+var scriptKindFor2 = (filePath) => {
+  if (/\.tsx$/i.test(filePath)) return ts5.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts5.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts5.ScriptKind.TS;
+  return ts5.ScriptKind.JS;
+};
+var isIterationStatement = (node) => ts5.isForStatement(node) || ts5.isForOfStatement(node) || ts5.isForInStatement(node) || ts5.isWhileStatement(node) || ts5.isDoStatement(node);
+var unwrapLabeled = (node) => {
+  let current = node;
+  while (ts5.isLabeledStatement(current)) current = current.statement;
+  return current;
+};
+var hasInvalidLabelJump = (sourceFile) => {
+  const visit = (node, labels) => {
+    if (ts5.isFunctionLike(node)) {
+      let nestedInvalid = false;
+      ts5.forEachChild(node, (child) => {
+        if (visit(child, /* @__PURE__ */ new Map())) nestedInvalid = true;
+      });
+      return nestedInvalid;
+    }
+    if (ts5.isLabeledStatement(node)) {
+      const next = new Map(labels);
+      next.set(node.label.text, isIterationStatement(unwrapLabeled(node.statement)));
+      return visit(node.statement, next);
+    }
+    if (ts5.isContinueStatement(node) && node.label) {
+      if (labels.get(node.label.text) !== true) return true;
+    }
+    if (ts5.isBreakStatement(node) && node.label && !labels.has(node.label.text)) {
+      return true;
+    }
+    let invalid = false;
+    ts5.forEachChild(node, (child) => {
+      if (visit(child, labels)) invalid = true;
+    });
+    return invalid;
+  };
+  return visit(sourceFile, /* @__PURE__ */ new Map());
+};
+var importSpecifier = `('[^']+'|"[^"]+")`;
+var importAttributes = String.raw`(?:\s+with\s*\{[^}]*\})?`;
+var stripModuleSyntax = (body) => body.replace(/\bexport\s+default\b/g, "var __rasputinVerifyDefault =").replace(new RegExp(String.raw`\bexport\s*\*[\s\S]*?from\s+${importSpecifier}`, "g"), "").replace(
+  new RegExp(
+    String.raw`\bexport\s*\{[^}]*\}\s*from\s+${importSpecifier}${importAttributes}`,
+    "g"
+  ),
+  ""
+).replace(/\bexport\s*\{[^}]*\}/g, "").replace(/\bexport\s+/g, "").replace(
+  new RegExp(
+    String.raw`\bimport(?:\s+type)?\s+[\s\S]*?from\s+${importSpecifier}${importAttributes}`,
+    "g"
+  ),
+  ""
+).replace(/\bimport\s+type\s+[\s\S]*?(?:;|\n)/g, "").replace(new RegExp(String.raw`\bimport\s+${importSpecifier}${importAttributes}`, "g"), "");
+var engineAccepts = (body) => {
+  for (const candidate of [body, stripModuleSyntax(body)]) {
+    try {
+      new Function(candidate);
+      return true;
+    } catch {
+      try {
+        new Function(`return (async()=>{${candidate}
+})`);
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+};
+var GLUED_INSTRUMENTATION = /\b(?:return|await|throw|typeof|void|yield|new|delete|in|instanceof|of|from|as|case|else)__rasputin/;
+var UNTERMINATED_BARE_LEAVE = /\breturn\s+__rasputin\w*\.leave\(\)(?!\s*;|\()/;
+var transformedSourceIsInvalid = (filePath, code) => {
+  if (GLUED_INSTRUMENTATION.test(code)) return true;
+  if (UNTERMINATED_BARE_LEAVE.test(code)) return true;
+  const sourceFile = ts5.createSourceFile(
+    filePath,
+    code,
+    ts5.ScriptTarget.Latest,
+    true,
+    scriptKindFor2(filePath)
+  );
+  if (hasInvalidLabelJump(sourceFile)) return true;
+  const { diagnostics, outputText } = transpileForVerification(filePath, code);
+  if (hasScanOrParseError(diagnostics)) return true;
+  if (looksTyped(filePath)) return !engineAccepts(scriptBodyForEngine(outputText));
+  if (engineAccepts(scriptBodyForEngine(code))) return false;
+  return !engineAccepts(scriptBodyForEngine(outputText));
+};
+
+// src/auto-instrumentation/transform-source.ts
+var isIdentContinue = (code) => code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 36 || code === 95;
+var isIdentStart = (code) => code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 36 || code === 95;
+var separateFromPreviousToken = (source, position, text) => {
+  if (position <= 0 || text.length === 0) return text;
+  if (isIdentContinue(source.charCodeAt(position - 1)) && isIdentStart(text.charCodeAt(0))) {
+    return ` ${text}`;
+  }
+  return text;
+};
+var RASPUTIN_INSTRUMENTATION_MARKER = "rasputin.instrumented.v3";
+var RASPUTIN_INSTRUMENTATION_PREAMBLE = `/*${RASPUTIN_INSTRUMENTATION_MARKER}*/`;
+var sourceIsRasputinInstrumented = (source) => source.includes(RASPUTIN_INSTRUMENTATION_PREAMBLE);
+var alreadyInstrumentedResult = (source) => ({
+  code: source,
+  delta: { functions: [], callSites: [], destructures: [], alreadyInstrumented: true }
+});
+var scriptKindFor3 = (filePath) => {
+  if (/\.tsx$/i.test(filePath)) return ts6.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts6.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts6.ScriptKind.TS;
+  return ts6.ScriptKind.JS;
 };
 var functionName = (node, sourceFile) => {
+  if (ts6.isConstructorDeclaration(node)) return "constructor";
   if (node.name) return node.name.getText(sourceFile).replace(/^['"]|['"]$/g, "");
   const parent = node.parent;
-  if (ts3.isVariableDeclaration(parent) && ts3.isIdentifier(parent.name)) return parent.name.text;
-  if (ts3.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
-  if (ts3.isPropertyDeclaration(parent) && parent.name) return parent.name.getText(sourceFile);
+  if (ts6.isVariableDeclaration(parent) && ts6.isIdentifier(parent.name)) return parent.name.text;
+  if (ts6.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
+  if (ts6.isPropertyDeclaration(parent) && parent.name) return parent.name.getText(sourceFile);
   const location = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
   return `anonymous@${location.line + 1}:${location.character + 1}`;
 };
 var functionLocationPosition = (node, sourceFile) => {
   if (node.name) return node.name.getStart(sourceFile);
   const parent = node.parent;
-  if ((ts3.isVariableDeclaration(parent) || ts3.isPropertyAssignment(parent)) && parent.name) {
+  if ((ts6.isVariableDeclaration(parent) || ts6.isPropertyAssignment(parent)) && parent.name) {
     return parent.name.getStart(sourceFile);
   }
   return node.getStart(sourceFile);
 };
-var bindingValue = (name, sourceFile) => {
-  if (ts3.isIdentifier(name)) return name.text;
-  if (ts3.isArrayBindingPattern(name)) {
-    const values = name.elements.map((element) => {
-      if (ts3.isOmittedExpression(element)) return "";
-      const value = bindingValue(element.name, sourceFile);
-      return element.dotDotDotToken ? `...${value}` : value;
-    });
-    return `[${values.join(",")}]`;
+var functionBodyPrologueEnd = (body, sourceFile) => {
+  let end = body.getStart(sourceFile) + 1;
+  for (const statement of body.statements) {
+    if (!isDirectivePrologue(statement)) break;
+    end = statement.end;
   }
-  const properties = name.elements.map((element) => {
-    const value = bindingValue(element.name, sourceFile);
-    if (element.dotDotDotToken) return `...${value}`;
-    if (element.propertyName) return `${element.propertyName.getText(sourceFile)}:${value}`;
-    return value;
-  });
-  return `{${properties.join(",")}}`;
+  return end;
 };
-var arrowArguments = (node) => {
+var arrowArgsCapture = (node) => {
+  if (!node.parameters.every((parameter) => ts6.isIdentifier(parameter.name))) {
+    const count = node.parameters.filter(
+      (parameter) => !(ts6.isIdentifier(parameter.name) && parameter.name.text === "this")
+    ).length;
+    return {
+      args: `[${Array.from({ length: count }, () => "void 0").join(",")}]`,
+      omitValues: true
+    };
+  }
   const values = node.parameters.flatMap((parameter) => {
-    if (ts3.isIdentifier(parameter.name) && parameter.name.text === "this") return [];
-    const value = bindingValue(parameter.name, node.getSourceFile());
-    return [parameter.dotDotDotToken ? `...${value}` : value];
+    if (!ts6.isIdentifier(parameter.name) || parameter.name.text === "this") return [];
+    return [parameter.dotDotDotToken ? `...${parameter.name.text}` : parameter.name.text];
   });
-  return `[${values.join(",")}]`;
+  return { args: `[${values.join(",")}]`, omitValues: false };
 };
 var isSupportedFunction = (node) => {
-  if (!ts3.isFunctionDeclaration(node) && !ts3.isFunctionExpression(node) && !ts3.isArrowFunction(node) && !ts3.isMethodDeclaration(node) && !ts3.isGetAccessorDeclaration(node) && !ts3.isSetAccessorDeclaration(node)) {
+  if (!ts6.isFunctionDeclaration(node) && !ts6.isFunctionExpression(node) && !ts6.isArrowFunction(node) && !ts6.isMethodDeclaration(node) && !ts6.isGetAccessorDeclaration(node) && !ts6.isSetAccessorDeclaration(node)) {
     return false;
   }
   if (!node.body || "asteriskToken" in node && node.asteriskToken) return false;
@@ -968,7 +827,7 @@ var uniqueName = (source, base) => {
   while (source.includes(name)) name += "_";
   return name;
 };
-var isDirectivePrologue = (statement) => ts3.isExpressionStatement(statement) && ts3.isStringLiteral(statement.expression);
+var isDirectivePrologue = (statement) => ts6.isExpressionStatement(statement) && ts6.isStringLiteral(statement.expression);
 var insertPositionAfterPrologue = (source, sourceFile) => {
   const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
   let end = shebangEnd;
@@ -983,7 +842,7 @@ var preambleInsert = (source, position, preamble) => {
   const previous = source[position - 1];
   return previous === ";" || previous === "\n" || previous === "\r" ? preamble : `;${preamble}`;
 };
-var modulePreamble = (runName, capName, plansName, plansJson) => `const ${plansName}=${plansJson};const ${runName}=((g,k)=>{const r=g[k]??(g[k]={runtimes:[],modules:[],captureRoot(i,v){return v},register(p){const d={run:(i,a,c)=>c()};const m={plans:p,cell:d};this.modules.push(m);const n=this.runtimes.at(-1);if(n)n.bind(m);return(i,a,c,l)=>d.run(i,a,c,l)}});return r.register(${plansName})})(globalThis,Symbol.for(${JSON.stringify(AUTOMATIC_RUNTIME_SYMBOL)}));const ${capName}=((g,k)=>{const r=g[k];return(i,v)=>typeof r?.captureRoot==='function'?r.captureRoot(i,v):v})(globalThis,Symbol.for(${JSON.stringify(AUTOMATIC_RUNTIME_SYMBOL)}));`;
+var modulePreamble = (runName, plansName, plansJson) => `${RASPUTIN_INSTRUMENTATION_PREAMBLE}const ${plansName}=${plansJson};const ${runName}=((g,k)=>{const r=g[k]??(g[k]={runtimes:[],modules:[],register(p){const d={run:(i,a,c)=>c(),enter(){return{leave(v){return v},fail(){},end(){},suspend(v){return v},resume(v){return v},run(c){return c()}}}};const m={plans:p,cell:d};this.modules.push(m);const n=this.runtimes.at(-1);if(n)n.bind(m);const f=(i,a,c,l)=>d.run(i,a,c,l);f.enter=(i,a,l)=>d.enter(i,a,l);return f}});return r.register(${plansName})})(globalThis,Symbol.for(${JSON.stringify(AUTOMATIC_RUNTIME_SYMBOL)}));`;
 var collectWrappedFunction = (node, sourceFile, absolutePath, mapLocation) => {
   const start = mappedLocation(
     sourceFile,
@@ -1011,40 +870,276 @@ var collectWrappedFunction = (node, sourceFile, absolutePath, mapLocation) => {
     endLine: end.line,
     endColumn: end.column,
     params,
-    paramNames
+    paramNames,
+    instrumented: true
   };
 };
-var canOmitCallValues = (analysis, analyzed) => {
-  if (!functionIsExact(analysis.plan) || analysis.hasThrow || analysis.hasCoercionGuard) {
-    return false;
+var wrap = (edits, start, end, open, close, depth) => {
+  const width = Math.max(0, end - start);
+  edits.push({ position: start, text: open, deleteCount: 0, depth, width, kind: "open" });
+  edits.push({ position: end, text: close, deleteCount: 0, depth, width, kind: "close" });
+};
+var compareEdits = (left, right) => {
+  if (left.position !== right.position) return right.position - left.position;
+  if (left.kind !== right.kind) {
+    const rank = { replace: 0, close: 1, open: 2 };
+    return rank[left.kind] - rank[right.kind];
   }
-  const callers = analyzed.filter(
-    (caller) => caller.callEdges.some((edge) => edge.calleeFunctionId === analysis.functionId)
-  );
-  if (callers.length === 0) return false;
-  return callers.every((caller) => caller.plan.fallbackReason === void 0 && !caller.hasThrow);
+  if (left.kind === "close") {
+    if (left.width !== right.width) return right.width - left.width;
+    return left.depth - right.depth;
+  }
+  if (left.kind === "open") {
+    if (left.width !== right.width) return left.width - right.width;
+    return right.depth - left.depth;
+  }
+  return 0;
+};
+var VLQ_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var encodeVlq = (value) => {
+  let vlq = value < 0 ? -value << 1 | 1 : value << 1;
+  let encoded = "";
+  do {
+    let digit = vlq & 31;
+    vlq >>>= 5;
+    if (vlq > 0) digit |= 32;
+    encoded += VLQ_ALPHABET[digit];
+  } while (vlq > 0);
+  return encoded;
+};
+var SOURCEMAP_COMMENT = /(?:\/\/[#@][ \t]*sourceMappingURL=([^\s'"]+)|\/\*[#@][ \t]*sourceMappingURL=([^\s*'"]+)[ \t]*\*\/)\s*$/;
+var decodeInlineSourceMap = (url) => {
+  const base64 = /^data:application\/json(?:;charset=[^;,]+)?;base64,(.+)$/i.exec(url);
+  if (base64?.[1]) {
+    try {
+      return Buffer.from(base64[1], "base64").toString("utf8");
+    } catch {
+      return void 0;
+    }
+  }
+  const raw = /^data:application\/json(?:;charset=[^;,]+)?,(.+)$/i.exec(url);
+  if (!raw?.[1]) return void 0;
+  try {
+    return decodeURIComponent(raw[1]);
+  } catch {
+    return void 0;
+  }
+};
+var upstreamTraceMap = (original) => {
+  const match = SOURCEMAP_COMMENT.exec(original);
+  const url = match?.[1] ?? match?.[2];
+  if (!url) return void 0;
+  const payload = url.startsWith("data:") ? decodeInlineSourceMap(url) : void 0;
+  if (!payload) return void 0;
+  try {
+    return new TraceMap2(payload);
+  } catch {
+    return void 0;
+  }
+};
+var lineStartsOf = (text) => {
+  const starts = [0];
+  for (let index = 0; index < text.length; index++) {
+    if (text[index] === "\n") starts.push(index + 1);
+  }
+  return starts;
+};
+var positionAt = (starts, offset) => {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = low + high + 1 >> 1;
+    if ((starts[mid] ?? 0) <= offset) low = mid;
+    else high = mid - 1;
+  }
+  return { line: low, column: offset - (starts[low] ?? 0) };
+};
+var sortedEdits = (edits) => [...edits].sort(compareEdits);
+var originalOffsetToGenerated = (originalOffset, edits) => {
+  let generated = originalOffset;
+  for (const edit of edits) {
+    const delta = edit.text.length - edit.deleteCount;
+    if (originalOffset >= edit.position + edit.deleteCount) generated += delta;
+    else if (originalOffset >= edit.position) generated = edit.position + edit.text.length;
+  }
+  return generated;
+};
+var mappingOffsets = (original, edits) => {
+  const offsets = /* @__PURE__ */ new Set([0, original.length]);
+  for (const start of lineStartsOf(original)) offsets.add(start);
+  for (const edit of edits) {
+    offsets.add(edit.position);
+    offsets.add(edit.position + edit.deleteCount);
+  }
+  return [...offsets].filter((offset) => offset >= 0 && offset <= original.length).sort((left, right) => left - right);
+};
+var encodeColumnMappings = (original, generated, file, edits) => {
+  const upstream = upstreamTraceMap(original);
+  const sources = (upstream?.sources.filter((source) => Boolean(source)) ?? [file]).filter((source, index, all) => all.indexOf(source) === index);
+  if (sources.length === 0) sources.push(file);
+  const applied = sortedEdits(edits);
+  const originalStarts = lineStartsOf(original);
+  const generatedStarts = lineStartsOf(generated);
+  const pointsByLine = Array.from({ length: generatedStarts.length }, () => []);
+  const seen = /* @__PURE__ */ new Set();
+  for (const originalOffset of mappingOffsets(original, edits)) {
+    const generatedOffset = Math.min(
+      originalOffsetToGenerated(originalOffset, applied),
+      generated.length
+    );
+    const originalPosition = positionAt(originalStarts, originalOffset);
+    const generatedPosition = positionAt(generatedStarts, generatedOffset);
+    let sourceIndex = 0;
+    let mappedLine = originalPosition.line;
+    let mappedColumn = originalPosition.column;
+    if (upstream) {
+      const mapped = originalPositionFor2(upstream, {
+        line: originalPosition.line + 1,
+        column: originalPosition.column
+      });
+      if (mapped.source && mapped.line != null && mapped.column != null) {
+        const index = sources.indexOf(mapped.source);
+        sourceIndex = index >= 0 ? index : 0;
+        mappedLine = mapped.line - 1;
+        mappedColumn = mapped.column;
+      }
+    }
+    const key = `${generatedPosition.line}:${generatedPosition.column}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    pointsByLine[generatedPosition.line]?.push({
+      generatedColumn: generatedPosition.column,
+      sourceIndex,
+      originalLine: mappedLine,
+      originalColumn: mappedColumn
+    });
+  }
+  const lines = pointsByLine.map((segments) => {
+    segments.sort((left, right) => left.generatedColumn - right.generatedColumn);
+    let lastGeneratedColumn = 0;
+    let lastSourceIndex = 0;
+    let lastOriginalLine = 0;
+    let lastOriginalColumn = 0;
+    return segments.map((point) => {
+      const encoded = `${encodeVlq(point.generatedColumn - lastGeneratedColumn)}${encodeVlq(point.sourceIndex - lastSourceIndex)}${encodeVlq(point.originalLine - lastOriginalLine)}${encodeVlq(point.originalColumn - lastOriginalColumn)}`;
+      lastGeneratedColumn = point.generatedColumn;
+      lastSourceIndex = point.sourceIndex;
+      lastOriginalLine = point.originalLine;
+      lastOriginalColumn = point.originalColumn;
+      return encoded;
+    }).join(",");
+  });
+  return { sources, mappings: lines.join(";") };
+};
+var attachInlineSourceMap = (original, generated, filePath, edits) => {
+  const file = basename(filePath);
+  const withoutUpstream = generated.replace(SOURCEMAP_COMMENT, "");
+  const { sources, mappings } = encodeColumnMappings(original, withoutUpstream, file, edits);
+  const comment = `/*# sourceMappingURL=data:application/json;base64,${Buffer.from(
+    JSON.stringify({ version: 3, file, sources, mappings })
+  ).toString("base64")} */`;
+  return withoutUpstream.endsWith("\n") ? `${withoutUpstream.slice(0, -1)}${comment}
+` : `${withoutUpstream}${comment}`;
+};
+var insertAfterSuperOrPrologue = (body, sourceFile) => {
+  const end = functionBodyPrologueEnd(body, sourceFile);
+  for (const statement of body.statements) {
+    if (isDirectivePrologue(statement)) continue;
+    if (ts6.isExpressionStatement(statement) && ts6.isCallExpression(statement.expression) && statement.expression.expression.kind === ts6.SyntaxKind.SuperKeyword) {
+      return statement.end;
+    }
+    break;
+  }
+  return end;
+};
+var failEpilogue = (handleName, errorName, args, restoreOnCatch) => `}catch(${errorName}){${restoreOnCatch ? `${handleName}.resume();` : ""}${handleName}.fail(${errorName},${args});throw ${errorName};}finally{${handleName}.end();}`;
+var walkOwnBody = (node, visitNode) => {
+  if (!node.body) return;
+  const visit = (candidate) => {
+    if (candidate !== node && ts6.isFunctionLike(candidate)) return;
+    visitNode(candidate);
+    ts6.forEachChild(candidate, visit);
+  };
+  visit(node.body);
+};
+var collectAwaitWraps = (node, sourceFile, handleName, edits, depth) => {
+  walkOwnBody(node, (candidate) => {
+    if (!ts6.isAwaitExpression(candidate)) return;
+    wrap(
+      edits,
+      candidate.expression.getStart(sourceFile),
+      candidate.expression.end,
+      `${handleName}.suspend(`,
+      ")",
+      depth + 3
+    );
+    wrap(
+      edits,
+      candidate.getStart(sourceFile),
+      candidate.end,
+      `${handleName}.resume(`,
+      ")",
+      depth + 2
+    );
+  });
+};
+var collectCatchFinallyResumes = (node, sourceFile, handleName, edits, depth) => {
+  walkOwnBody(node, (candidate) => {
+    if (!ts6.isTryStatement(candidate)) return;
+    const blocks = [candidate.catchClause?.block, candidate.finallyBlock];
+    for (const block of blocks) {
+      if (!block) continue;
+      edits.push({
+        position: block.getStart(sourceFile) + 1,
+        text: `${handleName}.resume();`,
+        deleteCount: 0,
+        depth,
+        width: 0,
+        kind: "replace"
+      });
+    }
+  });
+};
+var collectReturnWraps = (node, sourceFile, handleName, edits, depth) => {
+  if (!node.body || !ts6.isBlock(node.body)) return;
+  const visit = (candidate, at) => {
+    if (candidate !== node && ts6.isFunctionLike(candidate)) return;
+    if (ts6.isReturnStatement(candidate) && candidate.expression) {
+      const expression = candidate.expression;
+      wrap(
+        edits,
+        expression.getStart(sourceFile),
+        expression.end,
+        `(${handleName}.leave((`,
+        ")))",
+        at
+      );
+      return;
+    }
+    ts6.forEachChild(candidate, (child) => visit(child, at + 1));
+  };
+  visit(node.body, depth + 1);
 };
 var transformSource = (source, options) => {
   if (source.includes("@rasputin-ignore-file")) return void 0;
-  const sourceFile = ts3.createSourceFile(
+  if (sourceIsRasputinInstrumented(source)) return alreadyInstrumentedResult(source);
+  const sourceFile = ts6.createSourceFile(
     options.filePath,
     source,
-    ts3.ScriptTarget.Latest,
+    ts6.ScriptTarget.Latest,
     true,
-    scriptKindFor(options.filePath)
+    scriptKindFor3(options.filePath)
   );
   const runName = uniqueName(source, "__rasputinRun__");
-  const capName = uniqueName(source, "__rasputinCap__");
   const plansName = uniqueName(source, "__rasputinPlans__");
-  const absolutePath = resolve3(options.filePath);
-  const derivationMode = options.derivationMode ?? "analysis";
+  const handleName = uniqueName(source, "__rasputinH__");
+  const errorName = uniqueName(source, "__rasputinE__");
+  const absolutePath = resolve4(options.filePath);
   const edits = [];
-  let order = 0;
   const delta = {
     functions: [],
     callSites: [],
-    destructures: [],
-    derivationPlans: []
+    destructures: []
   };
   const collectContext = {
     sourceFile,
@@ -1052,75 +1147,134 @@ var transformSource = (source, options) => {
     absolutePath
   };
   const pending = [];
-  const visit = (node, caller) => {
+  const skipFunction = (collected, reason) => {
+    collected.instrumented = false;
+    collected.skipReason = reason;
+    delta.functions.push(collected);
+    if (process.env.RASPUTIN_DEBUG === "1") {
+      console.info(
+        `[rasputin] skipped instrumentation for ${collected.name} in ${options.filePath}: ${reason}`
+      );
+    }
+  };
+  const visit = (node, caller, depth) => {
+    if (isAsyncGeneratorLike(node) && node.body) {
+      const collected = collectWrappedFunction(
+        node,
+        sourceFile,
+        absolutePath,
+        options.mapLocation
+      );
+      if (collected) {
+        collected.asyncFunction = true;
+        skipFunction(collected, "unsupported_async_generator");
+      }
+      ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
+      return;
+    }
+    if (isSyncGeneratorLike(node) && node.body) {
+      const collected = collectWrappedFunction(
+        node,
+        sourceFile,
+        absolutePath,
+        options.mapLocation
+      );
+      if (collected) skipFunction(collected, "unsupported_sync_generator");
+      ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
+      return;
+    }
+    if (ts6.isConstructorDeclaration(node) && node.body) {
+      const collected = collectWrappedFunction(
+        node,
+        sourceFile,
+        absolutePath,
+        options.mapLocation
+      );
+      if (collected) skipFunction(collected, "unsupported_constructor");
+      ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
+      return;
+    }
     if (isSupportedFunction(node)) {
       const collected = collectWrappedFunction(node, sourceFile, absolutePath, options.mapLocation);
       if (!collected) {
-        ts3.forEachChild(node, (child) => visit(child, caller));
+        ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
+        return;
+      }
+      const asyncFunction = isAsyncFunctionLike(node);
+      collected.asyncFunction = asyncFunction;
+      const decision = asyncFunction ? decideAsyncInstrumentation(node, sourceFile) : { action: "inline" };
+      if (decision.action === "skip") {
+        skipFunction(collected, decision.reason);
+        ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
         return;
       }
-      pending.push({ node, collected });
+      if (functionHasPreBodyParameterEvaluation(node)) {
+        collected.plan = withPreBodyParameterEvaluation(collected.plan);
+      }
+      pending.push({
+        node,
+        collected,
+        depth,
+        suspendResume: decision.action === "suspend_resume"
+      });
       delta.functions.push(collected);
-      ts3.forEachChild(node, (child) => visit(child, collected));
+      ts6.forEachChild(node, (child) => visit(child, collected, depth + 1));
       return;
     }
-    if (caller && (ts3.isCallExpression(node) || ts3.isNewExpression(node))) {
+    if (caller && (ts6.isCallExpression(node) || ts6.isNewExpression(node))) {
       const site = collectCallSite(node, caller, collectContext);
       if (site) delta.callSites.push(site);
     }
-    if (caller && ts3.isVariableDeclaration(node)) {
+    if (caller && ts6.isVariableDeclaration(node)) {
       const destructure = collectParamDestructure(node, caller, collectContext);
       if (destructure) delta.destructures.push(destructure);
     }
-    ts3.forEachChild(node, (child) => visit(child, caller));
+    ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
   };
-  visit(sourceFile);
-  if (pending.length === 0) return void 0;
-  const analyzed = analyzeModuleFunctions(
-    sourceFile,
-    pending.map((entry) => ({
-      functionId: entry.collected.functionId,
-      name: entry.collected.name,
-      node: entry.node
-    }))
-  );
-  delta.derivationPlans = analyzed.map((fn) => fn.plan);
-  const analyzedById = new Map(analyzed.map((fn) => [fn.functionId, fn]));
+  visit(sourceFile, void 0, 0);
+  if (pending.length === 0) {
+    return delta.functions.length > 0 ? { code: source, delta } : void 0;
+  }
   for (const [planIndex, entry] of pending.entries()) {
-    const analysis = analyzedById.get(entry.collected.functionId);
-    const omitValues = derivationMode === "selective" && analysis && canOmitCallValues(analysis, analyzed);
-    const valueFlag = omitValues ? ",1" : "";
-    const args = ts3.isArrowFunction(entry.node) ? arrowArguments(entry.node) : "arguments";
-    const asyncCallback = entry.node.modifiers?.some(
-      (modifier) => modifier.kind === ts3.SyntaxKind.AsyncKeyword
-    ) ? "async " : "";
-    if (ts3.isBlock(entry.node.body)) {
-      edits.push({
-        position: entry.node.body.getStart(sourceFile) + 1,
-        text: `return ${runName}(${planIndex},${args},${asyncCallback}()=>{`,
-        order: order++
-      });
-      edits.push({
-        position: entry.node.body.end - 1,
-        text: `}${valueFlag});`,
-        order: order++
-      });
-    } else {
-      edits.push({
-        position: entry.node.body.getStart(sourceFile),
-        text: `${runName}(${planIndex},${args},${asyncCallback}()=>(`,
-        order: order++
-      });
-      edits.push({
-        position: entry.node.body.end,
-        text: `)${valueFlag})`,
-        order: order++
-      });
-    }
-    if (analysis) {
-      for (const edit of captureWrapEdits(analysis.captureWraps, capName)) {
-        edits.push({ ...edit, order: order++ });
+    const captured = ts6.isArrowFunction(entry.node) ? arrowArgsCapture(entry.node) : { args: "arguments", omitValues: false };
+    const omitArg = captured.omitValues ? ",true" : "";
+    const enterCall = `${runName}.enter(${planIndex},${captured.args}${omitArg})`;
+    const epilogue = failEpilogue(handleName, errorName, captured.args, entry.suspendResume);
+    if (ts6.isBlock(entry.node.body)) {
+      const prologueAt = insertAfterSuperOrPrologue(entry.node.body, sourceFile);
+      const closeAt = entry.node.body.end - 1;
+      wrap(
+        edits,
+        prologueAt,
+        closeAt,
+        `;const ${handleName}=${enterCall};try{`,
+        epilogue,
+        entry.depth
+      );
+      collectReturnWraps(entry.node, sourceFile, handleName, edits, entry.depth);
+      if (entry.suspendResume) {
+        collectAwaitWraps(entry.node, sourceFile, handleName, edits, entry.depth);
+        collectCatchFinallyResumes(entry.node, sourceFile, handleName, edits, entry.depth);
       }
+    } else if (entry.suspendResume) {
+      wrap(
+        edits,
+        entry.node.body.getStart(sourceFile),
+        entry.node.body.end,
+        `{;const ${handleName}=${enterCall};try{return (${handleName}.leave((`,
+        `)));${epilogue}}`,
+        entry.depth
+      );
+      collectAwaitWraps(entry.node, sourceFile, handleName, edits, entry.depth);
+    } else {
+      wrap(
+        edits,
+        entry.node.body.getStart(sourceFile),
+        entry.node.body.end,
+        `{;const ${handleName}=${enterCall};try{return (${handleName}.leave((`,
+        `)));${epilogue}}`,
+        entry.depth
+      );
     }
   }
   const insertAt = insertPositionAfterPrologue(source, sourceFile);
@@ -1131,19 +1285,189 @@ var transformSource = (source, options) => {
       insertAt,
       modulePreamble(
         runName,
-        capName,
         plansName,
-        JSON.stringify(delta.functions.map((fn) => fn.plan))
+        JSON.stringify(pending.map((entry) => entry.collected.plan))
       )
     ),
-    order: -1
+    deleteCount: 0,
+    depth: -1,
+    width: 0,
+    kind: "replace"
   });
-  edits.sort((left, right) => right.position - left.position || right.order - left.order);
+  edits.sort(compareEdits);
   let transformed = source;
   for (const edit of edits) {
-    transformed = `${transformed.slice(0, edit.position)}${edit.text}${transformed.slice(edit.position)}`;
+    const text = separateFromPreviousToken(transformed, edit.position, edit.text);
+    transformed = `${transformed.slice(0, edit.position)}${text}${transformed.slice(edit.position + edit.deleteCount)}`;
+  }
+  const verify = options.verifyTransform ?? true;
+  const refuseTransformed = () => {
+    for (const entry of pending) {
+      entry.collected.instrumented = false;
+      entry.collected.skipReason = "verification_failed";
+    }
+    if (process.env.RASPUTIN_DEBUG === "1") {
+      console.info(
+        `[rasputin] skipped instrumentation for ${options.filePath}: verification_failed`
+      );
+    }
+    return { code: source, delta };
+  };
+  if (verify && transformedSourceIsInvalid(options.filePath, transformed)) {
+    if (transformedSourceIsInvalid(options.filePath, source)) {
+      if (process.env.RASPUTIN_DEBUG === "1") {
+        console.info(
+          `[rasputin] skipped instrumentation for ${options.filePath}: transformed source failed verification`
+        );
+      }
+      return void 0;
+    }
+    return refuseTransformed();
   }
-  return { code: transformed, delta };
+  if (verify && !instrumentationTreesAreIsomorphic(options.filePath, source, transformed)) {
+    return refuseTransformed();
+  }
+  return { code: attachInlineSourceMap(source, transformed, options.filePath, edits), delta };
+};
+
+// src/auto-instrumentation/transform-disk-cache.ts
+var projectCacheDir = () => {
+  let directory = process.cwd();
+  for (let depth = 0; depth < 10; depth++) {
+    const modules = join2(directory, "node_modules");
+    try {
+      if (statSync(modules).isDirectory()) {
+        return join2(modules, ".cache", "rasputin-transform", SDK_VERSION);
+      }
+    } catch {
+    }
+    const parent = dirname2(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  return void 0;
+};
+var resolveTransformCacheDir = () => process.env.RASPUTIN_TRANSFORM_CACHE_DIR ?? projectCacheDir() ?? join2(homedir(), ".cache", "rasputin", "transform", SDK_VERSION);
+var defaultCacheLimit = () => {
+  const parsed = Number(process.env.RASPUTIN_TRANSFORM_CACHE_MAX);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : 256;
+};
+var cacheEnabled = () => process.env.RASPUTIN_TRANSFORM_CACHE !== "0";
+var directoryIsWorldWritable = (directory) => {
+  try {
+    const stats = lstatSync(directory);
+    return !stats.isDirectory() || (stats.mode & 2) !== 0;
+  } catch {
+    return true;
+  }
+};
+var directoryOwnerTrusted = (directory) => {
+  if (process.platform === "win32") return true;
+  try {
+    const stats = lstatSync(directory);
+    const uid = process.getuid?.();
+    if (uid === void 0) return true;
+    return stats.uid === uid;
+  } catch {
+    return false;
+  }
+};
+var ensureTrustedCacheDir = (directory, explicit) => {
+  try {
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    try {
+      chmodSync(directory, 448);
+    } catch {
+    }
+    const stats = lstatSync(directory);
+    if (!stats.isDirectory()) return false;
+    if (explicit) return true;
+    if (process.platform === "win32") return true;
+    return !directoryIsWorldWritable(directory) && directoryOwnerTrusted(directory);
+  } catch {
+    return false;
+  }
+};
+var cacheKey = (source, filePath, verifyTransform) => createHash("sha256").update(SDK_VERSION).update("\0").update(filePath).update("\0").update(source).update("\0").update(sourceMapPayloadForCache(filePath, source)).update("\0").update(verifyTransform ? "1" : "0").digest("hex");
+var revive = (cached) => ({
+  code: cached.code,
+  delta: {
+    functions: cached.delta.functions.map((fn) => ({
+      ...fn,
+      instrumented: fn.instrumented !== false,
+      paramNames: new Set(fn.paramNames)
+    })),
+    callSites: cached.delta.callSites,
+    destructures: cached.delta.destructures
+  }
+});
+var persistable = (result) => ({
+  code: result.code,
+  delta: {
+    functions: result.delta.functions.map((fn) => ({
+      ...fn,
+      paramNames: [...fn.paramNames]
+    })),
+    callSites: result.delta.callSites,
+    destructures: result.delta.destructures
+  }
+});
+var evictOldest = (directory, keep) => {
+  const entries = readdirSync(directory).map((name) => {
+    const path = join2(directory, name);
+    try {
+      return { path, mtime: statSync(path).mtimeMs };
+    } catch {
+      return void 0;
+    }
+  }).filter((entry) => entry !== void 0).sort((left, right) => left.mtime - right.mtime);
+  while (entries.length > keep) {
+    const oldest = entries.shift();
+    if (!oldest) break;
+    try {
+      unlinkSync(oldest.path);
+    } catch {
+    }
+  }
+};
+var readCache = (directory, key) => {
+  try {
+    const parsed = JSON.parse(
+      readFileSync2(join2(directory, `${key}.json`), "utf8")
+    );
+    if (typeof parsed.code !== "string" || !parsed.delta) return void 0;
+    return revive(parsed);
+  } catch {
+    return void 0;
+  }
+};
+var writeCache = (directory, key, result, limit) => {
+  try {
+    const path = join2(directory, `${key}.json`);
+    writeFileSync(path, JSON.stringify(persistable(result)), { mode: 384 });
+    try {
+      chmodSync(path, 384);
+    } catch {
+    }
+    evictOldest(directory, limit);
+  } catch {
+  }
+};
+var transformSourceCached = (source, options, cache = {}) => {
+  const transformOptions = {
+    ...options,
+    verifyTransform: options.verifyTransform ?? process.env.RASPUTIN_VERIFY_TRANSFORM !== "0"
+  };
+  if (!cacheEnabled()) return transformSource(source, transformOptions);
+  const explicit = cache.directory !== void 0;
+  const directory = cache.directory ?? resolveTransformCacheDir();
+  if (!ensureTrustedCacheDir(directory, explicit)) return transformSource(source, transformOptions);
+  const key = cacheKey(source, options.filePath, transformOptions.verifyTransform === true);
+  const hit = readCache(directory, key);
+  if (hit) return hit;
+  const result = transformSource(source, transformOptions);
+  if (result) writeCache(directory, key, result, cache.limit ?? defaultCacheLimit());
+  return result;
 };
 
 // src/auto-instrumentation/bun-plugin.ts
@@ -1156,13 +1480,13 @@ var loaderFor = (filePath) => {
 var loadedSourceFilter = /^(?!.*[\\/](?:node_modules|dist|build|out|coverage|generated|\.git|\.next|\.svelte-kit|\.output|\.vercel|\.rasputin|\.turbo|\.yarn|\.pnpm|\.bun)[\\/]).*\.[cm]?[jt]sx?$/i;
 var isLoadedApplicationSource = (filePath, options = {}) => isApplicationSource(filePath, { ...options, includeBuildOutput: false });
 var loadSourceForInstrumentation = async (filePath, options = {}) => {
-  const absolutePath = resolve4(filePath);
+  const absolutePath = resolve5(filePath);
   const source = await readFile(absolutePath, "utf8");
   if (!isLoadedApplicationSource(absolutePath, options)) {
     return { contents: source, loader: loaderFor(absolutePath), transformed: false };
   }
   try {
-    const transformed = transformSource(source, { filePath: absolutePath });
+    const transformed = transformSourceCached(source, { filePath: absolutePath });
     if (transformed) {
       recordInstrumentationManifestDelta(absolutePath, transformed.delta);
     }
@@ -1171,7 +1495,11 @@ var loadSourceForInstrumentation = async (filePath, options = {}) => {
       loader: loaderFor(absolutePath),
       transformed: transformed !== void 0
     };
-  } catch {
+  } catch (error) {
+    if (options.debug ?? process.env.RASPUTIN_DEBUG === "1") {
+      const detail = error instanceof Error ? error.message : "unknown error";
+      console.info(`[rasputin] skipped instrumentation for ${absolutePath}: ${detail}`);
+    }
     return { contents: source, loader: loaderFor(absolutePath), transformed: false };
   }
 };
@@ -1182,11 +1510,11 @@ var createRasputinBunPlugin = (options = {}) => {
     setup(build) {
       if (debug) {
         console.info(
-          options.rootDir ? `[rasputin] automatic instrumentation active (source root: ${resolve4(options.rootDir)})` : "[rasputin] automatic instrumentation active (loaded local source)"
+          options.rootDir ? `[rasputin] automatic instrumentation active (source root: ${resolve5(options.rootDir)})` : "[rasputin] automatic instrumentation active (loaded local source)"
         );
       }
       build.onLoad({ filter: loadedSourceFilter }, async ({ path }) => {
-        const absolutePath = resolve4(path);
+        const absolutePath = resolve5(path);
         const result = await loadSourceForInstrumentation(absolutePath, options);
         if (debug && result.transformed) {
           console.info(`[rasputin] instrumented ${absolutePath}`);
@@ -1198,9 +1526,9 @@ var createRasputinBunPlugin = (options = {}) => {
 };
 
 // src/auto-instrumentation/sdk-source-boundary.ts
-import { dirname, resolve as resolve5 } from "node:path";
-import { fileURLToPath } from "node:url";
-var sdkPackageScopeRootFrom = (instrumentEntryUrl) => resolve5(dirname(fileURLToPath(instrumentEntryUrl)), "../../..");
+import { dirname as dirname3, resolve as resolve6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var sdkPackageScopeRootFrom = (instrumentEntryUrl) => resolve6(dirname3(fileURLToPath2(instrumentEntryUrl)), "../../..");
 
 // src/auto-instrumentation/warn-production-runtime-transform.ts
 var RUNTIME_TRANSFORM_WARNING_SUPPRESS_ENV = "RASPUTIN_SUPPRESS_RUNTIME_TRANSFORM_WARNING";
@@ -1211,7 +1539,7 @@ var warnIfProductionRuntimeTransform = () => {
   if (Reflect.get(globalThis, warnedSymbol)) return;
   Reflect.set(globalThis, warnedSymbol, true);
   console.warn(
-    "[rasputin] Production is using load-time source transformation (`--import` / `--preload`). Prefer build-time `rasputin-instrument` so the process does not load the TypeScript compiler. Set RASPUTIN_SUPPRESS_RUNTIME_TRANSFORM_WARNING=1 to hide this warning."
+    "[rasputin] This production process is wrapping source as it loads (`--import` / `--preload`). Instrument compiled output at build time with `rasputin-instrument` instead \u2014 wrapping at startup is slower and uses more memory. Set RASPUTIN_SUPPRESS_RUNTIME_TRANSFORM_WARNING=1 to hide this warning."
   );
 };