@rasputin-ai/node 0.5.2 → 0.6.0

package/dist/instrument/node.js

@@ -9,11 +9,7 @@ import {
   sourceLocatorFromFile as sourceLocatorFromFile2
 } from "@rasputin-ai/core";
 
-// src/execution-recorder/function-plan.ts
-import {
-  runtimeFunctionId,
-  sourceLocatorFromFile
-} from "@rasputin-ai/core";
+// ../recorder/src/encoded-function-plan.ts
 var withPreBodyParameterEvaluation = (plan) => [
   plan[0],
   plan[1],
@@ -24,6 +20,12 @@ var withPreBodyParameterEvaluation = (plan) => [
   plan[6],
   1
 ];
+
+// ../recorder/src/function-plan.ts
+import {
+  runtimeFunctionId,
+  sourceLocatorFromFile
+} from "@rasputin-ai/core";
 var encodeFunctionPlan = (source) => {
   const locator = sourceLocatorFromFile(source.filePath);
   const definition = {
@@ -40,6 +42,9 @@ var encodeFunctionPlan = (source) => {
   ];
 };
 
+// ../recorder/src/runtime-symbol.ts
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v3";
+
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
 var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v3";
 var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
@@ -180,19 +185,10 @@ import {
 import { homedir } from "node:os";
 import { dirname as dirname2, join as join2 } from "node:path";
 
-// src/sdk-meta.ts
-var SDK_VERSION = "0.5.2";
-
-// 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.v3";
-var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+// ../instrumentation/src/classify-function.ts
+import ts4 from "typescript";
 
-// src/auto-instrumentation/collect-instrumentation-delta.ts
+// ../instrumentation/src/collect-instrumentation-delta.ts
 import ts from "typescript";
 var paramBindingFromName = (name, sourceFile) => {
   if (ts.isIdentifier(name)) return { kind: "identifier", name: name.text };
@@ -369,41 +365,436 @@ var collectParamDestructure = (declaration, caller, context) => {
   };
 };
 
-// src/auto-instrumentation/parameter-initializer-may-run-code.ts
+// ../instrumentation/src/parse-source.ts
 import ts2 from "typescript";
-var unwrap = (expression) => {
-  let current = expression;
-  while (ts2.isParenthesizedExpression(current) || ts2.isNonNullExpression(current)) {
-    current = current.expression;
+
+// ../instrumentation/src/svelte-generated.ts
+import ts3 from "typescript";
+
+// ../instrumentation/src/edits.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 current;
+  return text;
 };
-var isSafeLiteralInitializer = (expression) => {
-  const current = unwrap(expression);
-  if (ts2.isNumericLiteral(current) || ts2.isStringLiteral(current) || ts2.isNoSubstitutionTemplateLiteral(current) || ts2.isBigIntLiteral(current)) {
-    return true;
+var uniqueName = (source, base) => {
+  let name = base;
+  while (source.includes(name)) name += "_";
+  return name;
+};
+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];
   }
-  if (current.kind === ts2.SyntaxKind.TrueKeyword || current.kind === ts2.SyntaxKind.FalseKeyword || current.kind === ts2.SyntaxKind.NullKeyword) {
-    return true;
+  if (left.kind === "close") {
+    if (left.width !== right.width) return right.width - left.width;
+    return left.depth - right.depth;
   }
-  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));
+  if (left.kind === "open") {
+    if (left.width !== right.width) return left.width - right.width;
+    return right.depth - left.depth;
   }
-  return false;
+  return 0;
 };
-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;
+var applyEdits = (source, edits) => {
+  const ordered = [...edits].sort(compareEdits);
+  let transformed = source;
+  for (const edit of ordered) {
+    const text = separateFromPreviousToken(transformed, edit.position, textOf(edit));
+    transformed = `${transformed.slice(0, edit.position)}${text}${transformed.slice(edit.position + edit.deleteCount)}`;
   }
-  return false;
+  return transformed;
 };
+var textOf = (edit) => edit.text;
 
-// src/auto-instrumentation/suspension-whitelist.ts
-import ts3 from "typescript";
-var nodeFlags = ts3.NodeFlags;
+// ../node_modules/.bun/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function encodeInteger(builder, num) {
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) clamped |= 32;
+    builder.write(intToChar[clamped]);
+  } while (num > 0);
+}
+function encodeSign(num) {
+  return num < 0 ? -num << 1 | 1 : num << 1;
+}
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+  decode(buf) {
+    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+    return out.toString();
+  }
+} : {
+  decode(buf) {
+    let out = "";
+    for (let i = 0; i < buf.length; i++) {
+      out += String.fromCharCode(buf[i]);
+    }
+    return out;
+  }
+};
+var StringWriter = class {
+  constructor() {
+    this.pos = 0;
+    this.out = "";
+    this.buffer = new Uint8Array(bufLength);
+  }
+  write(v) {
+    const { buffer } = this;
+    buffer[this.pos++] = v;
+    if (this.pos === bufLength) {
+      this.out += td.decode(buffer);
+      this.pos = 0;
+    }
+  }
+  flush() {
+    const { buffer, out, pos } = this;
+    return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+  }
+};
+function encode(decoded) {
+  const writer = new StringWriter();
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    if (i > 0) writer.write(semicolon);
+    if (line.length === 0) continue;
+    let genColumn = 0;
+    for (let j = 0; j < line.length; j++) {
+      const segment = line[j];
+      if (j > 0) writer.write(comma);
+      encodeInteger(writer, encodeSign(segment[0] - genColumn));
+      genColumn = segment[0];
+      if (segment.length === 1) continue;
+      encodeInteger(writer, encodeSign(segment[1] - sourcesIndex));
+      encodeInteger(writer, encodeSign(segment[2] - sourceLine));
+      encodeInteger(writer, encodeSign(segment[3] - sourceColumn));
+      sourcesIndex = segment[1];
+      sourceLine = segment[2];
+      sourceColumn = segment[3];
+      if (segment.length === 4) continue;
+      encodeInteger(writer, encodeSign(segment[4] - namesIndex));
+      namesIndex = segment[4];
+    }
+  }
+  return writer.flush();
+}
+
+// ../node_modules/.bun/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
+import { TraceMap as TraceMap2, decodedMappings } from "@jridgewell/trace-mapping";
+var SetArray = class {
+  constructor() {
+    this._indexes = { __proto__: null };
+    this.array = [];
+  }
+};
+function cast(set) {
+  return set;
+}
+function get(setarr, key) {
+  return cast(setarr)._indexes[key];
+}
+function put(setarr, key) {
+  const index = get(setarr, key);
+  if (index !== void 0) return index;
+  const { array, _indexes: indexes } = cast(setarr);
+  const length = array.push(key);
+  return indexes[key] = length - 1;
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var NO_NAME = -1;
+var GenMapping = class {
+  constructor({ file, sourceRoot } = {}) {
+    this._names = new SetArray();
+    this._sources = new SetArray();
+    this._sourcesContent = [];
+    this._mappings = [];
+    this.file = file;
+    this.sourceRoot = sourceRoot;
+    this._ignoreList = new SetArray();
+  }
+};
+function cast2(map) {
+  return map;
+}
+function addSegment(map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+  return addSegmentInternal(
+    false,
+    map,
+    genLine,
+    genColumn,
+    source,
+    sourceLine,
+    sourceColumn,
+    name,
+    content
+  );
+}
+function toDecodedMap(map) {
+  const {
+    _mappings: mappings,
+    _sources: sources,
+    _sourcesContent: sourcesContent,
+    _names: names,
+    _ignoreList: ignoreList
+    // _originalScopes: originalScopes,
+    // _generatedRanges: generatedRanges,
+  } = cast2(map);
+  removeEmptyFinalLines(mappings);
+  return {
+    version: 3,
+    file: map.file || void 0,
+    names: names.array,
+    sourceRoot: map.sourceRoot || void 0,
+    sources: sources.array,
+    sourcesContent,
+    mappings,
+    // originalScopes,
+    // generatedRanges,
+    ignoreList: ignoreList.array
+  };
+}
+function toEncodedMap(map) {
+  const decoded = toDecodedMap(map);
+  return Object.assign({}, decoded, {
+    // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)),
+    // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]),
+    mappings: encode(decoded.mappings)
+  });
+}
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+  const {
+    _mappings: mappings,
+    _sources: sources,
+    _sourcesContent: sourcesContent,
+    _names: names
+    // _originalScopes: originalScopes,
+  } = cast2(map);
+  const line = getIndex(mappings, genLine);
+  const index = getColumnIndex(line, genColumn);
+  if (!source) {
+    if (skipable && skipSourceless(line, index)) return;
+    return insert(line, index, [genColumn]);
+  }
+  assert(sourceLine);
+  assert(sourceColumn);
+  const sourcesIndex = put(sources, source);
+  const namesIndex = name ? put(names, name) : NO_NAME;
+  if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null;
+  if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+    return;
+  }
+  return insert(
+    line,
+    index,
+    name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]
+  );
+}
+function assert(_val) {
+}
+function getIndex(arr, index) {
+  for (let i = arr.length; i <= index; i++) {
+    arr[i] = [];
+  }
+  return arr[index];
+}
+function getColumnIndex(line, genColumn) {
+  let index = line.length;
+  for (let i = index - 1; i >= 0; index = i--) {
+    const current = line[i];
+    if (genColumn >= current[COLUMN]) break;
+  }
+  return index;
+}
+function insert(array, index, value) {
+  for (let i = array.length; i > index; i--) {
+    array[i] = array[i - 1];
+  }
+  array[index] = value;
+}
+function removeEmptyFinalLines(mappings) {
+  const { length } = mappings;
+  let len = length;
+  for (let i = len - 1; i >= 0; len = i, i--) {
+    if (mappings[i].length > 0) break;
+  }
+  if (len < length) mappings.length = len;
+}
+function skipSourceless(line, index) {
+  if (index === 0) return true;
+  const prev = line[index - 1];
+  return prev.length === 1;
+}
+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+  if (index === 0) return false;
+  const prev = line[index - 1];
+  if (prev.length === 1) return false;
+  return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
+}
+
+// ../instrumentation/src/exact-transform-map.ts
+import { originalPositionFor as originalPositionFor2, TraceMap as TraceMap3 } from "@jridgewell/trace-mapping";
+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 TraceMap3(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 map = new GenMapping({ file });
+  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 source = sources[0] ?? file;
+    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) {
+        source = mapped.source;
+        mappedLine = mapped.line - 1;
+        mappedColumn = mapped.column;
+      }
+    }
+    const key = `${generatedPosition.line}:${generatedPosition.column}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    addSegment(
+      map,
+      generatedPosition.line,
+      generatedPosition.column,
+      source,
+      mappedLine,
+      mappedColumn
+    );
+  }
+  const encoded = toEncodedMap(map);
+  return {
+    sources: encoded.sources.filter((source) => Boolean(source)),
+    mappings: encoded.mappings
+  };
+};
+var attachInlineSourceMap = (original, generated, filePath, edits, basenameOf) => {
+  const file = basenameOf(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}`;
+};
+
+// ../instrumentation/src/browser-function-edits.ts
+import { propertyNameIsSensitive } from "@rasputin-ai/core";
+import ts10 from "typescript";
+
+// ../instrumentation/src/suspension-whitelist.ts
+import ts5 from "typescript";
+var nodeFlags = ts5.NodeFlags;
 var AWAIT_USING_FLAG = nodeFlags.AwaitUsing ?? 0;
 var USING_FLAG = nodeFlags.Using ?? 0;
 var KNOWN_SUSPENSION_KIND_NAMES = [
@@ -413,8 +804,8 @@ var KNOWN_SUSPENSION_KIND_NAMES = [
   "YieldKeyword",
   "UsingKeyword"
 ];
-var isFunctionLike = (node) => ts3.isFunctionLike(node);
-var isAsyncFunctionLike = (node) => (ts3.getCombinedModifierFlags(node) & ts3.ModifierFlags.Async) !== 0;
+var isFunctionLike = (node) => ts5.isFunctionLike(node);
+var isAsyncFunctionLike = (node) => (ts5.getCombinedModifierFlags(node) & ts5.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) => {
@@ -425,7 +816,7 @@ var visitOwnBody = (node, visitNode) => {
       return;
     }
     if (visitNode(candidate)) return;
-    ts3.forEachChild(candidate, visit);
+    ts5.forEachChild(candidate, visit);
   };
   visit(node.body);
 };
