@rasputin-ai/node 0.4.1 → 0.5.0-alpha.10

package/dist/instrument/bun.js

@@ -12,25 +12,29 @@ import {
   sourceLocatorFromFile as sourceLocatorFromFile2
 } from "@rasputin-ai/core";
 
-// src/execution-recorder/automatic-runtime.ts
+// src/execution-recorder/function-plan.ts
 import {
   runtimeFunctionId,
   sourceLocatorFromFile
 } from "@rasputin-ai/core";
-var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
-var AUTOMATIC_SOURCE_PREFIX = "rasputin-source-v2:";
-var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
-var encodeAutomaticFunctionSource = (source) => {
+var encodeFunctionPlan = (source) => {
   const locator = sourceLocatorFromFile(source.filePath);
-  const value = {
+  const definition = {
     name: source.name,
     ...locator ? { source: { ...locator, line: source.line, column: source.column } } : {}
   };
-  return `${AUTOMATIC_SOURCE_PREFIX}${JSON.stringify(value)}`;
+  return [
+    runtimeFunctionId(definition),
+    source.name,
+    locator?.packageName ?? null,
+    locator?.packageRelativePath ?? null,
+    source.line,
+    source.column
+  ];
 };
 
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
-var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v2";
+var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v3";
 var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
 var getRegistry = () => {
   const existing = Reflect.get(globalThis, registrySymbol);
@@ -84,16 +88,663 @@ var isApplicationSource = (filePath, options = {}) => {
 
 // src/auto-instrumentation/transform-source.ts
 import { resolve as resolve3 } from "node:path";
-import ts2 from "typescript";
+import ts3 from "typescript";
 
-// src/auto-instrumentation/collect-instrumentation-delta.ts
+// 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/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.moduleCallees.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++;
+  }
+};
+var analyzeOne = (node, functionId, name, sourceFile, moduleCallees) => {
+  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,
+    moduleCallees,
+    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 } : {}
+  };
+  return {
+    functionId,
+    name,
+    node,
+    plan,
+    captureWraps: ctx.fallback ? [] : ctx.captureWraps,
+    guardWraps: ctx.fallback ? [] : ctx.guardWraps,
+    callEdges: ctx.callEdges,
+    hasThrow: ctx.hasThrow,
+    hasCoercionGuard: ctx.hasCoercionGuard
+  };
+};
+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 moduleCallees = /* @__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,
+      moduleCallees
+    );
+    if (nameCounts.get(result.name) === 1) {
+      moduleCallees.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, moduleCallees)
+    );
+  }
+  return analyzed;
+};
+
+// src/derivation/derivation-proof.ts
+var functionIsExact = (plan) => plan.fallbackReason === void 0 && plan.captureBoundaries.length === 0 && plan.controlFacts.length === 0;
+
+// 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/execution-recorder/automatic-runtime.ts
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v2";
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+
+// src/auto-instrumentation/collect-instrumentation-delta.ts
+import ts2 from "typescript";
 var paramBindingFromName = (name, sourceFile) => {
-  if (ts.isIdentifier(name)) return { kind: "identifier", name: name.text };
-  if (ts.isArrayBindingPattern(name)) {
+  if (ts2.isIdentifier(name)) return { kind: "identifier", name: name.text };
+  if (ts2.isArrayBindingPattern(name)) {
     const elements = name.elements.map(
       (element) => {
-        if (ts.isOmittedExpression(element)) return { kind: "omitted" };
+        if (ts2.isOmittedExpression(element)) return { kind: "omitted" };
         const binding = paramBindingFromName(element.name, sourceFile);
         if (element.dotDotDotToken) return { kind: "rest", binding };
         return binding;
@@ -103,7 +754,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, "") : ts.isIdentifier(element.name) ? element.name.text : element.name.getText(sourceFile);
+    const key = element.propertyName ? element.propertyName.getText(sourceFile).replace(/^['"]|['"]$/g, "") : ts2.isIdentifier(element.name) ? element.name.text : element.name.getText(sourceFile);
     if (element.dotDotDotToken) {
       const rest = { kind: "rest", binding };
       return { key, binding: rest };
@@ -115,7 +766,7 @@ var paramBindingFromName = (name, sourceFile) => {
 var collectFunctionParams = (node, sourceFile) => {
   const params = [];
   for (const parameter of node.parameters) {
-    if (ts.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    if (ts2.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
     const binding = paramBindingFromName(parameter.name, sourceFile);
     params.push(parameter.dotDotDotToken ? { kind: "rest", binding } : binding);
   }
@@ -156,18 +807,18 @@ var mappedLocation = (sourceFile, position, absolutePath, mapLocation) => {
 };
 var unwrapExpression = (expression) => {
   let current = expression;
-  while (ts.isParenthesizedExpression(current) || ts.isNonNullExpression(current)) {
+  while (ts2.isParenthesizedExpression(current) || ts2.isNonNullExpression(current)) {
     current = current.expression;
   }
-  if (ts.isAwaitExpression(current)) return unwrapExpression(current.expression);
+  if (ts2.isAwaitExpression(current)) return unwrapExpression(current.expression);
   return current;
 };
 var calleeFromExpression = (expression, sourceFile) => {
   const current = unwrapExpression(expression);
-  if (ts.isIdentifier(current)) {
+  if (ts2.isIdentifier(current)) {
     return { calleeName: current.text, calleeText: current.text };
   }
-  if (ts.isPropertyAccessExpression(current) && ts.isIdentifier(current.name)) {
+  if (ts2.isPropertyAccessExpression(current) && ts2.isIdentifier(current.name)) {
     return {
       calleeName: current.name.text,
       calleeText: current.getText(sourceFile).replace(/\s+/g, "")
@@ -177,9 +828,9 @@ var calleeFromExpression = (expression, sourceFile) => {
 };
 var resultBindingForCall = (call) => {
   let node = call.parent;
-  if (ts.isAwaitExpression(node)) node = node.parent;
-  if (!ts.isVariableDeclaration(node)) return null;
-  if (!ts.isIdentifier(node.name)) return null;
+  if (ts2.isAwaitExpression(node)) node = node.parent;
+  if (!ts2.isVariableDeclaration(node)) return null;
+  if (!ts2.isIdentifier(node.name)) return null;
   const initializer = node.initializer;
   if (!initializer) return null;
   const inner = unwrapExpression(initializer);
@@ -189,18 +840,18 @@ var resultBindingForCall = (call) => {
 var argIdentifiersForCall = (call) => {
   const identifiers = [];
   call.arguments?.forEach((argument, index) => {
-    if (ts.isIdentifier(argument)) {
+    if (ts2.isIdentifier(argument)) {
       identifiers.push({ index, kind: "identifier", name: argument.text });
       return;
     }
-    if (!ts.isObjectLiteralExpression(argument)) return;
+    if (!ts2.isObjectLiteralExpression(argument)) return;
     const properties = [];
     for (const property of argument.properties) {
-      if (ts.isShorthandPropertyAssignment(property)) {
+      if (ts2.isShorthandPropertyAssignment(property)) {
         properties.push({ key: property.name.text, name: property.name.text });
         continue;
       }
-      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && ts.isIdentifier(property.initializer)) {
+      if (ts2.isPropertyAssignment(property) && ts2.isIdentifier(property.name) && ts2.isIdentifier(property.initializer)) {
         properties.push({ key: property.name.text, name: property.initializer.text });
       }
     }
@@ -227,7 +878,7 @@ var collectCallSite = (call, caller, context) => {
   );
   if (!start || !end) return null;
   return {
-    callerSourceToken: caller.sourceToken,
+    callerFunctionId: caller.functionId,
     calleeName: callee.calleeName,
     calleeText: callee.calleeText,
     filePath: start.filePath,
@@ -240,8 +891,8 @@ var collectCallSite = (call, caller, context) => {
   };
 };
 var collectParamDestructure = (declaration, caller, context) => {
-  if (!declaration.initializer || !ts.isIdentifier(declaration.initializer)) return null;
-  if (!ts.isObjectBindingPattern(declaration.name) && !ts.isArrayBindingPattern(declaration.name)) {
+  if (!declaration.initializer || !ts2.isIdentifier(declaration.initializer)) return null;
+  if (!ts2.isObjectBindingPattern(declaration.name) && !ts2.isArrayBindingPattern(declaration.name)) {
     return null;
   }
   const sourceParam = declaration.initializer.text;
@@ -254,7 +905,7 @@ var collectParamDestructure = (declaration, caller, context) => {
   );
   if (!start) return null;
   return {
-    callerSourceToken: caller.sourceToken,
+    callerFunctionId: caller.functionId,
     sourceParam,
     filePath: start.filePath,
     line: start.line,
@@ -265,33 +916,33 @@ var collectParamDestructure = (declaration, caller, context) => {
 
 // src/auto-instrumentation/transform-source.ts
 var scriptKindFor = (filePath) => {
-  if (/\.tsx$/i.test(filePath)) return ts2.ScriptKind.TSX;
-  if (/\.jsx$/i.test(filePath)) return ts2.ScriptKind.JSX;
-  if (/\.[cm]?ts$/i.test(filePath)) return ts2.ScriptKind.TS;
-  return ts2.ScriptKind.JS;
+  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;
 };
 var functionName = (node, sourceFile) => {
   if (node.name) return node.name.getText(sourceFile).replace(/^['"]|['"]$/g, "");
   const parent = node.parent;
-  if (ts2.isVariableDeclaration(parent) && ts2.isIdentifier(parent.name)) return parent.name.text;
-  if (ts2.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
-  if (ts2.isPropertyDeclaration(parent) && parent.name) return parent.name.getText(sourceFile);
+  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);
   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 ((ts2.isVariableDeclaration(parent) || ts2.isPropertyAssignment(parent)) && parent.name) {
+  if ((ts3.isVariableDeclaration(parent) || ts3.isPropertyAssignment(parent)) && parent.name) {
     return parent.name.getStart(sourceFile);
   }
   return node.getStart(sourceFile);
 };
 var bindingValue = (name, sourceFile) => {
-  if (ts2.isIdentifier(name)) return name.text;
-  if (ts2.isArrayBindingPattern(name)) {
+  if (ts3.isIdentifier(name)) return name.text;
+  if (ts3.isArrayBindingPattern(name)) {
     const values = name.elements.map((element) => {
-      if (ts2.isOmittedExpression(element)) return "";
+      if (ts3.isOmittedExpression(element)) return "";
       const value = bindingValue(element.name, sourceFile);
       return element.dotDotDotToken ? `...${value}` : value;
     });
@@ -307,20 +958,40 @@ var bindingValue = (name, sourceFile) => {
 };
 var arrowArguments = (node) => {
   const values = node.parameters.flatMap((parameter) => {
-    if (ts2.isIdentifier(parameter.name) && parameter.name.text === "this") return [];
+    if (ts3.isIdentifier(parameter.name) && parameter.name.text === "this") return [];
     const value = bindingValue(parameter.name, node.getSourceFile());
     return [parameter.dotDotDotToken ? `...${value}` : value];
   });
   return `[${values.join(",")}]`;
 };
 var isSupportedFunction = (node) => {
-  if (!ts2.isFunctionDeclaration(node) && !ts2.isFunctionExpression(node) && !ts2.isArrowFunction(node) && !ts2.isMethodDeclaration(node) && !ts2.isGetAccessorDeclaration(node) && !ts2.isSetAccessorDeclaration(node)) {
+  if (!ts3.isFunctionDeclaration(node) && !ts3.isFunctionExpression(node) && !ts3.isArrowFunction(node) && !ts3.isMethodDeclaration(node) && !ts3.isGetAccessorDeclaration(node) && !ts3.isSetAccessorDeclaration(node)) {
     return false;
   }
   if (!node.body || "asteriskToken" in node && node.asteriskToken) return false;
   return true;
 };
-var helperDeclaration = (helperName) => `const ${helperName}=(functionId,args,callback)=>{const runtime=Reflect.get(globalThis,Symbol.for(${JSON.stringify(AUTOMATIC_RUNTIME_SYMBOL)}));return runtime?runtime.run(functionId,args,callback):callback()};`;
+var uniqueName = (source, base) => {
+  let name = base;
+  while (source.includes(name)) name += "_";
+  return name;
+};
+var isDirectivePrologue = (statement) => ts3.isExpressionStatement(statement) && ts3.isStringLiteral(statement.expression);
+var insertPositionAfterPrologue = (source, sourceFile) => {
+  const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
+  let end = shebangEnd;
+  for (const statement of sourceFile.statements) {
+    if (!isDirectivePrologue(statement)) break;
+    end = statement.end;
+  }
+  return end;
+};
+var preambleInsert = (source, position, preamble) => {
+  if (position <= 0) return 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 collectWrappedFunction = (node, sourceFile, absolutePath, mapLocation) => {
   const start = mappedLocation(
     sourceFile,
@@ -332,13 +1003,15 @@ var collectWrappedFunction = (node, sourceFile, absolutePath, mapLocation) => {
   const end = mappedLocation(sourceFile, node.end, absolutePath, mapLocation) ?? start;
   const name = functionName(node, sourceFile).replace(/@\d+:\d+$/, "");
   const { params, paramNames } = collectFunctionParams(node, sourceFile);
+  const plan = encodeFunctionPlan({
+    filePath: start.filePath,
+    name,
+    line: start.line,
+    column: start.column
+  });
   return {
-    sourceToken: encodeAutomaticFunctionSource({
-      filePath: start.filePath,
-      name,
-      line: start.line,
-      column: start.column
-    }),
+    plan,
+    functionId: plan[0],
     filePath: start.filePath,
     name,
     startLine: start.line,
@@ -349,74 +1022,130 @@ var collectWrappedFunction = (node, sourceFile, absolutePath, mapLocation) => {
     paramNames
   };
 };
+var canOmitCallValues = (analysis, analyzed) => {
+  if (!functionIsExact(analysis.plan) || analysis.hasThrow || analysis.hasCoercionGuard) {
+    return false;
+  }
+  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);
+};
 var transformSource = (source, options) => {
   if (source.includes("@rasputin-ignore-file")) return void 0;
-  const sourceFile = ts2.createSourceFile(
+  const sourceFile = ts3.createSourceFile(
     options.filePath,
     source,
-    ts2.ScriptTarget.Latest,
+    ts3.ScriptTarget.Latest,
     true,
     scriptKindFor(options.filePath)
   );
-  let helperName = "__rasputinAutoRun__";
-  while (source.includes(helperName)) helperName += "_";
+  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 edits = [];
   let order = 0;
   const delta = {
     functions: [],
     callSites: [],
-    destructures: []
+    destructures: [],
+    derivationPlans: []
   };
   const collectContext = {
     sourceFile,
     mapLocation: options.mapLocation,
     absolutePath
   };
+  const pending = [];
   const visit = (node, caller) => {
     if (isSupportedFunction(node)) {
       const collected = collectWrappedFunction(node, sourceFile, absolutePath, options.mapLocation);
       if (!collected) {
-        ts2.forEachChild(node, (child) => visit(child, caller));
+        ts3.forEachChild(node, (child) => visit(child, caller));
         return;
       }
+      pending.push({ node, collected });
       delta.functions.push(collected);
-      const args = ts2.isArrowFunction(node) ? arrowArguments(node) : "arguments";
-      const asyncCallback = node.modifiers?.some(
-        (modifier) => modifier.kind === ts2.SyntaxKind.AsyncKeyword
-      ) ? "async " : "";
-      if (ts2.isBlock(node.body)) {
-        edits.push({
-          position: node.body.getStart(sourceFile) + 1,
-          text: `return ${helperName}(${JSON.stringify(collected.sourceToken)},${args},${asyncCallback}()=>{`,
-          order: order++
-        });
-        edits.push({ position: node.body.end - 1, text: "});", order: order++ });
-      } else {
-        edits.push({
-          position: node.body.getStart(sourceFile),
-          text: `${helperName}(${JSON.stringify(collected.sourceToken)},${args},${asyncCallback}()=>(`,
-          order: order++
-        });
-        edits.push({ position: node.body.end, text: "))", order: order++ });
-      }
-      ts2.forEachChild(node, (child) => visit(child, collected));
+      ts3.forEachChild(node, (child) => visit(child, collected));
       return;
     }
-    if (caller && (ts2.isCallExpression(node) || ts2.isNewExpression(node))) {
+    if (caller && (ts3.isCallExpression(node) || ts3.isNewExpression(node))) {
       const site = collectCallSite(node, caller, collectContext);
       if (site) delta.callSites.push(site);
     }
-    if (caller && ts2.isVariableDeclaration(node)) {
+    if (caller && ts3.isVariableDeclaration(node)) {
       const destructure = collectParamDestructure(node, caller, collectContext);
       if (destructure) delta.destructures.push(destructure);
     }
-    ts2.forEachChild(node, (child) => visit(child, caller));
+    ts3.forEachChild(node, (child) => visit(child, caller));
   };
   visit(sourceFile);
-  if (edits.length === 0) return void 0;
-  const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
-  edits.push({ position: shebangEnd, text: helperDeclaration(helperName), order: -1 });
+  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]));
+  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 insertAt = insertPositionAfterPrologue(source, sourceFile);
+  edits.push({
+    position: insertAt,
+    text: preambleInsert(
+      source,
+      insertAt,
+      modulePreamble(
+        runName,
+        capName,
+        plansName,
+        JSON.stringify(delta.functions.map((fn) => fn.plan))
+      )
+    ),
+    order: -1
+  });
   edits.sort((left, right) => right.position - left.position || right.order - left.order);
   let transformed = source;
   for (const edit of edits) {
@@ -481,7 +1210,21 @@ import { dirname, resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
 var sdkPackageScopeRootFrom = (instrumentEntryUrl) => resolve5(dirname(fileURLToPath(instrumentEntryUrl)), "../../..");
 
+// src/auto-instrumentation/warn-production-runtime-transform.ts
+var RUNTIME_TRANSFORM_WARNING_SUPPRESS_ENV = "RASPUTIN_SUPPRESS_RUNTIME_TRANSFORM_WARNING";
+var warnedSymbol = Symbol.for("rasputin.runtimeTransformWarning");
+var warnIfProductionRuntimeTransform = () => {
+  if (process.env.NODE_ENV !== "production") return;
+  if (process.env[RUNTIME_TRANSFORM_WARNING_SUPPRESS_ENV] === "1") return;
+  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."
+  );
+};
+
 // src/instrument/bun.ts
+warnIfProductionRuntimeTransform();
 plugin(
   createRasputinBunPlugin({
     excludedRoots: [sdkPackageScopeRootFrom(import.meta.url)]