@@ -453,16 +844,16 @@ var slicesOutside = (start, end, spans) => {
 };
 var sliceHasAwaitKeyword = (source, start, end) => {
   if (end <= start) return false;
-  const scanner = ts3.createScanner(
-    ts3.ScriptTarget.Latest,
+  const scanner = ts5.createScanner(
+    ts5.ScriptTarget.Latest,
     true,
-    ts3.LanguageVariant.Standard,
+    ts5.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;
+    if (token === ts5.SyntaxKind.EndOfFileToken) return false;
+    if (token === ts5.SyntaxKind.AwaitKeyword) return true;
   }
 };
 var ownBodyHasAwaitKeyword = (node, sourceFile) => {
@@ -480,7 +871,7 @@ var isAwaitUsingList = (node) => {
   return (node.flags & AWAIT_USING_FLAG) === AWAIT_USING_FLAG && (node.flags & USING_FLAG) !== 0;
 };
 var unknownSuspensionKind = (node) => {
-  const name = ts3.SyntaxKind[node.kind];
+  const name = ts5.SyntaxKind[node.kind];
   if (typeof name !== "string" || !/Await|Yield|Using/.test(name)) return false;
   return !KNOWN_SUSPENSION_KIND_NAMES.includes(name);
 };
@@ -493,9 +884,9 @@ var ownSuspensionFacts = (node, sourceFile) => {
     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)) {
+    if (ts5.isAwaitExpression(candidate)) facts.awaitExpressions = true;
+    if (ts5.isForOfStatement(candidate) && candidate.awaitModifier) facts.forAwait = true;
+    if (ts5.isVariableDeclarationList(candidate) && isAwaitUsingList(candidate)) {
       facts.awaitUsing = true;
     }
     if (unknownSuspensionKind(candidate)) facts.unknown = true;
@@ -506,7 +897,7 @@ var ownSuspensionFacts = (node, sourceFile) => {
 var bodyHasDirectEval = (node) => {
   let found = false;
   visitOwnBody(node, (candidate) => {
-    if (ts3.isCallExpression(candidate) && ts3.isIdentifier(candidate.expression) && candidate.expression.text === "eval") {
+    if (ts5.isCallExpression(candidate) && ts5.isIdentifier(candidate.expression) && candidate.expression.text === "eval") {
       found = true;
     }
     return found;
@@ -528,25 +919,61 @@ var decideAsyncInstrumentation = (node, sourceFile) => {
   return { action: "inline" };
 };
 
-// src/auto-instrumentation/verify-instrumentation-isomorphism.ts
-import ts4 from "typescript";
+// ../instrumentation/src/transform-source.ts
+import { basename, resolve as resolve4 } from "node:path";
+import ts9 from "typescript";
+
+// ../instrumentation/src/parameter-initializer-may-run-code.ts
+import ts6 from "typescript";
+var unwrap = (expression) => {
+  let current = expression;
+  while (ts6.isParenthesizedExpression(current) || ts6.isNonNullExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+};
+var isSafeLiteralInitializer = (expression) => {
+  const current = unwrap(expression);
+  if (ts6.isNumericLiteral(current) || ts6.isStringLiteral(current) || ts6.isNoSubstitutionTemplateLiteral(current) || ts6.isBigIntLiteral(current)) {
+    return true;
+  }
+  if (current.kind === ts6.SyntaxKind.TrueKeyword || current.kind === ts6.SyntaxKind.FalseKeyword || current.kind === ts6.SyntaxKind.NullKeyword) {
+    return true;
+  }
+  if (ts6.isIdentifier(current) && current.text === "undefined") return true;
+  if (ts6.isPrefixUnaryExpression(current) && (current.operator === ts6.SyntaxKind.PlusToken || current.operator === ts6.SyntaxKind.MinusToken)) {
+    return ts6.isNumericLiteral(unwrap(current.operand));
+  }
+  return false;
+};
+var functionHasPreBodyParameterEvaluation = (node) => {
+  for (const parameter of node.parameters) {
+    if (ts6.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    if (!parameter.initializer) continue;
+    if (!isSafeLiteralInitializer(parameter.initializer)) return true;
+  }
+  return false;
+};
+
+// ../instrumentation/src/verify-instrumentation-isomorphism.ts
+import ts7 from "typescript";
 var RASPUTIN_IDENT = /^__rasputin/;
 var scriptKindFor = (filePath) => {
-  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;
+  if (/\.tsx$/i.test(filePath)) return ts7.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts7.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts7.ScriptKind.TS;
+  return ts7.ScriptKind.JS;
 };
-var parse = (filePath, source) => ts4.createSourceFile(filePath, source, ts4.ScriptTarget.Latest, true, scriptKindFor(filePath));
+var parse = (filePath, source) => ts7.createSourceFile(filePath, source, ts7.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;
+  if (ts7.isIdentifier(node)) return node.text;
+  if (ts7.isPrivateIdentifier(node)) return node.text;
   return void 0;
 };
 var calleeName = (expression) => {
-  if (ts4.isIdentifier(expression)) return expression.text;
-  if (ts4.isPropertyAccessExpression(expression)) {
+  if (ts7.isIdentifier(expression)) return expression.text;
+  if (ts7.isPropertyAccessExpression(expression)) {
     const object = identText(expression.expression);
     const property = identText(expression.name);
     if (object && isRasputinName(object) && property) return `${object}.${property}`;
@@ -554,7 +981,7 @@ var calleeName = (expression) => {
   return void 0;
 };
 var isRasputinCall = (node, methods) => {
-  if (!ts4.isCallExpression(node)) return false;
+  if (!ts7.isCallExpression(node)) return false;
   const name = calleeName(node.expression);
   if (!name) return false;
   if (isRasputinName(name)) return !methods || methods.has(name.split(".")[1] ?? "");
@@ -564,20 +991,20 @@ 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 (ts7.isParenthesizedExpression(current)) current = current.expression;
   }
-  if (ts4.isParenthesizedExpression(current)) return current.expression;
+  if (ts7.isParenthesizedExpression(current)) return current.expression;
   return current;
 };
 var isRasputinStatement = (node) => {
-  if (ts4.isEmptyStatement(node)) return true;
-  if (ts4.isVariableStatement(node)) {
+  if (ts7.isEmptyStatement(node)) return true;
+  if (ts7.isVariableStatement(node)) {
     return node.declarationList.declarations.every((declaration) => {
       const name = identText(declaration.name);
       return Boolean(name && isRasputinName(name));
     });
   }
-  if (ts4.isExpressionStatement(node)) {
+  if (ts7.isExpressionStatement(node)) {
     if (!isRasputinCall(node.expression)) return false;
     const unwrapped = unwrapCall(node.expression);
     return unwrapped === node.expression;
@@ -591,7 +1018,7 @@ var isRasputinTryWrapper = (node) => {
     (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);
+  const leftoverThrow = catchCalls.length === 1 && leftover !== void 0 && ts7.isThrowStatement(leftover) && ts7.isIdentifier(leftover.expression) && isRasputinName(leftover.expression.text);
   if (!leftoverThrow && catchCalls.length > 0) return false;
   return node.finallyBlock.statements.every((statement) => isRasputinStatement(statement));
 };
@@ -599,7 +1026,7 @@ var flattenStatements = (statements) => {
   const flattened = [];
   for (const statement of statements) {
     if (isRasputinStatement(statement)) continue;
-    if (ts4.isTryStatement(statement) && isRasputinTryWrapper(statement)) {
+    if (ts7.isTryStatement(statement) && isRasputinTryWrapper(statement)) {
       flattened.push(...flattenStatements(statement.tryBlock.statements));
       continue;
     }
@@ -608,38 +1035,38 @@ var flattenStatements = (statements) => {
   return flattened;
 };
 var extra = (node) => {
-  if (ts4.isIdentifier(node) || ts4.isPrivateIdentifier(node)) {
+  if (ts7.isIdentifier(node) || ts7.isPrivateIdentifier(node)) {
     return isRasputinName(node.text) ? "" : node.text;
   }
-  if (ts4.isStringLiteral(node) || ts4.isNumericLiteral(node) || ts4.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts7.isStringLiteral(node) || ts7.isNumericLiteral(node) || ts7.isNoSubstitutionTemplateLiteral(node)) {
     return node.text;
   }
-  if (ts4.isToken(node) && !ts4.isIdentifier(node)) return ts4.SyntaxKind[node.kind] ?? "";
+  if (ts7.isToken(node) && !ts7.isIdentifier(node)) return ts7.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)) {
+  if (ts7.isEmptyStatement(unwrapped) || isRasputinStatement(unwrapped)) return "";
+  if (ts7.isTryStatement(unwrapped) && isRasputinTryWrapper(unwrapped)) {
     return flattenStatements(unwrapped.tryBlock.statements).map(signatureOf).filter(Boolean).join("");
   }
-  if (ts4.isBlock(unwrapped)) {
+  if (ts7.isBlock(unwrapped)) {
     const statements = flattenStatements(unwrapped.statements);
     return `Block[${statements.map(signatureOf).filter(Boolean).join(",")}]`;
   }
-  if (ts4.isCatchClause(unwrapped)) {
+  if (ts7.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)) {
+  if (ts7.isArrowFunction(unwrapped) && ts7.isBlock(unwrapped.body)) {
     const statements = flattenStatements(unwrapped.body.statements);
     const only = statements[0];
-    if (statements.length === 1 && only && ts4.isReturnStatement(only) && only.expression) {
+    if (statements.length === 1 && only && ts7.isReturnStatement(only) && only.expression) {
       const expression = only.expression;
       const parts2 = [];
-      ts4.forEachChild(unwrapped, (child) => {
+      ts7.forEachChild(unwrapped, (child) => {
         if (child === unwrapped.body) {
           const part2 = signatureOf(expression);
           if (part2) parts2.push(part2);
@@ -652,11 +1079,11 @@ var signatureOf = (node) => {
     }
   }
   const parts = [];
-  ts4.forEachChild(unwrapped, (child) => {
+  ts7.forEachChild(unwrapped, (child) => {
     const part = signatureOf(child);
     if (part) parts.push(part);
   });
-  const kind = ts4.SyntaxKind[unwrapped.kind] ?? "Node";
+  const kind = ts7.SyntaxKind[unwrapped.kind] ?? "Node";
   const label = extra(unwrapped);
   return `${kind}${label}[${parts.join(",")}]`;
 };
@@ -664,15 +1091,15 @@ 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, {
+// ../instrumentation/src/verify-transformed-source.ts
+import ts8 from "typescript";
+var transpileForVerification = (filePath, code) => ts8.transpileModule(code, {
   compilerOptions: {
     // ES2020 downlevel keeps native @decorators out of `new Function`.
-    target: ts5.ScriptTarget.ES2020,
-    module: ts5.ModuleKind.ESNext,
+    target: ts8.ScriptTarget.ES2020,
+    module: ts8.ModuleKind.ESNext,
     allowJs: true,
-    jsx: ts5.JsxEmit.React,
+    jsx: ts8.JsxEmit.React,
     experimentalDecorators: true
   },
   reportDiagnostics: true,
@@ -680,7 +1107,7 @@ var transpileForVerification = (filePath, code) => ts5.transpileModule(code, {
 });
 var hasScanOrParseError = (diagnostics) => Boolean(
   diagnostics?.some(
-    (diagnostic) => diagnostic.category === ts5.DiagnosticCategory.Error && diagnostic.code < 2e3
+    (diagnostic) => diagnostic.category === ts8.DiagnosticCategory.Error && diagnostic.code < 2e3
   )
 );
 var scriptBodyForEngine = (emitted) => (
@@ -689,39 +1116,39 @@ var scriptBodyForEngine = (emitted) => (
 );
 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;
+  if (/\.tsx$/i.test(filePath)) return ts8.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts8.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts8.ScriptKind.TS;
+  return ts8.ScriptKind.JS;
 };
-var isIterationStatement = (node) => ts5.isForStatement(node) || ts5.isForOfStatement(node) || ts5.isForInStatement(node) || ts5.isWhileStatement(node) || ts5.isDoStatement(node);
+var isIterationStatement = (node) => ts8.isForStatement(node) || ts8.isForOfStatement(node) || ts8.isForInStatement(node) || ts8.isWhileStatement(node) || ts8.isDoStatement(node);
 var unwrapLabeled = (node) => {
   let current = node;
-  while (ts5.isLabeledStatement(current)) current = current.statement;
+  while (ts8.isLabeledStatement(current)) current = current.statement;
   return current;
 };
 var hasInvalidLabelJump = (sourceFile) => {
   const visit = (node, labels) => {
-    if (ts5.isFunctionLike(node)) {
+    if (ts8.isFunctionLike(node)) {
       let nestedInvalid = false;
-      ts5.forEachChild(node, (child) => {
+      ts8.forEachChild(node, (child) => {
         if (visit(child, /* @__PURE__ */ new Map())) nestedInvalid = true;
       });
       return nestedInvalid;
     }
-    if (ts5.isLabeledStatement(node)) {
+    if (ts8.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 (ts8.isContinueStatement(node) && node.label) {
       if (labels.get(node.label.text) !== true) return true;
     }
-    if (ts5.isBreakStatement(node) && node.label && !labels.has(node.label.text)) {
+    if (ts8.isBreakStatement(node) && node.label && !labels.has(node.label.text)) {
       return true;
     }
     let invalid = false;
-    ts5.forEachChild(node, (child) => {
+    ts8.forEachChild(node, (child) => {
       if (visit(child, labels)) invalid = true;
     });
     return invalid;
@@ -764,10 +1191,10 @@ 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(
+  const sourceFile = ts8.createSourceFile(
     filePath,
     code,
-    ts5.ScriptTarget.Latest,
+    ts8.ScriptTarget.Latest,
     true,
     scriptKindFor2(filePath)
   );
@@ -779,16 +1206,7 @@ var transformedSourceIsInvalid = (filePath, code) => {
   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;
-};
+// ../instrumentation/src/transform-source.ts
 var RASPUTIN_INSTRUMENTATION_MARKER = "rasputin.instrumented.v3";
 var RASPUTIN_INSTRUMENTATION_PREAMBLE = `/*${RASPUTIN_INSTRUMENTATION_MARKER}*/`;
 var sourceIsRasputinInstrumented = (source) => source.includes(RASPUTIN_INSTRUMENTATION_PREAMBLE);
@@ -797,25 +1215,25 @@ var alreadyInstrumentedResult = (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;
+  if (/\.tsx$/i.test(filePath)) return ts9.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts9.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts9.ScriptKind.TS;
+  return ts9.ScriptKind.JS;
 };
 var functionName = (node, sourceFile) => {
-  if (ts6.isConstructorDeclaration(node)) return "constructor";
+  if (ts9.isConstructorDeclaration(node)) return "constructor";
   if (node.name) return node.name.getText(sourceFile).replace(/^['"]|['"]$/g, "");
   const parent = node.parent;
-  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);
+  if (ts9.isVariableDeclaration(parent) && ts9.isIdentifier(parent.name)) return parent.name.text;
+  if (ts9.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
+  if (ts9.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 ((ts6.isVariableDeclaration(parent) || ts6.isPropertyAssignment(parent)) && parent.name) {
+  if ((ts9.isVariableDeclaration(parent) || ts9.isPropertyAssignment(parent)) && parent.name) {
     return parent.name.getStart(sourceFile);
   }
   return node.getStart(sourceFile);
@@ -828,12 +1246,12 @@ var functionBodyPrologueEnd = (body, sourceFile) => {
   }
   return end;
 };
-var isStaticPropertyName = (name) => ts6.isIdentifier(name) || ts6.isStringLiteral(name) || ts6.isNoSubstitutionTemplateLiteral(name) || ts6.isNumericLiteral(name);
+var isStaticPropertyName = (name) => ts9.isIdentifier(name) || ts9.isStringLiteral(name) || ts9.isNoSubstitutionTemplateLiteral(name) || ts9.isNumericLiteral(name);
 var canReconstructBinding = (name) => {
-  if (ts6.isIdentifier(name)) return true;
-  if (ts6.isArrayBindingPattern(name)) {
+  if (ts9.isIdentifier(name)) return true;
+  if (ts9.isArrayBindingPattern(name)) {
     return name.elements.every(
-      (element) => ts6.isOmittedExpression(element) || canReconstructBinding(element.name)
+      (element) => ts9.isOmittedExpression(element) || canReconstructBinding(element.name)
     );
   }
   return name.elements.every((element) => {
@@ -842,10 +1260,10 @@ var canReconstructBinding = (name) => {
   });
 };
 var bindingValue = (name, sourceFile) => {
-  if (ts6.isIdentifier(name)) return name.text;
-  if (ts6.isArrayBindingPattern(name)) {
+  if (ts9.isIdentifier(name)) return name.text;
+  if (ts9.isArrayBindingPattern(name)) {
     const values = name.elements.map((element) => {
-      if (ts6.isOmittedExpression(element)) return "";
+      if (ts9.isOmittedExpression(element)) return "";
       const value = bindingValue(element.name, sourceFile);
       return element.dotDotDotToken ? `...${value}` : value;
     });
@@ -855,7 +1273,7 @@ var bindingValue = (name, sourceFile) => {
     const value = bindingValue(element.name, sourceFile);
     if (element.dotDotDotToken) return `...${value}`;
     if (!element.propertyName) return value;
-    const key = ts6.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText(sourceFile);
+    const key = ts9.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText(sourceFile);
     return `${key}:${value}`;
   });
   return `{${properties.join(",")}}`;
@@ -863,7 +1281,7 @@ var bindingValue = (name, sourceFile) => {
 var arrowArgsCapture = (node) => {
   const sourceFile = node.getSourceFile();
   const params = node.parameters.filter(
-    (parameter) => !(ts6.isIdentifier(parameter.name) && parameter.name.text === "this")
+    (parameter) => !(ts9.isIdentifier(parameter.name) && parameter.name.text === "this")
   );
   if (!params.every((parameter) => canReconstructBinding(parameter.name))) {
     return {
@@ -878,18 +1296,13 @@ var arrowArgsCapture = (node) => {
   return { args: `[${values.join(",")}]`, omitValues: false };
 };
 var isSupportedFunction = (node) => {
-  if (!ts6.isFunctionDeclaration(node) && !ts6.isFunctionExpression(node) && !ts6.isArrowFunction(node) && !ts6.isMethodDeclaration(node) && !ts6.isGetAccessorDeclaration(node) && !ts6.isSetAccessorDeclaration(node)) {
+  if (!ts9.isFunctionDeclaration(node) && !ts9.isFunctionExpression(node) && !ts9.isArrowFunction(node) && !ts9.isMethodDeclaration(node) && !ts9.isGetAccessorDeclaration(node) && !ts9.isSetAccessorDeclaration(node)) {
     return false;
   }
   if (!node.body || "asteriskToken" in node && node.asteriskToken) return false;
   return true;
 };
-var uniqueName = (source, base) => {
-  let name = base;
-  while (source.includes(name)) name += "_";
-  return name;
-};
-var isDirectivePrologue = (statement) => ts6.isExpressionStatement(statement) && ts6.isStringLiteral(statement.expression);
+var isDirectivePrologue = (statement) => ts9.isExpressionStatement(statement) && ts9.isStringLiteral(statement.expression);
 var insertPositionAfterPrologue = (source, sourceFile) => {
   const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
   let end = shebangEnd;
@@ -936,178 +1349,11 @@ var collectWrappedFunction = (node, sourceFile, absolutePath, mapLocation) => {
     instrumented: true
   };
 };
-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];
-  }
-  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) {
+    if (ts9.isExpressionStatement(statement) && ts9.isCallExpression(statement.expression) && statement.expression.expression.kind === ts9.SyntaxKind.SuperKeyword) {
       return statement.end;
     }
     break;
@@ -1118,15 +1364,15 @@ var failEpilogue = (handleName, errorName, args, restoreOnCatch) => `}catch(${er
 var walkOwnBody = (node, visitNode) => {
   if (!node.body) return;
   const visit = (candidate) => {
-    if (candidate !== node && ts6.isFunctionLike(candidate)) return;
+    if (candidate !== node && ts9.isFunctionLike(candidate)) return;
     visitNode(candidate);
-    ts6.forEachChild(candidate, visit);
+    ts9.forEachChild(candidate, visit);
   };
   visit(node.body);
 };
 var collectAwaitWraps = (node, sourceFile, handleName, edits, depth) => {
   walkOwnBody(node, (candidate) => {
-    if (!ts6.isAwaitExpression(candidate)) return;
+    if (!ts9.isAwaitExpression(candidate)) return;
     wrap(
       edits,
       candidate.expression.getStart(sourceFile),
@@ -1147,7 +1393,7 @@ var collectAwaitWraps = (node, sourceFile, handleName, edits, depth) => {
 };
 var collectCatchFinallyResumes = (node, sourceFile, handleName, edits, depth) => {
   walkOwnBody(node, (candidate) => {
-    if (!ts6.isTryStatement(candidate)) return;
+    if (!ts9.isTryStatement(candidate)) return;
     const blocks = [candidate.catchClause?.block, candidate.finallyBlock];
     for (const block of blocks) {
       if (!block) continue;
@@ -1163,10 +1409,10 @@ var collectCatchFinallyResumes = (node, sourceFile, handleName, edits, depth) =>
   });
 };
 var collectReturnWraps = (node, sourceFile, handleName, edits, depth) => {
-  if (!node.body || !ts6.isBlock(node.body)) return;
+  if (!node.body || !ts9.isBlock(node.body)) return;
   const visit = (candidate, at) => {
-    if (candidate !== node && ts6.isFunctionLike(candidate)) return;
-    if (ts6.isReturnStatement(candidate) && candidate.expression) {
+    if (candidate !== node && ts9.isFunctionLike(candidate)) return;
+    if (ts9.isReturnStatement(candidate) && candidate.expression) {
       const expression = candidate.expression;
       wrap(
         edits,
@@ -1178,17 +1424,17 @@ var collectReturnWraps = (node, sourceFile, handleName, edits, depth) => {
       );
       return;
     }
-    ts6.forEachChild(candidate, (child) => visit(child, at + 1));
+    ts9.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;
   if (sourceIsRasputinInstrumented(source)) return alreadyInstrumentedResult(source);
-  const sourceFile = ts6.createSourceFile(
+  const sourceFile = ts9.createSourceFile(
     options.filePath,
     source,
-    ts6.ScriptTarget.Latest,
+    ts9.ScriptTarget.Latest,
     true,
     scriptKindFor3(options.filePath)
   );
@@ -1231,7 +1477,7 @@ var transformSource = (source, options) => {
         collected.asyncFunction = true;
         skipFunction(collected, "unsupported_async_generator");
       }
-      ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
+      ts9.forEachChild(node, (child) => visit(child, caller, depth + 1));
       return;
     }
     if (isSyncGeneratorLike(node) && node.body) {
@@ -1242,10 +1488,10 @@ var transformSource = (source, options) => {
         options.mapLocation
       );
       if (collected) skipFunction(collected, "unsupported_sync_generator");
-      ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
+      ts9.forEachChild(node, (child) => visit(child, caller, depth + 1));
       return;
     }
-    if (ts6.isConstructorDeclaration(node) && node.body) {
+    if (ts9.isConstructorDeclaration(node) && node.body) {
       const collected = collectWrappedFunction(
         node,
         sourceFile,
@@ -1253,13 +1499,13 @@ var transformSource = (source, options) => {
         options.mapLocation
       );
       if (collected) skipFunction(collected, "unsupported_constructor");
-      ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
+      ts9.forEachChild(node, (child) => visit(child, caller, depth + 1));
       return;
     }
     if (isSupportedFunction(node)) {
       const collected = collectWrappedFunction(node, sourceFile, absolutePath, options.mapLocation);
       if (!collected) {
-        ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
+        ts9.forEachChild(node, (child) => visit(child, caller, depth + 1));
         return;
       }
       const asyncFunction = isAsyncFunctionLike(node);
@@ -1267,7 +1513,7 @@ var transformSource = (source, options) => {
       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));
+        ts9.forEachChild(node, (child) => visit(child, caller, depth + 1));
         return;
       }
       if (functionHasPreBodyParameterEvaluation(node)) {
@@ -1280,29 +1526,29 @@ var transformSource = (source, options) => {
         suspendResume: decision.action === "suspend_resume"
       });
       delta.functions.push(collected);
-      ts6.forEachChild(node, (child) => visit(child, collected, depth + 1));
+      ts9.forEachChild(node, (child) => visit(child, collected, depth + 1));
       return;
     }
-    if (caller && (ts6.isCallExpression(node) || ts6.isNewExpression(node))) {
+    if (caller && (ts9.isCallExpression(node) || ts9.isNewExpression(node))) {
       const site = collectCallSite(node, caller, collectContext);
       if (site) delta.callSites.push(site);
     }
-    if (caller && ts6.isVariableDeclaration(node)) {
+    if (caller && ts9.isVariableDeclaration(node)) {
       const destructure = collectParamDestructure(node, caller, collectContext);
       if (destructure) delta.destructures.push(destructure);
     }
-    ts6.forEachChild(node, (child) => visit(child, caller, depth + 1));
+    ts9.forEachChild(node, (child) => visit(child, caller, depth + 1));
   };
   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 captured = ts6.isArrowFunction(entry.node) ? arrowArgsCapture(entry.node) : { args: "arguments", omitValues: false };
+    const captured = ts9.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)) {
+    if (ts9.isBlock(entry.node.body)) {
       const prologueAt = insertAfterSuperOrPrologue(entry.node.body, sourceFile);
       const closeAt = entry.node.body.end - 1;
       wrap(
@@ -1356,12 +1602,7 @@ var transformSource = (source, options) => {
     width: 0,
     kind: "replace"
   });
-  edits.sort(compareEdits);
-  let transformed = source;
-  for (const edit of edits) {
-    const text = separateFromPreviousToken(transformed, edit.position, edit.text);
-    transformed = `${transformed.slice(0, edit.position)}${text}${transformed.slice(edit.position + edit.deleteCount)}`;
-  }
+  const transformed = applyEdits(source, edits);
   const verify = options.verifyTransform ?? true;
   const refuseTransformed = () => {
     for (const entry of pending) {
@@ -1389,9 +1630,34 @@ var transformSource = (source, options) => {
   if (verify && !instrumentationTreesAreIsomorphic(options.filePath, source, transformed)) {
     return refuseTransformed();
   }
-  return { code: attachInlineSourceMap(source, transformed, options.filePath, edits), delta };
+  return {
+    code: attachInlineSourceMap(source, transformed, options.filePath, edits, basename),
+    delta
+  };
 };
 
+// ../instrumentation/src/json-producer-sites.ts
+import ts11 from "typescript";
+
+// ../instrumentation/src/literal-sites.ts
+import ts12 from "typescript";
+
+// ../instrumentation/src/observe-sites.ts
+import { propertyNameIsSensitive as propertyNameIsSensitive2 } from "@rasputin-ai/core";
+import ts13 from "typescript";
+
+// ../instrumentation/src/verify-browser-source.ts
+import ts14 from "typescript";
+
+// ../instrumentation/src/provenance-function-edits.ts
+import ts15 from "typescript";
+
+// ../instrumentation/src/source-map-location.ts
+import { originalPositionFor as originalPositionFor3, TraceMap as TraceMap4 } from "@jridgewell/trace-mapping";
+
+// src/sdk-meta.ts
+var SDK_VERSION = "0.6.0";
+
 // src/auto-instrumentation/transform-disk-cache.ts
 var projectCacheDir = () => {
   let directory = process.cwd();