@rasputin-ai/browser 0.6.0

package/dist/vite/index.js

@@ -0,0 +1,4666 @@
+// src/vite/plugin.ts
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve5 } from "node:path";
+
+// ../instrumentation/src/classify-function.ts
+import { resolve as resolve3 } from "node:path";
+
+// ../recorder/src/encoded-function-plan.ts
+var compactRuntimeFunctionId = (moduleIndex, planIndex) => `${moduleIndex}.${planIndex}`;
+
+// ../core/src/create-ingest-event/truncate-ingest-message.ts
+var MAX_MESSAGE_BYTES = 8 * 1024;
+
+// ../core/src/source-identity/source-identity.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+var packageBoundaryByDirectory = /* @__PURE__ */ new Map();
+var toPosix = (path) => path.replaceAll("\\", "/");
+var physicalPath = (file) => {
+  if (!file.startsWith("file://")) return resolve(file);
+  try {
+    return fileURLToPath(file);
+  } catch {
+    return resolve(file.replace(/^file:\/\//, ""));
+  }
+};
+var readPackageBoundary = (directory) => {
+  const visited = [];
+  let current = resolve(directory);
+  while (true) {
+    const cached = packageBoundaryByDirectory.get(current);
+    if (cached !== void 0) {
+      for (const path of visited) packageBoundaryByDirectory.set(path, cached);
+      return cached;
+    }
+    visited.push(current);
+    const packageJson = resolve(current, "package.json");
+    if (existsSync(packageJson)) {
+      let name;
+      try {
+        const parsed = JSON.parse(readFileSync(packageJson, "utf8"));
+        if (typeof parsed.name === "string" && parsed.name.trim()) name = parsed.name.trim();
+      } catch {
+      }
+      const boundary = { root: current, ...name ? { name } : {} };
+      for (const path of visited) packageBoundaryByDirectory.set(path, boundary);
+      return boundary;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      for (const path of visited) packageBoundaryByDirectory.set(path, null);
+      return null;
+    }
+    current = parent;
+  }
+};
+var sourceLocatorFromFile = (file) => {
+  if (!file || /^(node:|bun:|https?:|webpack:|blob:|data:|native$)/i.test(file)) return void 0;
+  const absolute = physicalPath(file.split("?")[0] ?? file);
+  const boundary = readPackageBoundary(dirname(absolute));
+  if (!boundary) return void 0;
+  const fromPackage = relative(boundary.root, absolute);
+  if (!fromPackage || fromPackage === ".." || fromPackage.startsWith(`..${sep}`) || isAbsolute(fromPackage)) {
+    return { packageRelativePath: basename(absolute) };
+  }
+  return {
+    ...boundary.name ? { packageName: boundary.name } : {},
+    packageRelativePath: toPosix(fromPackage)
+  };
+};
+var runtimeFunctionId = (definition) => {
+  const source = definition.source;
+  const identity = [
+    definition.name,
+    source?.packageName ?? "",
+    source?.packageRelativePath ?? "",
+    String(source?.line ?? ""),
+    String(source?.column ?? "")
+  ].join("\0");
+  return `rf_${createHash("sha256").update(identity).digest("base64url").slice(0, 24)}`;
+};
+
+// ../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 decodeInteger(reader) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  return value;
+}
+function decodeSign(num) {
+  return num & 1 ? -2147483648 | -(num >>> 1) : num >>> 1;
+}
+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;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max) return false;
+  return reader.peek() !== comma;
+}
+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;
+  }
+};
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn += decodeSign(decodeInteger(reader));
+      if (genColumn < lastCol) sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex += decodeSign(decodeInteger(reader));
+        sourceLine += decodeSign(decodeInteger(reader));
+        sourceColumn += decodeSign(decodeInteger(reader));
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex += decodeSign(decodeInteger(reader));
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted) sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+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+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+var schemeRegex = /^[\w+.-]+:\/\//;
+var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+var fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+  return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+  return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+  return input.startsWith("/");
+}
+function isFileUrl(input) {
+  return input.startsWith("file:");
+}
+function isRelative(input) {
+  return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+  const match = urlRegex.exec(input);
+  return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+  const match = fileRegex.exec(input);
+  const path = match[2];
+  return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+  return {
+    scheme,
+    user,
+    host,
+    port,
+    path,
+    query,
+    hash,
+    type: 7
+  };
+}
+function parseUrl(input) {
+  if (isSchemeRelativeUrl(input)) {
+    const url2 = parseAbsoluteUrl("http:" + input);
+    url2.scheme = "";
+    url2.type = 6;
+    return url2;
+  }
+  if (isAbsolutePath(input)) {
+    const url2 = parseAbsoluteUrl("http://foo.com" + input);
+    url2.scheme = "";
+    url2.host = "";
+    url2.type = 5;
+    return url2;
+  }
+  if (isFileUrl(input))
+    return parseFileUrl(input);
+  if (isAbsoluteUrl(input))
+    return parseAbsoluteUrl(input);
+  const url = parseAbsoluteUrl("http://foo.com/" + input);
+  url.scheme = "";
+  url.host = "";
+  url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+  return url;
+}
+function stripPathFilename(path) {
+  if (path.endsWith("/.."))
+    return path;
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+  normalizePath(base, base.type);
+  if (url.path === "/") {
+    url.path = base.path;
+  } else {
+    url.path = stripPathFilename(base.path) + url.path;
+  }
+}
+function normalizePath(url, type) {
+  const rel = type <= 4;
+  const pieces = url.path.split("/");
+  let pointer = 1;
+  let positive = 0;
+  let addTrailingSlash = false;
+  for (let i = 1; i < pieces.length; i++) {
+    const piece = pieces[i];
+    if (!piece) {
+      addTrailingSlash = true;
+      continue;
+    }
+    addTrailingSlash = false;
+    if (piece === ".")
+      continue;
+    if (piece === "..") {
+      if (positive) {
+        addTrailingSlash = true;
+        positive--;
+        pointer--;
+      } else if (rel) {
+        pieces[pointer++] = piece;
+      }
+      continue;
+    }
+    pieces[pointer++] = piece;
+    positive++;
+  }
+  let path = "";
+  for (let i = 1; i < pointer; i++) {
+    path += "/" + pieces[i];
+  }
+  if (!path || addTrailingSlash && !path.endsWith("/..")) {
+    path += "/";
+  }
+  url.path = path;
+}
+function resolve2(input, base) {
+  if (!input && !base)
+    return "";
+  const url = parseUrl(input);
+  let inputType = url.type;
+  if (base && inputType !== 7) {
+    const baseUrl = parseUrl(base);
+    const baseType = baseUrl.type;
+    switch (inputType) {
+      case 1:
+        url.hash = baseUrl.hash;
+      // fall through
+      case 2:
+        url.query = baseUrl.query;
+      // fall through
+      case 3:
+      case 4:
+        mergePaths(url, baseUrl);
+      // fall through
+      case 5:
+        url.user = baseUrl.user;
+        url.host = baseUrl.host;
+        url.port = baseUrl.port;
+      // fall through
+      case 6:
+        url.scheme = baseUrl.scheme;
+    }
+    if (baseType > inputType)
+      inputType = baseType;
+  }
+  normalizePath(url, inputType);
+  const queryHash = url.query + url.hash;
+  switch (inputType) {
+    // This is impossible, because of the empty checks at the start of the function.
+    // case UrlType.Empty:
+    case 2:
+    case 3:
+      return queryHash;
+    case 4: {
+      const path = url.path.slice(1);
+      if (!path)
+        return queryHash || ".";
+      if (isRelative(base || input) && !isRelative(path)) {
+        return "./" + path + queryHash;
+      }
+      return path + queryHash;
+    }
+    case 5:
+      return url.path + queryHash;
+    default:
+      return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+  }
+}
+
+// ../node_modules/.bun/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+  if (!path) return "";
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => resolve2(prefix + (source || ""), from);
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length) return mappings;
+  if (!owned) mappings = mappings.slice();
+  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+    mappings[i] = sortSegments(mappings[i], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i = start; i < mappings.length; i++) {
+    if (!isSorted(mappings[i])) return i;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1; j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned) line = line.slice();
+  return line.sort(sortComparator2);
+}
+function sortComparator2(a, b) {
+  return a[COLUMN] - b[COLUMN];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo) return map;
+    const parsed = parse(map);
+    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+    const resolve6 = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve6);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = void 0;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = void 0;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = void 0;
+    this._bySourceMemos = void 0;
+  }
+};
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0) throw new Error(LINE_GTR_ZERO);
+  if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length) return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(
+    segments,
+    cast(map)._decodedMemo,
+    line,
+    column,
+    bias || GREATEST_LOWER_BOUND
+  );
+  if (index === -1) return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1) return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(
+    resolvedSources[segment[SOURCES_INDEX]],
+    segment[SOURCE_LINE] + 1,
+    segment[SOURCE_COLUMN],
+    segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+  );
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND) index++;
+  if (index === -1 || index === segments.length) return -1;
+  return index;
+}
+
+// ../core/src/resolve-source-maps/resolve-source-maps.ts
+var MAX_MAP_CACHE_BYTES = 8 * 1024 * 1024;
+
+// ../core/src/transport/process-shutdown-hooks.ts
+var SIGNAL_EXIT_CODES = { SIGTERM: 143, SIGINT: 130 };
+var RASPUTIN_PROCESS_LISTENER = Symbol.for("rasputin.process.listener.v1");
+var removeProcessListener = process.off.bind(process);
+var tagListener = (listener) => {
+  Object.defineProperty(listener, RASPUTIN_PROCESS_LISTENER, { value: true });
+  return listener;
+};
+var hostProcessListenerCount = (event) => {
+  const listeners = event === "beforeExit" ? process.listeners("beforeExit") : process.listeners(event);
+  return listeners.filter((listener) => !(RASPUTIN_PROCESS_LISTENER in listener)).length;
+};
+var exitAfterFlush = (done, code) => {
+  void done.finally(() => {
+    process.exit(code);
+  });
+};
+var participants = /* @__PURE__ */ new Set();
+var shuttingDown = false;
+var onBeforeExit = tagListener(() => {
+  for (const participant of participants) participant.onBeforeExit();
+});
+var handleSignal = (signal) => {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  const hostOwns = hostProcessListenerCount(signal) > 0;
+  const snapshot = [...participants];
+  const done = Promise.all(snapshot.map((participant) => participant.onSignal().catch(() => {
+  }))).then(() => {
+    for (const participant of snapshot) participant.dropRemaining();
+  }).then(() => {
+  });
+  if (!hostOwns) exitAfterFlush(done, SIGNAL_EXIT_CODES[signal] ?? 143);
+};
+var onTerm = tagListener(() => {
+  handleSignal("SIGTERM");
+});
+var onInt = tagListener(() => {
+  handleSignal("SIGINT");
+});
+
+// ../core/src/transport/create-transport.ts
+var DEFAULTS = {
+  enabled: true,
+  maxQueueSize: 500,
+  maxQueueBytes: 8 * 1024 * 1024,
+  batchSize: 30,
+  flushIntervalMs: 5e3,
+  gzipThresholdBytes: 10 * 1024,
+  maxRetries: 5,
+  installSignalHandlers: true,
+  maxBatchReplays: 8,
+  maxRetryBatchAgeMs: 6e4,
+  shutdownFlushMs: 2e3
+};
+
+// ../core/src/derivation/sensitive-property-name.ts
+var DEFAULT_SENSITIVE_PROPERTY_NAMES = [
+  "password",
+  "passwd",
+  "pwd",
+  "passphrase",
+  "token",
+  "accesstoken",
+  "refreshtoken",
+  "sessiontoken",
+  "authorization",
+  "auth",
+  "bearer",
+  "cookie",
+  "cookies",
+  "signedcookies",
+  "setcookie",
+  "secret",
+  "secrets",
+  "clientsecret",
+  "apikey",
+  "xapikey",
+  "credential",
+  "credentials",
+  "privatekey",
+  "privkey",
+  "pem",
+  "jwt",
+  "otp",
+  "totp",
+  "pin",
+  "mfacode",
+  "sessionid",
+  "sid",
+  "databaseurl",
+  "connectionstring",
+  "dsn",
+  "mongouri",
+  "redisurl",
+  "signingkey",
+  "encryptionkey",
+  "cvv",
+  "cvc",
+  "cardnumber",
+  "ssn",
+  "creditcard",
+  "securitycode",
+  "twofactorcode",
+  "masterkey",
+  "servicerolekey",
+  "stripekey",
+  "rawheaders"
+];
+var DEFAULT_SENSITIVE_PROPERTY_NAME_SET = new Set(DEFAULT_SENSITIVE_PROPERTY_NAMES);
+var SENSITIVE_SEGMENTS = /* @__PURE__ */ new Set([
+  "password",
+  "passwd",
+  "pwd",
+  "passphrase",
+  "token",
+  "secret",
+  "cookie",
+  "cookies",
+  "authorization",
+  "auth",
+  "bearer",
+  "credential",
+  "credentials",
+  "jwt",
+  "otp",
+  "totp",
+  "pin",
+  "sid",
+  "dsn",
+  "pem",
+  "privkey",
+  "cvv",
+  "cvc",
+  "ssn",
+  "secrets"
+]);
+var SENSITIVE_SUFFIXES = [
+  "password",
+  "passwd",
+  "token",
+  "secret",
+  "apikey",
+  "privatekey",
+  "credential",
+  "credentials",
+  "cookie"
+];
+var compactKey = (key) => {
+  let compacted = "";
+  for (let index = 0; index < key.length; index++) {
+    const code = key.charCodeAt(index);
+    if (code === 45 || code === 46 || code === 95) continue;
+    compacted += code >= 65 && code <= 90 ? String.fromCharCode(code + 32) : key[index];
+  }
+  return compacted;
+};
+var stripTrailingDigits = (value) => {
+  let end = value.length;
+  while (end > 0) {
+    const code = value.charCodeAt(end - 1);
+    if (code < 48 || code > 57) break;
+    end--;
+  }
+  return end === 0 ? value : value.slice(0, end);
+};
+var segmentsOf = (key) => {
+  const segments = [];
+  let current = "";
+  for (let index = 0; index < key.length; index++) {
+    const char = key[index] ?? "";
+    const code = key.charCodeAt(index);
+    if (code === 45 || code === 46 || code === 95) {
+      if (current) segments.push(current.toLowerCase());
+      current = "";
+      continue;
+    }
+    if (current && code >= 65 && code <= 90) {
+      const prev = current.charCodeAt(current.length - 1);
+      const prevIsLower = prev >= 97 && prev <= 122;
+      const next = key.charCodeAt(index + 1);
+      const nextIsLower = next >= 97 && next <= 122;
+      if (prevIsLower || nextIsLower) {
+        segments.push(current.toLowerCase());
+        current = char;
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current) segments.push(current.toLowerCase());
+  return segments;
+};
+var adjacentPairsSensitive = (left, right) => left === "api" && right === "key" || left === "private" && right === "key" || left === "client" && right === "secret" || left === "set" && right === "cookie" || left === "database" && right === "url" || left === "connection" && right === "string" || left === "mongo" && (right === "uri" || right === "url") || left === "mongodb" && (right === "uri" || right === "url") || left === "redis" && (right === "uri" || right === "url") || left === "postgres" && (right === "uri" || right === "url") || left === "database" && right === "uri" || left === "signing" && right === "key" || left === "master" && right === "key" || left === "stripe" && right === "key" || left === "service" && right === "role" || left === "security" && right === "code" || left === "two" && right === "factor" || left === "encryption" && right === "key" || left === "session" && (right === "id" || right === "key" || right === "token") || left === "card" && right === "number" || left === "mfa" && right === "code";
+var propertyNameIsSensitive = (key) => {
+  const compacted = compactKey(key);
+  const compactForms = [compacted, stripTrailingDigits(compacted)].filter(
+    (value, index, values) => value.length > 0 && values.indexOf(value) === index
+  );
+  for (const form of compactForms) {
+    if (DEFAULT_SENSITIVE_PROPERTY_NAME_SET.has(form)) return true;
+    for (const suffix of SENSITIVE_SUFFIXES) {
+      if (form.endsWith(suffix)) return true;
+    }
+    if (form.includes("apikey") || form.includes("xapikey")) return true;
+  }
+  const segments = segmentsOf(key).map((segment) => stripTrailingDigits(segment) || segment);
+  for (const segment of segments) {
+    if (SENSITIVE_SEGMENTS.has(segment)) return true;
+  }
+  for (let index = 0; index < segments.length - 1; index++) {
+    const left = segments[index];
+    const right = segments[index + 1];
+    if (left && right && adjacentPairsSensitive(left, right)) return true;
+  }
+  return false;
+};
+
+// ../recorder/src/function-plan.ts
+var encodeFunctionPlan = (source) => {
+  const locator = sourceLocatorFromFile(source.filePath);
+  const definition = {
+    name: source.name,
+    ...locator ? { source: { ...locator, line: source.line, column: source.column } } : {}
+  };
+  return [
+    runtimeFunctionId(definition),
+    source.name,
+    locator?.packageName ?? null,
+    locator?.packageRelativePath ?? null,
+    source.line,
+    source.column
+  ];
+};
+
+// ../recorder/src/runtime-symbol.ts
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v3";
+
+// ../instrumentation/src/classify-function.ts
+import ts4 from "typescript";
+
+// ../instrumentation/src/collect-instrumentation-delta.ts
+import ts from "typescript";
+var paramBindingFromName = (name, sourceFile) => {
+  if (ts.isIdentifier(name)) return { kind: "identifier", name: name.text };
+  if (ts.isArrayBindingPattern(name)) {
+    const elements = name.elements.map(
+      (element) => {
+        if (ts.isOmittedExpression(element)) return { kind: "omitted" };
+        const binding = paramBindingFromName(element.name, sourceFile);
+        if (element.dotDotDotToken) return { kind: "rest", binding };
+        return binding;
+      }
+    );
+    return { kind: "array", elements };
+  }
+  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);
+    if (element.dotDotDotToken) {
+      const rest = { kind: "rest", binding };
+      return { key, binding: rest };
+    }
+    return { key, binding };
+  });
+  return { kind: "object", properties };
+};
+var collectFunctionParams = (node, sourceFile) => {
+  const params = [];
+  for (const parameter of node.parameters) {
+    if (ts.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    const binding = paramBindingFromName(parameter.name, sourceFile);
+    params.push(parameter.dotDotDotToken ? { kind: "rest", binding } : binding);
+  }
+  return { params, paramNames: identifierNames(params) };
+};
+var identifierNames = (bindings) => {
+  const names = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    if (node.kind === "identifier") {
+      names.add(node.name);
+      return;
+    }
+    if (node.kind === "rest") {
+      walk(node.binding);
+      return;
+    }
+    if (node.kind === "object") {
+      for (const property of node.properties) walk(property.binding);
+      return;
+    }
+    if (node.kind === "array") {
+      for (const element of node.elements) {
+        if (element.kind !== "omitted") walk(element);
+      }
+    }
+  };
+  for (const item of bindings) walk(item);
+  return names;
+};
+var mappedLocation = (sourceFile, position, absolutePath, mapLocation) => {
+  const generated = sourceFile.getLineAndCharacterOfPosition(position);
+  const raw = {
+    filePath: absolutePath,
+    line: generated.line + 1,
+    column: generated.character + 1
+  };
+  return mapLocation ? mapLocation(raw) : raw;
+};
+var unwrapExpression = (expression) => {
+  let current = expression;
+  while (ts.isParenthesizedExpression(current) || ts.isNonNullExpression(current)) {
+    current = current.expression;
+  }
+  if (ts.isAwaitExpression(current)) return unwrapExpression(current.expression);
+  return current;
+};
+var calleeFromExpression = (expression, sourceFile) => {
+  const current = unwrapExpression(expression);
+  if (ts.isIdentifier(current)) {
+    return { calleeName: current.text, calleeText: current.text };
+  }
+  if (ts.isPropertyAccessExpression(current) && ts.isIdentifier(current.name)) {
+    return {
+      calleeName: current.name.text,
+      calleeText: current.getText(sourceFile).replace(/\s+/g, "")
+    };
+  }
+  return null;
+};
+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;
+  const initializer = node.initializer;
+  if (!initializer) return null;
+  const inner = unwrapExpression(initializer);
+  if (inner !== call) return null;
+  return node.name.text;
+};
+var argIdentifiersForCall = (call) => {
+  const identifiers = [];
+  call.arguments?.forEach((argument, index) => {
+    if (ts.isIdentifier(argument)) {
+      identifiers.push({ index, kind: "identifier", name: argument.text });
+      return;
+    }
+    if (!ts.isObjectLiteralExpression(argument)) return;
+    const properties = [];
+    for (const property of argument.properties) {
+      if (ts.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)) {
+        properties.push({ key: property.name.text, name: property.initializer.text });
+      }
+    }
+    if (properties.length > 0) {
+      identifiers.push({ index, kind: "object", properties });
+    }
+  });
+  return identifiers;
+};
+var collectCallSite = (call, caller, context) => {
+  const callee = calleeFromExpression(call.expression, context.sourceFile);
+  if (!callee) return null;
+  const start = mappedLocation(
+    context.sourceFile,
+    call.getStart(context.sourceFile),
+    context.absolutePath,
+    context.mapLocation
+  );
+  const end = mappedLocation(
+    context.sourceFile,
+    call.end,
+    context.absolutePath,
+    context.mapLocation
+  );
+  if (!start || !end) return null;
+  return {
+    callerFunctionId: caller.functionId,
+    calleeName: callee.calleeName,
+    calleeText: callee.calleeText,
+    filePath: start.filePath,
+    line: start.line,
+    column: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+    resultBinding: resultBindingForCall(call),
+    argIdentifiers: argIdentifiersForCall(call)
+  };
+};
+var collectParamDestructure = (declaration, caller, context) => {
+  if (!declaration.initializer || !ts.isIdentifier(declaration.initializer)) return null;
+  if (!ts.isObjectBindingPattern(declaration.name) && !ts.isArrayBindingPattern(declaration.name)) {
+    return null;
+  }
+  const sourceParam = declaration.initializer.text;
+  if (!caller.paramNames.has(sourceParam)) return null;
+  const start = mappedLocation(
+    context.sourceFile,
+    declaration.getStart(context.sourceFile),
+    context.absolutePath,
+    context.mapLocation
+  );
+  if (!start) return null;
+  return {
+    callerFunctionId: caller.functionId,
+    sourceParam,
+    filePath: start.filePath,
+    line: start.line,
+    column: start.column,
+    binding: paramBindingFromName(declaration.name, context.sourceFile)
+  };
+};
+
+// ../instrumentation/src/parse-source.ts
+import ts2 from "typescript";
+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;
+};
+var parseSource = (source, filePath) => ts2.createSourceFile(filePath, source, ts2.ScriptTarget.Latest, true, scriptKindFor(filePath));
+var peel = (expression) => {
+  let current = expression;
+  while (ts2.isParenthesizedExpression(current) || ts2.isNonNullExpression(current) || ts2.isAsExpression(current) || ts2.isTypeAssertionExpression(current) || ts2.isSatisfiesExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+};
+
+// ../instrumentation/src/svelte-generated.ts
+import ts3 from "typescript";
+var SVELTE_TEMPLATE_FACTORIES = /* @__PURE__ */ new Set(["from_html", "from_svg", "template"]);
+var SVELTE_PROP_GETTERS = /* @__PURE__ */ new Set(["prop", "prop_source"]);
+var isFunctionLike = (node) => ts3.isFunctionDeclaration(node) || ts3.isFunctionExpression(node) || ts3.isArrowFunction(node) || ts3.isMethodDeclaration(node) || ts3.isGetAccessorDeclaration(node) || ts3.isSetAccessorDeclaration(node);
+var isDescendant = (root, node) => {
+  let current = node;
+  while (current) {
+    if (current === root) return true;
+    current = current.parent;
+  }
+  return false;
+};
+var svelteCallMethod = (call) => {
+  const callee = call.expression;
+  if (!ts3.isPropertyAccessExpression(callee) || !ts3.isIdentifier(callee.expression)) {
+    return void 0;
+  }
+  if (callee.expression.text !== "$" || !ts3.isIdentifier(callee.name)) return void 0;
+  return callee.name.text;
+};
+var svelteRuntimeMethod = (node) => {
+  const parent = node.parent;
+  if (!parent || !ts3.isCallExpression(parent)) return void 0;
+  if (!parent.arguments.some((argument) => argument === node)) return void 0;
+  return svelteCallMethod(parent);
+};
+var enclosingSvelteRuntimeMethod = (node) => {
+  const direct = svelteRuntimeMethod(node);
+  if (direct) return direct;
+  let current = node;
+  let parent = node.parent;
+  while (parent) {
+    if (isFunctionLike(parent) && parent.body) {
+      if (current === parent.body || isDescendant(parent.body, current)) return void 0;
+    }
+    if (ts3.isCallExpression(parent)) {
+      const method = svelteCallMethod(parent);
+      if (method && parent.arguments.some((argument) => argument === current || isDescendant(argument, current))) {
+        return method;
+      }
+    }
+    current = parent;
+    parent = parent.parent;
+  }
+  return void 0;
+};
+var svelteGeneratedIdentifierCallees = (sourceFile) => {
+  const names = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.initializer && ts3.isCallExpression(node.initializer)) {
+      const method = svelteCallMethod(node.initializer);
+      if (method && (SVELTE_TEMPLATE_FACTORIES.has(method) || SVELTE_PROP_GETTERS.has(method))) {
+        names.add(node.name.text);
+      }
+    }
+    ts3.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return names;
+};
+var isSvelteCompilerCall = (call, sourceFile, identifierCallees) => {
+  if (svelteCallMethod(call)) return true;
+  if (!ts3.isCallExpression(call) || !ts3.isIdentifier(call.expression)) return false;
+  if (call.expression.text.startsWith("$$")) return true;
+  const names = identifierCallees ?? svelteGeneratedIdentifierCallees(sourceFile);
+  return names.has(call.expression.text);
+};
+
+// ../instrumentation/src/svelte-module-path.ts
+var isSvelteCompiledPath = (idOrPath) => {
+  const path = idOrPath.split("?")[0]?.replaceAll("\\", "/") ?? "";
+  return path.endsWith(".svelte") || path.endsWith(".svelte.ts") || path.endsWith(".svelte.js");
+};
+
+// ../instrumentation/src/classify-function.ts
+var ALLOWED_STATIC_CALLS = /* @__PURE__ */ new Map([
+  ["Array", /* @__PURE__ */ new Set(["isArray"])],
+  ["Boolean", /* @__PURE__ */ new Set()],
+  ["Number", /* @__PURE__ */ new Set(["isNaN", "isFinite"])],
+  ["Object", /* @__PURE__ */ new Set(["is"])]
+]);
+var functionName = (node, sourceFile) => {
+  if (ts4.isConstructorDeclaration(node)) return "constructor";
+  if (node.name) return node.name.getText(sourceFile).replace(/^['"]|['"]$/g, "");
+  const parent = node.parent;
+  if (ts4.isVariableDeclaration(parent) && ts4.isIdentifier(parent.name)) return parent.name.text;
+  if (ts4.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
+  if (ts4.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 ((ts4.isVariableDeclaration(parent) || ts4.isPropertyAssignment(parent)) && parent.name) {
+    return parent.name.getStart(sourceFile);
+  }
+  return node.getStart(sourceFile);
+};
+var isSupportedFunction = (node) => {
+  if (!ts4.isFunctionDeclaration(node) && !ts4.isFunctionExpression(node) && !ts4.isArrowFunction(node) && !ts4.isMethodDeclaration(node) && !ts4.isGetAccessorDeclaration(node) && !ts4.isSetAccessorDeclaration(node)) {
+    return false;
+  }
+  if (!node.body || "asteriskToken" in node && node.asteriskToken) return false;
+  return true;
+};
+var singleReturnedExpression = (body) => {
+  if (!ts4.isBlock(body)) return body;
+  if (body.statements.length === 0) return void 0;
+  if (body.statements.length !== 1) return void 0;
+  const statement = body.statements[0];
+  if (!statement || !ts4.isReturnStatement(statement)) return void 0;
+  return statement.expression;
+};
+var isLiteralExpression = (expression) => {
+  const node = peel(expression);
+  if (ts4.isStringLiteral(node) || ts4.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts4.isNumericLiteral(node)) return true;
+  if (node.kind === ts4.SyntaxKind.TrueKeyword || node.kind === ts4.SyntaxKind.FalseKeyword || node.kind === ts4.SyntaxKind.NullKeyword) {
+    return true;
+  }
+  if (ts4.isIdentifier(node) && (node.text === "undefined" || node.text === "NaN")) return true;
+  return false;
+};
+var isLiteralOnlyBody = (body) => {
+  if (ts4.isBlock(body)) {
+    if (body.statements.length === 0) return true;
+    if (body.statements.length !== 1) return false;
+    const statement = body.statements[0];
+    if (!statement || !ts4.isReturnStatement(statement)) return false;
+    return !statement.expression || isLiteralExpression(statement.expression);
+  }
+  return isLiteralExpression(body);
+};
+var identifierParams = (node) => {
+  const names = [];
+  for (const parameter of node.parameters) {
+    if (ts4.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    if (!ts4.isIdentifier(parameter.name) || parameter.dotDotDotToken) return [];
+    names.push(parameter.name.text);
+  }
+  return names;
+};
+var isIdentityFunction = (node) => {
+  const params = identifierParams(node);
+  if (params.length !== 1 || !node.body) return false;
+  const returned = singleReturnedExpression(node.body);
+  if (!returned) return false;
+  const value = peel(returned);
+  return ts4.isIdentifier(value) && value.text === params[0];
+};
+var isAllowedTypeCall = (expression) => {
+  const callee = peel(expression);
+  if (ts4.isIdentifier(callee)) {
+    return callee.text === "Boolean";
+  }
+  if (!ts4.isPropertyAccessExpression(callee) || !ts4.isIdentifier(callee.expression)) return false;
+  const allowed = ALLOWED_STATIC_CALLS.get(callee.expression.text);
+  return !!allowed && ts4.isIdentifier(callee.name) && allowed.has(callee.name.text);
+};
+var isPredicateAtom = (expression) => {
+  const node = peel(expression);
+  if (isLiteralExpression(node) || ts4.isIdentifier(node)) return true;
+  if (node.kind === ts4.SyntaxKind.ThisKeyword) return true;
+  if (ts4.isPropertyAccessExpression(node)) return isPredicateAtom(node.expression);
+  if (ts4.isElementAccessExpression(node)) {
+    return isPredicateAtom(node.expression) && isPredicateAtom(node.argumentExpression);
+  }
+  return false;
+};
+var isPredicateExpression = (expression) => {
+  const node = peel(expression);
+  if (ts4.isTypeOfExpression(node)) return isPredicateAtom(node.expression);
+  if (ts4.isPrefixUnaryExpression(node) && node.operator === ts4.SyntaxKind.ExclamationToken) {
+    return isPredicateExpression(node.operand) || isPredicateAtom(node.operand);
+  }
+  if (ts4.isBinaryExpression(node)) {
+    const kind = node.operatorToken.kind;
+    if (kind === ts4.SyntaxKind.EqualsEqualsEqualsToken || kind === ts4.SyntaxKind.ExclamationEqualsEqualsToken || kind === ts4.SyntaxKind.EqualsEqualsToken || kind === ts4.SyntaxKind.ExclamationEqualsToken || kind === ts4.SyntaxKind.LessThanToken || kind === ts4.SyntaxKind.GreaterThanToken || kind === ts4.SyntaxKind.LessThanEqualsToken || kind === ts4.SyntaxKind.GreaterThanEqualsToken || kind === ts4.SyntaxKind.AmpersandAmpersandToken || kind === ts4.SyntaxKind.BarBarToken || kind === ts4.SyntaxKind.QuestionQuestionToken || kind === ts4.SyntaxKind.InstanceOfKeyword) {
+      const side = (value) => isPredicateExpression(value) || isPredicateAtom(value);
+      return side(node.left) && side(node.right);
+    }
+    return false;
+  }
+  if (ts4.isCallExpression(node)) {
+    return isAllowedTypeCall(node.expression) && node.arguments.every(
+      (argument) => isPredicateExpression(argument) || isPredicateAtom(argument)
+    );
+  }
+  return false;
+};
+var bodyHasDisallowedControl = (body) => {
+  let found2 = false;
+  const visit = (node) => {
+    if (found2) return;
+    if (ts4.isAwaitExpression(node) || ts4.isYieldExpression(node) || ts4.isThrowStatement(node) || ts4.isTryStatement(node) || ts4.isNewExpression(node)) {
+      found2 = true;
+      return;
+    }
+    if (ts4.isBinaryExpression(node) && node.operatorToken.kind === ts4.SyntaxKind.EqualsToken) {
+      found2 = true;
+      return;
+    }
+    ts4.forEachChild(node, visit);
+  };
+  visit(body);
+  return found2;
+};
+var isObjectEntriesWrapper = (body) => {
+  const returned = singleReturnedExpression(body);
+  if (!returned) return false;
+  let current = peel(returned);
+  while (ts4.isCallExpression(current) && ts4.isPropertyAccessExpression(current.expression)) {
+    const method = current.expression.name.getText();
+    if (method === "filter" || method === "map" || method === "flatMap") {
+      current = peel(current.expression.expression);
+      continue;
+    }
+    break;
+  }
+  if (!ts4.isCallExpression(current) || !ts4.isPropertyAccessExpression(current.expression)) {
+    return false;
+  }
+  return ts4.isIdentifier(current.expression.expression) && current.expression.expression.text === "Object" && ts4.isIdentifier(current.expression.name) && (current.expression.name.text === "entries" || current.expression.name.text === "keys" || current.expression.name.text === "values");
+};
+var SVELTE_REACTIVE_CALLBACKS = /* @__PURE__ */ new Map([
+  ["derived", { name: "$derived", reason: "svelte $derived callback", kind: "derived" }],
+  ["user_effect", { name: "$effect", reason: "svelte $effect callback", kind: "effect" }],
+  [
+    "user_pre_effect",
+    { name: "$effect.pre", reason: "svelte $effect.pre callback", kind: "effect.pre" }
+  ]
+]);
+var SVELTE_EVENT_CALLBACKS = /* @__PURE__ */ new Set(["delegated", "event"]);
+var parameterNames = (node) => {
+  const names = [];
+  for (const parameter of node.parameters) {
+    if (ts4.isIdentifier(parameter.name)) names.push(parameter.name.text);
+  }
+  return names;
+};
+var isSvelteComponentWrapper = (node) => {
+  const names = parameterNames(node);
+  return names.includes("$$anchor") && names.includes("$$props");
+};
+var isSvelteGeneratedBlock = (node) => {
+  const names = parameterNames(node);
+  if (names.includes("$$props")) return false;
+  return names.includes("$$anchor") || names.includes("$$render");
+};
+var isSvelteChildPropThunk = (node) => {
+  const parent = node.parent;
+  if (!parent || !ts4.isPropertyAssignment(parent)) return false;
+  const object = parent.parent;
+  if (!object || !ts4.isObjectLiteralExpression(object)) return false;
+  const call = object.parent;
+  if (!call || !ts4.isCallExpression(call)) return false;
+  return call.arguments.some((argument) => argument === object);
+};
+var isSimpleReadBody = (body) => {
+  const returned = singleReturnedExpression(body);
+  if (!returned || bodyHasDisallowedControl(body)) return false;
+  const value = peel(returned);
+  if (ts4.isIdentifier(value)) return true;
+  if (ts4.isPropertyAccessExpression(value) && isPredicateAtom(value)) return true;
+  if (!ts4.isCallExpression(value) || value.arguments.length !== 1) return false;
+  const argument = value.arguments[0];
+  if (!argument) return false;
+  if (!ts4.isPropertyAccessExpression(value.expression) || !ts4.isIdentifier(value.expression.expression)) {
+    return false;
+  }
+  return value.expression.expression.text === "$" && ts4.isIdentifier(value.expression.name) && value.expression.name.text === "get" && ts4.isIdentifier(peel(argument));
+};
+var classifyBody = (node, name, sourceFile, filePath) => {
+  if (isSvelteComponentWrapper(node)) {
+    return { captureClass: "structure", captureReason: "svelte component wrapper" };
+  }
+  if (isSvelteCompiledPath(filePath) && /^\$[A-Za-z]/.test(name)) {
+    return { captureClass: "skip", captureReason: "svelte store subscription" };
+  }
+  if (isSvelteCompiledPath(filePath)) {
+    if (ts4.isGetAccessorDeclaration(node) || ts4.isSetAccessorDeclaration(node)) {
+      return { captureClass: "skip", captureReason: "svelte generated accessor" };
+    }
+    if (isSvelteGeneratedBlock(node)) {
+      return { captureClass: "skip", captureReason: "svelte generated block" };
+    }
+    if (isSvelteChildPropThunk(node)) {
+      const returned2 = singleReturnedExpression(node.body);
+      if (isLiteralOnlyBody(node.body) || isIdentityFunction(node) || isSimpleReadBody(node.body) || returned2 !== void 0 && isPredicateExpression(returned2) && !bodyHasDisallowedControl(node.body)) {
+        return { captureClass: "skip", captureReason: "svelte prop thunk" };
+      }
+      return { captureClass: "full", captureReason: "svelte user callback" };
+    }
+  }
+  if (isSvelteCompiledPath(filePath)) {
+    const runtimeMethod = svelteRuntimeMethod(node);
+    if (runtimeMethod) {
+      const reactive = SVELTE_REACTIVE_CALLBACKS.get(runtimeMethod);
+      if (reactive) {
+        if (isLiteralOnlyBody(node.body)) {
+          return { captureClass: "skip", captureReason: "literal-only return" };
+        }
+        return {
+          captureClass: "reactive-sparse",
+          captureReason: reactive.reason,
+          inferredName: name === "anonymous" ? reactive.name : void 0,
+          reactiveKind: reactive.kind
+        };
+      }
+      if (SVELTE_EVENT_CALLBACKS.has(runtimeMethod)) {
+        if (isLiteralOnlyBody(node.body)) {
+          return { captureClass: "skip", captureReason: "literal-only return" };
+        }
+        return { captureClass: "full", captureReason: "svelte user callback" };
+      }
+      return { captureClass: "skip", captureReason: "svelte generated callback" };
+    }
+    if (enclosingSvelteRuntimeMethod(node)) {
+      return { captureClass: "skip", captureReason: "svelte generated callback" };
+    }
+  }
+  if (isLiteralOnlyBody(node.body)) {
+    return { captureClass: "skip", captureReason: "literal-only return" };
+  }
+  if (isIdentityFunction(node)) {
+    return { captureClass: "structure", captureReason: "identity wrapper" };
+  }
+  const returned = singleReturnedExpression(node.body);
+  if (returned && isPredicateExpression(returned) && !bodyHasDisallowedControl(node.body)) {
+    return { captureClass: "structure", captureReason: "tiny predicate" };
+  }
+  if (isObjectEntriesWrapper(node.body) && !bodyHasDisallowedControl(node.body)) {
+    return { captureClass: "structure", captureReason: "object-entries wrapper" };
+  }
+  if (name === "anonymous" && node.body.getText(sourceFile).length < 80 && !bodyHasDisallowedControl(node.body)) {
+    return { captureClass: "structure", captureReason: "tiny anonymous helper" };
+  }
+  return { captureClass: "full", captureReason: "application function" };
+};
+var classifyFunctions = (source, filePath, mapLocation) => {
+  const sourceFile = parseSource(source, filePath);
+  const absolutePath = resolve3(filePath);
+  const classifications = [];
+  const visit = (node) => {
+    if (isSupportedFunction(node) && node.body) {
+      let location;
+      if (isSvelteComponentWrapper(node)) {
+        location = { filePath: absolutePath, line: 1, column: 1 };
+      } else {
+        location = mappedLocation(
+          sourceFile,
+          functionLocationPosition(node, sourceFile),
+          absolutePath,
+          mapLocation
+        );
+        if (!location) {
+          ts4.forEachChild(node, visit);
+          return;
+        }
+      }
+      const rawName = functionName(node, sourceFile).replace(/@\d+:\d+$/, "");
+      const classified = classifyBody(node, rawName, sourceFile, filePath);
+      const name = classified.inferredName ?? rawName;
+      const plan = encodeFunctionPlan({
+        filePath: location.filePath,
+        name,
+        line: location.line,
+        column: location.column
+      });
+      classifications.push({
+        functionId: plan[0],
+        name,
+        captureClass: classified.captureClass,
+        captureReason: classified.captureReason,
+        line: location.line,
+        column: location.column,
+        filePath: location.filePath,
+        start: node.getStart(sourceFile),
+        end: node.end,
+        bodyStart: node.body.getStart(sourceFile),
+        bodyEnd: node.body.end,
+        ...classified.reactiveKind ? { reactiveKind: classified.reactiveKind } : {}
+      });
+    }
+    ts4.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  const hasUserWork = classifications.some(
+    (item) => item.captureClass === "full" || item.captureClass === "reactive-sparse"
+  );
+  if (!hasUserWork) {
+    for (const item of classifications) {
+      if (item.captureReason === "svelte component wrapper") {
+        item.captureClass = "skip";
+        item.captureReason = "svelte presentational wrapper";
+      }
+    }
+  }
+  return classifications;
+};
+
+// ../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 text;
+};
+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 (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 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 transformed;
+};
+var textOf = (edit) => edit.text;
+
+// ../node_modules/.bun/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
+var SetArray = class {
+  constructor() {
+    this._indexes = { __proto__: null };
+    this.array = [];
+  }
+};
+function cast2(set) {
+  return set;
+}
+function get(setarr, key) {
+  return cast2(setarr)._indexes[key];
+}
+function put(setarr, key) {
+  const index = get(setarr, key);
+  if (index !== void 0) return index;
+  const { array, _indexes: indexes } = cast2(setarr);
+  const length = array.push(key);
+  return indexes[key] = length - 1;
+}
+var COLUMN2 = 0;
+var SOURCES_INDEX2 = 1;
+var SOURCE_LINE2 = 2;
+var SOURCE_COLUMN2 = 3;
+var NAMES_INDEX2 = 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 cast22(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,
+  } = cast22(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,
+  } = cast22(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[COLUMN2]) 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_INDEX2] && sourceLine === prev[SOURCE_LINE2] && sourceColumn === prev[SOURCE_COLUMN2] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX2] : NO_NAME);
+}
+
+// ../instrumentation/src/exact-transform-map.ts
+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 TraceMap(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 = originalPositionFor(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 exactTransformMap = (original, generated, file, edits) => {
+  const withoutUpstream = generated.replace(SOURCEMAP_COMMENT, "");
+  const { sources, mappings } = encodeColumnMappings(original, withoutUpstream, file, edits);
+  return { version: 3, file, sources, mappings };
+};
+
+// ../instrumentation/src/instrument-browser-source.ts
+import { basename as basename2 } from "node:path";
+
+// ../instrumentation/src/browser-function-edits.ts
+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 = [
+  "AwaitExpression",
+  "AwaitKeyword",
+  "YieldExpression",
+  "YieldKeyword",
+  "UsingKeyword"
+];
+var isFunctionLike2 = (node) => ts5.isFunctionLike(node);
+var isAsyncFunctionLike = (node) => (ts5.getCombinedModifierFlags(node) & ts5.ModifierFlags.Async) !== 0;
+var isAsyncGeneratorLike = (node) => isFunctionLike2(node) && isAsyncFunctionLike(node) && "asteriskToken" in node && Boolean(node.asteriskToken);
+var visitOwnBody = (node, visitNode) => {
+  if (!node.body) return;
+  const visit = (candidate) => {
+    if (candidate !== node && isFunctionLike2(candidate)) {
+      visitNode(candidate);
+      return;
+    }
+    if (visitNode(candidate)) return;
+    ts5.forEachChild(candidate, visit);
+  };
+  visit(node.body);
+};
+var nestedFunctionSpans = (node, sourceFile) => {
+  const spans = [];
+  visitOwnBody(node, (candidate) => {
+    if (candidate !== node && isFunctionLike2(candidate)) {
+      spans.push([candidate.getStart(sourceFile), candidate.end]);
+    }
+    return void 0;
+  });
+  return spans.sort((left, right) => left[0] - right[0]);
+};
+var slicesOutside = (start, end, spans) => {
+  const slices = [];
+  let cursor = start;
+  for (const [from, to] of spans) {
+    if (to <= cursor) continue;
+    if (from >= end) break;
+    if (from > cursor) slices.push([cursor, Math.min(from, end)]);
+    cursor = Math.max(cursor, to);
+  }
+  if (cursor < end) slices.push([cursor, end]);
+  return slices;
+};
+var sliceHasAwaitKeyword = (source, start, end) => {
+  if (end <= start) return false;
+  const scanner = ts5.createScanner(
+    ts5.ScriptTarget.Latest,
+    true,
+    ts5.LanguageVariant.Standard,
+    source.slice(start, end)
+  );
+  while (true) {
+    const token = scanner.scan();
+    if (token === ts5.SyntaxKind.EndOfFileToken) return false;
+    if (token === ts5.SyntaxKind.AwaitKeyword) return true;
+  }
+};
+var ownBodyHasAwaitKeyword = (node, sourceFile) => {
+  if (!node.body) return false;
+  const spans = nestedFunctionSpans(node, sourceFile);
+  for (const [start, end] of slicesOutside(node.body.getStart(sourceFile), node.body.end, spans)) {
+    if (sliceHasAwaitKeyword(sourceFile.text, start, end)) return true;
+  }
+  return false;
+};
+var isAwaitUsingList = (node) => {
+  const text = node.getText().trimStart();
+  if (text.startsWith("await using")) return true;
+  if (AWAIT_USING_FLAG === 0 || USING_FLAG === 0) return false;
+  return (node.flags & AWAIT_USING_FLAG) === AWAIT_USING_FLAG && (node.flags & USING_FLAG) !== 0;
+};
+var unknownSuspensionKind = (node) => {
+  const name = ts5.SyntaxKind[node.kind];
+  if (typeof name !== "string" || !/Await|Yield|Using/.test(name)) return false;
+  return !KNOWN_SUSPENSION_KIND_NAMES.includes(name);
+};
+var ownSuspensionFacts = (node, sourceFile) => {
+  const facts = {
+    awaitExpressions: false,
+    forAwait: false,
+    awaitUsing: false,
+    unknown: false,
+    awaitKeyword: ownBodyHasAwaitKeyword(node, sourceFile)
+  };
+  visitOwnBody(node, (candidate) => {
+    if (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;
+    return void 0;
+  });
+  return facts;
+};
+var bodyHasDirectEval = (node) => {
+  let found2 = false;
+  visitOwnBody(node, (candidate) => {
+    if (ts5.isCallExpression(candidate) && ts5.isIdentifier(candidate.expression) && candidate.expression.text === "eval") {
+      found2 = true;
+    }
+    return found2;
+  });
+  return found2;
+};
+var decideAsyncInstrumentation = (node, sourceFile) => {
+  if (isAsyncGeneratorLike(node)) return { action: "skip", reason: "unsupported_async_generator" };
+  if (!isAsyncFunctionLike(node)) return { action: "inline" };
+  if (bodyHasDirectEval(node)) return { action: "skip", reason: "direct_eval" };
+  const facts = ownSuspensionFacts(node, sourceFile);
+  if (facts.unknown) return { action: "skip", reason: "unknown_suspension" };
+  if (facts.forAwait) return { action: "skip", reason: "unsupported_for_await" };
+  if (facts.awaitUsing) return { action: "skip", reason: "await_using" };
+  if (facts.awaitKeyword && !facts.awaitExpressions) {
+    return { action: "skip", reason: "unknown_suspension" };
+  }
+  if (facts.awaitExpressions) return { action: "suspend_resume" };
+  return { action: "inline" };
+};
+
+// ../instrumentation/src/transform-source.ts
+import ts9 from "typescript";
+
+// ../instrumentation/src/parameter-initializer-may-run-code.ts
+import ts6 from "typescript";
+
+// ../instrumentation/src/verify-instrumentation-isomorphism.ts
+import ts7 from "typescript";
+
+// ../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: ts8.ScriptTarget.ES2020,
+    module: ts8.ModuleKind.ESNext,
+    allowJs: true,
+    jsx: ts8.JsxEmit.React,
+    experimentalDecorators: true
+  },
+  reportDiagnostics: true,
+  fileName: filePath
+});
+var hasScanOrParseError = (diagnostics) => Boolean(
+  diagnostics?.some(
+    (diagnostic) => diagnostic.category === ts8.DiagnosticCategory.Error && diagnostic.code < 2e3
+  )
+);
+var scriptBodyForEngine = (emitted) => (
+  // File loaders strip a leading shebang; `new Function` does not.
+  emitted.replace(/^#![^\n]*\n/, "").replaceAll("import.meta", "({})")
+);
+var looksTyped = (filePath) => /\.[cm]?tsx?$/i.test(filePath);
+var scriptKindFor2 = (filePath) => {
+  if (/\.tsx$/i.test(filePath)) return 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) => ts8.isForStatement(node) || ts8.isForOfStatement(node) || ts8.isForInStatement(node) || ts8.isWhileStatement(node) || ts8.isDoStatement(node);
+var unwrapLabeled = (node) => {
+  let current = node;
+  while (ts8.isLabeledStatement(current)) current = current.statement;
+  return current;
+};
+var hasInvalidLabelJump = (sourceFile) => {
+  const visit = (node, labels) => {
+    if (ts8.isFunctionLike(node)) {
+      let nestedInvalid = false;
+      ts8.forEachChild(node, (child) => {
+        if (visit(child, /* @__PURE__ */ new Map())) nestedInvalid = true;
+      });
+      return nestedInvalid;
+    }
+    if (ts8.isLabeledStatement(node)) {
+      const next = new Map(labels);
+      next.set(node.label.text, isIterationStatement(unwrapLabeled(node.statement)));
+      return visit(node.statement, next);
+    }
+    if (ts8.isContinueStatement(node) && node.label) {
+      if (labels.get(node.label.text) !== true) return true;
+    }
+    if (ts8.isBreakStatement(node) && node.label && !labels.has(node.label.text)) {
+      return true;
+    }
+    let invalid = false;
+    ts8.forEachChild(node, (child) => {
+      if (visit(child, labels)) invalid = true;
+    });
+    return invalid;
+  };
+  return visit(sourceFile, /* @__PURE__ */ new Map());
+};
+var importSpecifier = `('[^']+'|"[^"]+")`;
+var importAttributes = String.raw`(?:\s+with\s*\{[^}]*\})?`;
+var stripModuleSyntax = (body) => body.replace(/\bexport\s+default\b/g, "var __rasputinVerifyDefault =").replace(new RegExp(String.raw`\bexport\s*\*[\s\S]*?from\s+${importSpecifier}`, "g"), "").replace(
+  new RegExp(
+    String.raw`\bexport\s*\{[^}]*\}\s*from\s+${importSpecifier}${importAttributes}`,
+    "g"
+  ),
+  ""
+).replace(/\bexport\s*\{[^}]*\}/g, "").replace(/\bexport\s+/g, "").replace(
+  new RegExp(
+    String.raw`\bimport(?:\s+type)?\s+[\s\S]*?from\s+${importSpecifier}${importAttributes}`,
+    "g"
+  ),
+  ""
+).replace(/\bimport\s+type\s+[\s\S]*?(?:;|\n)/g, "").replace(new RegExp(String.raw`\bimport\s+${importSpecifier}${importAttributes}`, "g"), "");
+var engineAccepts = (body) => {
+  for (const candidate of [body, stripModuleSyntax(body)]) {
+    try {
+      new Function(candidate);
+      return true;
+    } catch {
+      try {
+        new Function(`return (async()=>{${candidate}
+})`);
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+};
+var GLUED_INSTRUMENTATION = /\b(?:return|await|throw|typeof|void|yield|new|delete|in|instanceof|of|from|as|case|else)__rasputin/;
+var UNTERMINATED_BARE_LEAVE = /\breturn\s+__rasputin\w*\.leave\(\)(?!\s*;|\()/;
+var transformedSourceIsInvalid = (filePath, code) => {
+  if (GLUED_INSTRUMENTATION.test(code)) return true;
+  if (UNTERMINATED_BARE_LEAVE.test(code)) return true;
+  const sourceFile = ts8.createSourceFile(
+    filePath,
+    code,
+    ts8.ScriptTarget.Latest,
+    true,
+    scriptKindFor2(filePath)
+  );
+  if (hasInvalidLabelJump(sourceFile)) return true;
+  const { diagnostics, outputText } = transpileForVerification(filePath, code);
+  if (hasScanOrParseError(diagnostics)) return true;
+  if (looksTyped(filePath)) return !engineAccepts(scriptBodyForEngine(outputText));
+  if (engineAccepts(scriptBodyForEngine(code))) return false;
+  return !engineAccepts(scriptBodyForEngine(outputText));
+};
+
+// ../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);
+
+// ../instrumentation/src/browser-function-edits.ts
+var REACTIVE_HIT = "__rasputinR";
+var REACTIVE_LEAVE = "__rasputinL";
+var REACTIVE_THROW = "__rasputinT";
+var REACTIVE_DONE = "__rasputinD";
+var REACTIVE_REG = "__rasputinReg";
+var OBSERVE_GUARD = "globalThis.__rasputinO??=function(i,v){return v};";
+var STRUCT_GUARD = "globalThis.__rasputinK??=function(o){return o};";
+var REACTIVE_GUARD = "globalThis.__rasputinR??=function(){return 1};globalThis.__rasputinL??=function(i,v){return v};globalThis.__rasputinT??=function(){};globalThis.__rasputinD??=function(){};globalThis.__rasputinReg??=function(){};";
+var isWrapTarget = (node) => (ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node) || ts10.isMethodDeclaration(node) || ts10.isGetAccessorDeclaration(node) || ts10.isSetAccessorDeclaration(node)) && node.body !== void 0;
+var isDirectivePrologue = (statement) => ts10.isExpressionStatement(statement) && ts10.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 functionBodyPrologueEnd = (body, sourceFile) => {
+  let end = body.getStart(sourceFile) + 1;
+  for (const statement of body.statements) {
+    if (!isDirectivePrologue(statement)) break;
+    end = statement.end;
+  }
+  return end;
+};
+var insertAfterSuperOrPrologue = (body, sourceFile) => {
+  const end = functionBodyPrologueEnd(body, sourceFile);
+  for (const statement of body.statements) {
+    if (isDirectivePrologue(statement)) continue;
+    if (ts10.isExpressionStatement(statement) && ts10.isCallExpression(statement.expression) && statement.expression.expression.kind === ts10.SyntaxKind.SuperKeyword) {
+      return statement.end;
+    }
+    break;
+  }
+  return end;
+};
+var functionRef = (node) => {
+  if (node.name && ts10.isIdentifier(node.name)) {
+    if (ts10.isGetAccessorDeclaration(node) || ts10.isSetAccessorDeclaration(node) || ts10.isMethodDeclaration(node)) {
+      return void 0;
+    }
+    return node.name.text;
+  }
+  const parent = node.parent;
+  if (ts10.isVariableDeclaration(parent) && ts10.isIdentifier(parent.name) && parent.initializer === node) {
+    return parent.name.text;
+  }
+  return void 0;
+};
+var matchingFunction = (sourceFile, item) => {
+  let found2;
+  const visit = (node) => {
+    if (found2) return;
+    if (isWrapTarget(node) && node.getStart(sourceFile) === item.start && node.end === item.end) {
+      found2 = node;
+      return;
+    }
+    ts10.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found2;
+};
+var isStaticPropertyName = (name) => ts10.isIdentifier(name) || ts10.isStringLiteral(name) || ts10.isNoSubstitutionTemplateLiteral(name) || ts10.isNumericLiteral(name);
+var canReconstructBinding = (name) => {
+  if (ts10.isIdentifier(name)) return true;
+  if (ts10.isArrayBindingPattern(name)) {
+    return name.elements.every(
+      (element) => ts10.isOmittedExpression(element) || canReconstructBinding(element.name)
+    );
+  }
+  return name.elements.every((element) => {
+    if (element.propertyName && !isStaticPropertyName(element.propertyName)) return false;
+    return canReconstructBinding(element.name);
+  });
+};
+var REDACTED_ARG_EXPR = 'Symbol.for("rasputin.redacted.v1")';
+var staticBindingKey = (name) => {
+  if (ts10.isIdentifier(name)) return name.text;
+  if (ts10.isStringLiteral(name) || ts10.isNoSubstitutionTemplateLiteral(name)) return name.text;
+  if (ts10.isNumericLiteral(name)) return name.text;
+  return void 0;
+};
+var bindingHasSensitiveName = (name) => {
+  if (ts10.isIdentifier(name)) return propertyNameIsSensitive(name.text);
+  if (ts10.isArrayBindingPattern(name)) {
+    return name.elements.some(
+      (element) => !ts10.isOmittedExpression(element) && bindingHasSensitiveName(element.name)
+    );
+  }
+  return name.elements.some((element) => {
+    const key = element.propertyName ? staticBindingKey(element.propertyName) : void 0;
+    if (key && propertyNameIsSensitive(key)) return true;
+    return bindingHasSensitiveName(element.name);
+  });
+};
+var capturedBinding = (name, sourceFile) => {
+  if (ts10.isIdentifier(name)) {
+    return propertyNameIsSensitive(name.text) ? REDACTED_ARG_EXPR : name.text;
+  }
+  if (ts10.isArrayBindingPattern(name)) {
+    const values = name.elements.map((element) => {
+      if (ts10.isOmittedExpression(element)) return "";
+      const value = capturedBinding(element.name, sourceFile);
+      return element.dotDotDotToken ? `...${value}` : value;
+    });
+    return `[${values.join(",")}]`;
+  }
+  const properties = name.elements.map((element) => {
+    const key = element.propertyName ? staticBindingKey(element.propertyName) : void 0;
+    const sensitive = key !== void 0 && propertyNameIsSensitive(key) || ts10.isIdentifier(element.name) && propertyNameIsSensitive(element.name.text);
+    if (element.dotDotDotToken) {
+      return `...${sensitive ? REDACTED_ARG_EXPR : capturedBinding(element.name, sourceFile)}`;
+    }
+    if (!element.propertyName) {
+      return sensitive && ts10.isIdentifier(element.name) ? `${element.name.text}:${REDACTED_ARG_EXPR}` : capturedBinding(element.name, sourceFile);
+    }
+    const printedKey = ts10.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText(sourceFile);
+    return `${printedKey}:${sensitive ? REDACTED_ARG_EXPR : capturedBinding(element.name, sourceFile)}`;
+  });
+  return `{${properties.join(",")}}`;
+};
+var captureArgs = (node) => {
+  const sourceFile = node.getSourceFile();
+  const params = node.parameters.filter(
+    (parameter) => !(ts10.isIdentifier(parameter.name) && parameter.name.text === "this")
+  );
+  const reconstructable = params.every((parameter) => canReconstructBinding(parameter.name));
+  const sensitive = params.some((parameter) => bindingHasSensitiveName(parameter.name));
+  if (!reconstructable) {
+    if (ts10.isArrowFunction(node) || sensitive) {
+      return {
+        args: `[${Array.from({ length: params.length }, () => "void 0").join(",")}]`,
+        omitValues: true
+      };
+    }
+    return { args: "arguments", omitValues: false };
+  }
+  if (!ts10.isArrowFunction(node) && !sensitive) {
+    return { args: "arguments", omitValues: false };
+  }
+  const values = params.map((parameter) => {
+    const value = capturedBinding(parameter.name, sourceFile);
+    return parameter.dotDotDotToken ? `...${value}` : value;
+  });
+  return { args: `[${values.join(",")}]`, omitValues: false };
+};
+var walkOwnBody = (node, visitNode) => {
+  const visit = (candidate) => {
+    if (candidate !== node && ts10.isFunctionLike(candidate)) return;
+    visitNode(candidate);
+    ts10.forEachChild(candidate, visit);
+  };
+  visit(node.body);
+};
+var collectReturnWraps = (node, sourceFile, handleName, edits, depth) => {
+  if (!ts10.isBlock(node.body)) return;
+  walkOwnBody(node, (candidate) => {
+    if (!ts10.isReturnStatement(candidate) || !candidate.expression) return;
+    wrap(
+      edits,
+      candidate.expression.getStart(sourceFile),
+      candidate.expression.end,
+      `(${handleName}.leave((`,
+      ")))",
+      depth + 1
+    );
+  });
+};
+var collectAwaitWraps = (node, sourceFile, handleName, edits, depth) => {
+  walkOwnBody(node, (candidate) => {
+    if (!ts10.isAwaitExpression(candidate)) return;
+    wrap(
+      edits,
+      candidate.expression.getStart(sourceFile),
+      candidate.expression.end,
+      `${handleName}.suspend(`,
+      ")",
+      depth + 3
+    );
+    wrap(
+      edits,
+      candidate.getStart(sourceFile),
+      candidate.end,
+      `${handleName}.resume(`,
+      ")",
+      depth + 2
+    );
+  });
+};
+var collectCatchFinallyResumes = (node, sourceFile, handleName, edits, depth) => {
+  walkOwnBody(node, (candidate) => {
+    if (!ts10.isTryStatement(candidate)) return;
+    for (const block of [candidate.catchClause?.block, candidate.finallyBlock]) {
+      if (!block) continue;
+      edits.push({
+        position: block.getStart(sourceFile) + 1,
+        text: `${handleName}.resume();`,
+        deleteCount: 0,
+        depth,
+        width: 0,
+        kind: "replace"
+      });
+    }
+  });
+};
+var collectReactiveReturnWraps = (node, sourceFile, siteId, edits, depth) => {
+  if (!ts10.isBlock(node.body)) return;
+  walkOwnBody(node, (candidate) => {
+    if (!ts10.isReturnStatement(candidate)) return;
+    if (!candidate.expression) {
+      edits.push({
+        position: candidate.getStart(sourceFile),
+        text: `return void ${REACTIVE_LEAVE}(${siteId});`,
+        deleteCount: candidate.end - candidate.getStart(sourceFile),
+        depth,
+        width: 0,
+        kind: "replace"
+      });
+      return;
+    }
+    wrap(
+      edits,
+      candidate.expression.getStart(sourceFile),
+      candidate.expression.end,
+      `${REACTIVE_LEAVE}(${siteId},`,
+      ")",
+      depth + 1
+    );
+  });
+};
+var failEpilogue = (handleName, errorName, failArgs, restoreOnCatch) => `}catch(${errorName}){${restoreOnCatch ? `${handleName}.resume();` : ""}${handleName}.fail(${errorName}${failArgs});throw ${errorName};}finally{${handleName}.end();}`;
+var toManifestFunction = (item, node, sourceFile, asyncFunction, instrumented, mapLocation) => {
+  const plan = encodeFunctionPlan({
+    filePath: item.filePath,
+    name: item.name,
+    line: item.line,
+    column: item.column
+  });
+  const { params, paramNames } = node ? collectFunctionParams(node, sourceFile) : { params: [], paramNames: /* @__PURE__ */ new Set() };
+  const end = node ? mappedLocation(sourceFile, node.end, item.filePath, mapLocation) : { line: item.line, column: item.column };
+  return {
+    plan,
+    functionId: item.functionId,
+    filePath: item.filePath,
+    name: item.name,
+    startLine: item.line,
+    startColumn: item.column,
+    endLine: end?.line ?? item.line,
+    endColumn: end?.column ?? item.column,
+    params,
+    paramNames,
+    instrumented,
+    asyncFunction
+  };
+};
+var collectCallerSites = (sourceFile, classifications, functions, absolutePath, mapLocation) => {
+  const bySpan = /* @__PURE__ */ new Map();
+  const classified = new Map(
+    classifications.map((item) => [`${item.start}:${item.end}`, item])
+  );
+  const byId = new Map(functions.map((fn) => [fn.functionId, fn]));
+  for (const item of classifications) {
+    const fn = byId.get(item.functionId);
+    if (fn) bySpan.set(`${item.start}:${item.end}`, fn);
+  }
+  const callSites = [];
+  const destructures = [];
+  const collectContext = { sourceFile, absolutePath, mapLocation };
+  const svelteFile = isSvelteCompiledPath(absolutePath);
+  const identifierCallees = svelteFile ? svelteGeneratedIdentifierCallees(sourceFile) : void 0;
+  const visit = (node, caller) => {
+    if (isWrapTarget(node)) {
+      const item = classified.get(`${node.getStart(sourceFile)}:${node.end}`);
+      if (item) {
+        const fn = bySpan.get(`${item.start}:${item.end}`);
+        const next = fn && fn.instrumented !== false ? fn : caller;
+        ts10.forEachChild(node, (child) => visit(child, next));
+        return;
+      }
+    }
+    if (caller && (ts10.isCallExpression(node) || ts10.isNewExpression(node))) {
+      if (svelteFile && isSvelteCompilerCall(node, sourceFile, identifierCallees)) {
+        ts10.forEachChild(node, (child) => visit(child, caller));
+        return;
+      }
+      const site = collectCallSite(node, caller, collectContext);
+      if (site) callSites.push(site);
+    }
+    if (caller && ts10.isVariableDeclaration(node)) {
+      const destructure = collectParamDestructure(node, caller, collectContext);
+      if (destructure) destructures.push(destructure);
+    }
+    ts10.forEachChild(node, (child) => visit(child, caller));
+  };
+  visit(sourceFile, void 0);
+  return { callSites, destructures };
+};
+var compactRegister = (runName, moduleIndex, plans) => `const ${runName}=((g,k,m)=>{const e=g[k];const ok=e&&typeof e.register==="function"&&Array.isArray(e.runtimes)&&Array.isArray(e.modules);const stub={runtimes:[],modules:[],register(p,i){const d={run:(x,a,c)=>c(),enter(){return{leave(v){return v},fail(){},end(){},suspend(v){return v},resume(v){return v},run(c){return c()}}}};const n={plans:p,cell:d,moduleIndex:i??m};this.modules.push(n);const t=this.runtimes.at(-1);if(t)t.bind(n);const f=(x,a,c,l)=>d.run(x,a,c,l);f.enter=(x,a,l,n)=>d.enter(x,a,l,n);return f}};const r=ok?e:e==null?(g[k]=stub):stub;return r.register(${JSON.stringify(plans)},m)})(globalThis,Symbol.for(${JSON.stringify(AUTOMATIC_RUNTIME_SYMBOL)}),${moduleIndex});`;
+var collectBrowserFunctionEdits = (source, sourceFile, classifications, moduleIndex, reactiveIds, options) => {
+  const edits = [];
+  const functions = [];
+  const identities = [];
+  const runtimePlans = [];
+  const reactiveSiteIds = [];
+  const runName = uniqueName(source, "__rasputinRun__");
+  const handleName = uniqueName(source, "__rasputinH__");
+  const errorName = uniqueName(source, "__rasputinE__");
+  const sampledName = uniqueName(source, "__rasputinS__");
+  const valueName = uniqueName(source, "__rasputinV__");
+  let planIndex = 0;
+  let emittedRuntime = false;
+  for (const item of classifications) {
+    const node = matchingFunction(sourceFile, item);
+    const asyncFunction = node ? isAsyncFunctionLike(node) : false;
+    if (item.captureClass === "skip") {
+      functions.push(
+        toManifestFunction(item, node, sourceFile, asyncFunction, false, options.mapLocation)
+      );
+      continue;
+    }
+    if (!node) {
+      functions.push(
+        toManifestFunction(item, void 0, sourceFile, asyncFunction, false, options.mapLocation)
+      );
+      continue;
+    }
+    const remember = (siteId) => {
+      runtimePlans[planIndex] = encodeFunctionPlan({
+        filePath: item.filePath,
+        name: item.name,
+        line: item.line,
+        column: item.column
+      });
+      identities.push({
+        compactId: compactRuntimeFunctionId(moduleIndex, planIndex),
+        functionId: item.functionId,
+        name: item.name,
+        moduleIndex,
+        planIndex,
+        captureClass: item.captureClass,
+        line: item.line,
+        column: item.column,
+        filePath: item.filePath,
+        ...siteId === void 0 ? {} : { siteId }
+      });
+    };
+    if (item.captureClass === "reactive-sparse" && !isAsyncFunctionLike(node)) {
+      const siteId = reactiveIds.value++;
+      remember(siteId);
+      const hit = `${REACTIVE_HIT}(${siteId})`;
+      const leave = `${REACTIVE_LEAVE}(${siteId})`;
+      const fail = `${REACTIVE_THROW}(${siteId},${errorName})`;
+      const epilogue2 = `}catch(${errorName}){${fail};throw ${errorName};}finally{${REACTIVE_DONE}()}`;
+      if (ts10.isBlock(node.body)) {
+        wrap(
+          edits,
+          node.body.getStart(sourceFile) + 1,
+          node.body.end - 1,
+          `;var ${sampledName}=${hit};try{`,
+          `;if(!${sampledName})${leave}${epilogue2}`,
+          0
+        );
+        collectReactiveReturnWraps(node, sourceFile, siteId, edits, 0);
+      } else {
+        wrap(
+          edits,
+          node.body.getStart(sourceFile),
+          node.body.end,
+          `{try{var ${sampledName}=${hit},${valueName}=`,
+          `;return ${sampledName}?${valueName}:${REACTIVE_LEAVE}(${siteId},${valueName})${epilogue2}}`,
+          0
+        );
+      }
+      reactiveSiteIds.push(siteId);
+      functions.push(toManifestFunction(item, node, sourceFile, false, true, options.mapLocation));
+      planIndex += 1;
+      continue;
+    }
+    const decision = isAsyncFunctionLike(node) ? decideAsyncInstrumentation(node, sourceFile) : { action: "inline" };
+    if (decision.action === "skip") {
+      functions.push(toManifestFunction(item, node, sourceFile, true, false, options.mapLocation));
+      continue;
+    }
+    remember();
+    emittedRuntime = true;
+    const structure = item.captureClass === "structure";
+    const captured = structure ? { args: "void 0", omitValues: true } : captureArgs(node);
+    const omitFlag = structure || captured.omitValues;
+    const ref = functionRef(node);
+    const enterCall = `${runName}.enter(${planIndex},${captured.args},${omitFlag}${ref ? `,${ref}` : ""})`;
+    const failLive = structure ? captureArgs(node) : captured;
+    const failArgs = `,${failLive.args}`;
+    const epilogue = failEpilogue(
+      handleName,
+      errorName,
+      failArgs,
+      decision.action === "suspend_resume"
+    );
+    if (ts10.isBlock(node.body)) {
+      const prologueAt = insertAfterSuperOrPrologue(node.body, sourceFile);
+      const closeAt = node.body.end - 1;
+      wrap(edits, prologueAt, closeAt, `;const ${handleName}=${enterCall};try{`, epilogue, 0);
+      collectReturnWraps(node, sourceFile, handleName, edits, 0);
+      if (decision.action === "suspend_resume") {
+        collectAwaitWraps(node, sourceFile, handleName, edits, 0);
+        collectCatchFinallyResumes(node, sourceFile, handleName, edits, 0);
+      }
+    } else {
+      wrap(
+        edits,
+        node.body.getStart(sourceFile),
+        node.body.end,
+        `{;const ${handleName}=${enterCall};try{return (${handleName}.leave((`,
+        `)));${epilogue}}`,
+        0
+      );
+      if (decision.action === "suspend_resume") {
+        collectAwaitWraps(node, sourceFile, handleName, edits, 0);
+      }
+    }
+    functions.push(
+      toManifestFunction(
+        item,
+        node,
+        sourceFile,
+        isAsyncFunctionLike(node),
+        true,
+        options.mapLocation
+      )
+    );
+    planIndex += 1;
+  }
+  if (functions.length === 0 && !options.observe) {
+    return {
+      edits: [],
+      delta: { functions: [], callSites: [], destructures: [] },
+      identities: [],
+      reactiveSiteIds: []
+    };
+  }
+  const insertAt = insertPositionAfterPrologue(source, sourceFile);
+  const reactivePreamble = reactiveSiteIds.length > 0 ? `${REACTIVE_REG}([${reactiveSiteIds.join(",")}]);` : "";
+  const preamble = `${RASPUTIN_INSTRUMENTATION_PREAMBLE}${options.observe ? OBSERVE_GUARD : ""}${options.struct ? STRUCT_GUARD : ""}${reactiveSiteIds.length > 0 ? REACTIVE_GUARD : ""}${emittedRuntime ? compactRegister(runName, moduleIndex, options.includePlans ? runtimePlans : []) : ""}${reactivePreamble}`;
+  edits.push({
+    position: insertAt,
+    text: preambleInsert(source, insertAt, preamble),
+    deleteCount: 0,
+    depth: -1,
+    width: 0,
+    kind: "replace"
+  });
+  const sites = collectCallerSites(
+    sourceFile,
+    classifications,
+    functions,
+    classifications[0]?.filePath ?? "",
+    options.mapLocation
+  );
+  return {
+    edits,
+    delta: { functions, callSites: sites.callSites, destructures: sites.destructures },
+    identities,
+    reactiveSiteIds
+  };
+};
+
+// ../instrumentation/src/json-producer-sites.ts
+import ts11 from "typescript";
+var JSON_METHOD_CALLEE = "globalThis.__rasputinM";
+var JSON_AWAIT_CALLEE = "globalThis.__rasputinA";
+var JSON_ADOPT_CALLEE = "globalThis.__rasputinP";
+var JSON_PRODUCER_GUARD = "globalThis.__rasputinM??=function(r,f){return Reflect.apply(f,r,[].slice.call(arguments,2))};globalThis.__rasputinA??=function(v){return v};globalThis.__rasputinP??=function(p){return p};";
+var isSimpleReceiver = (expression) => {
+  const receiver = peel(expression);
+  return ts11.isIdentifier(receiver) || receiver.kind === ts11.SyntaxKind.ThisKeyword;
+};
+var isSimpleIdentifierCall = (node) => !node.questionDotToken && ts11.isIdentifier(node.expression);
+var isSimpleMethodCall = (node) => {
+  if (node.questionDotToken) return false;
+  const callee = node.expression;
+  return ts11.isPropertyAccessExpression(callee) && !callee.questionDotToken && ts11.isIdentifier(callee.name) && !ts11.isPrivateIdentifier(callee.name) && isSimpleReceiver(callee.expression);
+};
+var isSimpleProvenanceCall = (node) => isSimpleIdentifierCall(node) || isSimpleMethodCall(node);
+var isJsonParseCall = (node) => {
+  if (!isSimpleMethodCall(node)) return false;
+  const callee = node.expression;
+  if (!ts11.isPropertyAccessExpression(callee) || callee.name.text !== "parse") return false;
+  const object = peel(callee.expression);
+  return ts11.isIdentifier(object) && object.text === "JSON";
+};
+var methodName = (node) => {
+  if (!isSimpleMethodCall(node)) return void 0;
+  const callee = node.expression;
+  return ts11.isPropertyAccessExpression(callee) ? callee.name.text : void 0;
+};
+var containsNestedAwaitOrFunction = (node) => {
+  let found2 = false;
+  const visit = (candidate) => {
+    if (candidate !== node && (ts11.isAwaitExpression(candidate) || ts11.isFunctionLike(candidate))) {
+      found2 = true;
+      return;
+    }
+    if (!found2) ts11.forEachChild(candidate, visit);
+  };
+  visit(node);
+  return found2;
+};
+var isSimpleProducerCall = (node) => {
+  if (containsNestedAwaitOrFunction(node)) return false;
+  if (isJsonParseCall(node)) return true;
+  return methodName(node) === "json";
+};
+var isAwaitExpressionOf = (node) => {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (ts11.isParenthesizedExpression(parent) || ts11.isNonNullExpression(parent) || ts11.isAsExpression(parent) || ts11.isTypeAssertionExpression(parent) || ts11.isSatisfiesExpression(parent)) {
+      current = parent;
+      continue;
+    }
+    return ts11.isAwaitExpression(parent) && parent.expression === current;
+  }
+  return false;
+};
+var isDirectSuperCall = (node) => node.expression.kind === ts11.SyntaxKind.SuperKeyword;
+var SVELTE_RUNE_ROOTS = /* @__PURE__ */ new Set([
+  "$state",
+  "$derived",
+  "$effect",
+  "$props",
+  "$bindable",
+  "$inspect",
+  "$host"
+]);
+var isSvelteRuneCall = (node) => {
+  let current = peel(node.expression);
+  while (ts11.isPropertyAccessExpression(current)) {
+    current = peel(current.expression);
+  }
+  return ts11.isIdentifier(current) && SVELTE_RUNE_ROOTS.has(current.text);
+};
+var isSvelteSourcePath = (filePath) => filePath.includes(".svelte");
+var isSvelteCompilerCall2 = (node, filePath) => {
+  if (isSvelteRuneCall(node)) return true;
+  if (!isSvelteSourcePath(filePath)) return false;
+  const callee = peel(node.expression);
+  if (!ts11.isPropertyAccessExpression(callee)) return false;
+  const object = peel(callee.expression);
+  return ts11.isIdentifier(object) && object.text === "$";
+};
+var outerExpression = (node) => {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if ((ts11.isParenthesizedExpression(parent) || ts11.isNonNullExpression(parent) || ts11.isAsExpression(parent) || ts11.isTypeAssertionExpression(parent) || ts11.isSatisfiesExpression(parent)) && parent.expression === current) {
+      current = parent;
+      continue;
+    }
+    break;
+  }
+  return current;
+};
+var isReturnedOrBoundCall = (node) => {
+  const expression = outerExpression(node);
+  const parent = expression.parent;
+  if (!parent) return false;
+  if (ts11.isReturnStatement(parent) && parent.expression === expression) return true;
+  if (ts11.isVariableDeclaration(parent) && parent.initializer === expression) return true;
+  if (ts11.isBinaryExpression(parent) && parent.right === expression && parent.operatorToken.kind === ts11.SyntaxKind.EqualsToken) {
+    return true;
+  }
+  return false;
+};
+var NON_PROVENANCE_ROOTS = /* @__PURE__ */ new Set([
+  "String",
+  "Number",
+  "Boolean",
+  "Object",
+  "Array",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "URIError",
+  "EvalError",
+  "ReferenceError",
+  "Symbol",
+  "BigInt",
+  "Math",
+  "JSON",
+  "Date",
+  "Promise",
+  "console",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI"
+]);
+var callCanCarryProvenance = (node) => {
+  const name = methodName(node);
+  if (name === "json" || name === "parse") return true;
+  if (name === "call" || name === "apply") return false;
+  const callee = node.expression;
+  if (ts11.isIdentifier(callee)) return !NON_PROVENANCE_ROOTS.has(callee.text);
+  if (ts11.isPropertyAccessExpression(callee)) {
+    const object = peel(callee.expression);
+    if (ts11.isIdentifier(object) && NON_PROVENANCE_ROOTS.has(object.text)) {
+      return object.text === "JSON" && callee.name.text === "parse";
+    }
+  }
+  return true;
+};
+var shouldAdoptCall = (node, filePath) => {
+  if (isAwaitExpressionOf(node) || isDirectSuperCall(node) || isSvelteCompilerCall2(node, filePath)) {
+    return false;
+  }
+  if (ts11.isComputedPropertyName(outerExpression(node).parent)) return false;
+  if (!isSimpleProvenanceCall(node)) return false;
+  return isReturnedOrBoundCall(node) && callCanCarryProvenance(node);
+};
+var shouldAdoptAwaitCall = (node, filePath) => {
+  if (isSvelteCompilerCall2(node, filePath) || !isSimpleProvenanceCall(node)) return false;
+  return callCanCarryProvenance(node);
+};
+var replaceProducerCall = (node, sourceFile, receiverName) => {
+  const callee = node.expression;
+  if (!ts11.isPropertyAccessExpression(callee)) return node.getText(sourceFile);
+  const args = node.arguments.map((argument) => argument.getText(sourceFile));
+  const extra2 = args.length > 0 ? `,${args.join(",")}` : "";
+  const receiver = callee.expression.getText(sourceFile);
+  const method = `${receiverName}.${callee.name.text}`;
+  return `((${receiverName})=>${JSON_METHOD_CALLEE}(${receiverName},${method}${extra2}))(${receiver})`;
+};
+var hasBlockBody = (node) => {
+  if (!ts11.isFunctionDeclaration(node) && !ts11.isFunctionExpression(node) && !ts11.isArrowFunction(node) && !ts11.isMethodDeclaration(node) && !ts11.isConstructorDeclaration(node) && !ts11.isGetAccessorDeclaration(node) && !ts11.isSetAccessorDeclaration(node)) {
+    return false;
+  }
+  return node.body !== void 0 && ts11.isBlock(node.body);
+};
+var owningFunctionBody = (node) => {
+  let current = node;
+  while (current) {
+    if (hasBlockBody(current)) return current.body;
+    current = current.parent;
+  }
+  return void 0;
+};
+var callOpenParen = (node, sourceFile) => {
+  const text = sourceFile.text;
+  for (let index = node.expression.getEnd(); index < node.end; index += 1) {
+    if (text.charCodeAt(index) === 40) return index;
+  }
+  return node.arguments.pos;
+};
+var callCloseParen = (node, sourceFile) => {
+  const text = sourceFile.text;
+  for (let index = node.end - 1; index >= node.arguments.pos; index -= 1) {
+    if (text.charCodeAt(index) === 41) return index;
+  }
+  return node.end - 1;
+};
+var adoptCall = (edits, node, sourceFile, receiverName, fnName, slotName, slot = false) => {
+  const start = node.getStart(sourceFile);
+  const end = node.end;
+  const depth = slot ? 17 : 14;
+  const wrapOpen = (inner) => slot ? `(${slotName}={p:${inner}` : inner;
+  const wrapClose = (inner) => slot ? `${inner}},${slotName}.p)` : inner;
+  const callee = node.expression;
+  if (ts11.isIdentifier(callee)) {
+    wrap(
+      edits,
+      start,
+      end,
+      wrapOpen(`((${fnName})=>${JSON_ADOPT_CALLEE}(`),
+      wrapClose(`,${fnName}))(${callee.text})`),
+      depth
+    );
+    edits.push({
+      position: callee.getStart(sourceFile),
+      text: fnName,
+      deleteCount: callee.end - callee.getStart(sourceFile),
+      depth: 18,
+      width: callee.end - callee.getStart(sourceFile),
+      kind: "replace"
+    });
+    return;
+  }
+  if (!isSimpleMethodCall(node) || !ts11.isPropertyAccessExpression(callee)) return;
+  const receiver = callee.expression.getText(sourceFile);
+  const method = callee.name.text;
+  const open = callOpenParen(node, sourceFile);
+  const close = callCloseParen(node, sourceFile);
+  wrap(
+    edits,
+    start,
+    end,
+    wrapOpen(`((${receiverName})=>((${fnName})=>${JSON_ADOPT_CALLEE}(`),
+    wrapClose(`,${fnName}))(${receiverName}.${method}))(${receiver})`),
+    depth
+  );
+  edits.push({
+    position: start,
+    text: `Reflect.apply(${fnName},${receiverName},[`,
+    deleteCount: open + 1 - start,
+    depth: 18,
+    width: open + 1 - start,
+    kind: "replace"
+  });
+  edits.push({
+    position: close,
+    text: "])",
+    deleteCount: 1,
+    depth: 18,
+    width: 1,
+    kind: "replace"
+  });
+};
+var skippedComplexCall = (node, filePath) => {
+  if (isSvelteCompilerCall2(node, filePath) || isDirectSuperCall(node)) return false;
+  if (isSimpleProvenanceCall(node)) return false;
+  if (!callCanCarryProvenance(node)) return false;
+  return true;
+};
+var collectJsonProducerEdits = (source, filePath, sourceFile = parseSource(source, filePath), options) => {
+  const adoptCalls = options?.adoptCalls === true;
+  const receiverName = uniqueName(source, "__rasputinJ");
+  const adoptFnName = uniqueName(source, "__rasputinC");
+  const slotName = uniqueName(source, "__rasputinS");
+  const edits = [];
+  const bodies = /* @__PURE__ */ new Set();
+  let awaitWraps = 0;
+  let callWraps = 0;
+  let provenanceSkippedComplexCall = 0;
+  const visit = (node) => {
+    if (ts11.isCallExpression(node) && isSimpleProducerCall(node) && !isAwaitExpressionOf(node)) {
+      edits.push({
+        position: node.getStart(sourceFile),
+        text: replaceProducerCall(node, sourceFile, receiverName),
+        deleteCount: node.end - node.getStart(sourceFile),
+        depth: 18,
+        width: node.end - node.getStart(sourceFile),
+        kind: "replace"
+      });
+      callWraps += 1;
+    } else if (adoptCalls && ts11.isCallExpression(node) && shouldAdoptCall(node, filePath)) {
+      adoptCall(edits, node, sourceFile, receiverName, adoptFnName, slotName);
+      callWraps += 1;
+    } else if (ts11.isCallExpression(node) && !isAwaitExpressionOf(node) && isReturnedOrBoundCall(node) && skippedComplexCall(node, filePath)) {
+      provenanceSkippedComplexCall += 1;
+    }
+    if (ts11.isAwaitExpression(node)) {
+      const inner = peel(node.expression);
+      const producer = ts11.isCallExpression(inner) && isSimpleProducerCall(inner);
+      const adoptInner = adoptCalls && ts11.isCallExpression(inner) && shouldAdoptAwaitCall(inner, filePath);
+      const adoptValue = adoptCalls && !ts11.isCallExpression(inner);
+      if (producer || adoptInner || adoptValue) {
+        if (producer && ts11.isCallExpression(inner)) {
+          edits.push({
+            position: node.expression.getStart(sourceFile),
+            text: `(${slotName}={p:${replaceProducerCall(inner, sourceFile, receiverName)}},${slotName}.p)`,
+            deleteCount: node.expression.end - node.expression.getStart(sourceFile),
+            depth: 17,
+            width: node.expression.end - node.expression.getStart(sourceFile),
+            kind: "replace"
+          });
+          callWraps += 1;
+        } else if (adoptInner && ts11.isCallExpression(inner)) {
+          if (node.expression === inner) {
+            adoptCall(edits, inner, sourceFile, receiverName, adoptFnName, slotName, true);
+          } else {
+            wrap(
+              edits,
+              node.expression.getStart(sourceFile),
+              node.expression.end,
+              `(${slotName}={p:`,
+              `},${slotName}.p)`,
+              17
+            );
+            adoptCall(edits, inner, sourceFile, receiverName, adoptFnName, slotName);
+          }
+          callWraps += 1;
+        } else {
+          wrap(
+            edits,
+            node.expression.getStart(sourceFile),
+            node.expression.end,
+            `(${slotName}={p:${JSON_ADOPT_CALLEE}(`,
+            `)},${slotName}.p)`,
+            17
+          );
+        }
+        wrap(
+          edits,
+          node.getStart(sourceFile),
+          node.end,
+          `${JSON_AWAIT_CALLEE}(`,
+          `,${slotName}.p)`,
+          16
+        );
+        awaitWraps += 1;
+        const body = owningFunctionBody(node);
+        if (body) bodies.add(body);
+      } else if (ts11.isCallExpression(inner) && skippedComplexCall(inner, filePath)) {
+        provenanceSkippedComplexCall += 1;
+      }
+    }
+    ts11.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  if (edits.length > 0) {
+    edits.push({
+      position: 0,
+      text: `${RASPUTIN_INSTRUMENTATION_PREAMBLE}${JSON_PRODUCER_GUARD}`,
+      deleteCount: 0,
+      depth: -1,
+      width: 0,
+      kind: "replace"
+    });
+  }
+  for (const body of bodies) {
+    edits.push({
+      position: body.getStart(sourceFile) + 1,
+      text: `var ${slotName};`,
+      deleteCount: 0,
+      depth: 1,
+      width: 0,
+      kind: "replace"
+    });
+  }
+  return { edits, awaitWraps, callWraps, provenanceSkippedComplexCall };
+};
+
+// ../instrumentation/src/literal-sites.ts
+import ts12 from "typescript";
+var STRUCT_CALLEE = "globalThis.__rasputinK";
+var owningFunction = (position, classifications) => {
+  let owner;
+  let span = Number.POSITIVE_INFINITY;
+  for (const item of classifications) {
+    if (position < item.bodyStart || position >= item.bodyEnd) continue;
+    const size = item.bodyEnd - item.bodyStart;
+    if (size < span) {
+      owner = item;
+      span = size;
+    }
+  }
+  return owner;
+};
+var allowsLiteralCapture = (owner) => owner.captureClass === "full" || owner.captureClass === "reactive-sparse";
+var walkPeelParent = (node) => {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if ((ts12.isParenthesizedExpression(parent) || ts12.isNonNullExpression(parent) || ts12.isAsExpression(parent) || ts12.isTypeAssertionExpression(parent) || ts12.isSatisfiesExpression(parent)) && parent.expression === current) {
+      current = parent;
+      continue;
+    }
+    break;
+  }
+  return current;
+};
+var isCapturePosition = (node) => {
+  const current = walkPeelParent(node);
+  const parent = current.parent;
+  if (!parent) return false;
+  if (ts12.isReturnStatement(parent) && parent.expression === current) return true;
+  if (ts12.isArrowFunction(parent) && parent.body === current) return true;
+  if (ts12.isVariableDeclaration(parent) && parent.initializer === current) return true;
+  if (ts12.isBinaryExpression(parent) && parent.operatorToken.kind === ts12.SyntaxKind.EqualsToken && parent.right === current) {
+    return true;
+  }
+  if (ts12.isCallExpression(parent) || ts12.isNewExpression(parent)) {
+    return parent.arguments?.some((argument) => argument === current) === true;
+  }
+  return false;
+};
+var isInAssignmentPattern = (node) => {
+  let current = walkPeelParent(node);
+  while (current.parent) {
+    const parent = current.parent;
+    if (ts12.isBinaryExpression(parent) && parent.operatorToken.kind === ts12.SyntaxKind.EqualsToken && parent.left === current) {
+      return true;
+    }
+    if ((ts12.isForOfStatement(parent) || ts12.isForInStatement(parent)) && parent.initializer === current) {
+      return true;
+    }
+    if (ts12.isPropertyAssignment(parent) || ts12.isShorthandPropertyAssignment(parent) || ts12.isSpreadAssignment(parent) || ts12.isObjectLiteralExpression(parent) || ts12.isArrayLiteralExpression(parent) || ts12.isParenthesizedExpression(parent) || ts12.isAsExpression(parent) || ts12.isTypeAssertionExpression(parent) || ts12.isNonNullExpression(parent) || ts12.isSatisfiesExpression(parent)) {
+      current = walkPeelParent(parent);
+      continue;
+    }
+    return false;
+  }
+  return false;
+};
+var isLiteralChild = (node) => {
+  const current = walkPeelParent(node);
+  const parent = current.parent;
+  if (!parent) return false;
+  if (ts12.isPropertyAssignment(parent) && parent.initializer === current) return true;
+  if (ts12.isArrayLiteralExpression(parent)) return true;
+  return false;
+};
+var shouldRewrite = (node, classifications, sourceFile) => {
+  if (isInAssignmentPattern(node)) return false;
+  const owner = owningFunction(node.getStart(sourceFile), classifications);
+  if (!owner || !allowsLiteralCapture(owner)) return false;
+  return isCapturePosition(node) || isLiteralChild(node);
+};
+var collectLiteralSiteEdits = (source, filePath, options, sourceFile = parseSource(source, filePath)) => {
+  const edits = [];
+  const visit = (node) => {
+    if ((ts12.isObjectLiteralExpression(node) || ts12.isArrayLiteralExpression(node)) && shouldRewrite(node, options.classifications, sourceFile)) {
+      wrap(edits, node.getStart(sourceFile), node.end, `${STRUCT_CALLEE}(`, ")", 15);
+    }
+    ts12.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return { edits };
+};
+
+// ../instrumentation/src/observe-sites.ts
+import { createHash as createHash2 } from "node:crypto";
+import { resolve as resolve4 } from "node:path";
+import ts13 from "typescript";
+var OBSERVE_CALLEE = "globalThis.__rasputinO";
+var siteIdFor = (filePath, line, column, text) => {
+  const digest = createHash2("sha256").update(`${resolve4(filePath)}:${line}:${column}:${text}`).digest("base64url").slice(0, 16);
+  return `rs_${digest}`;
+};
+var isAssignmentOperator = (kind) => kind === ts13.SyntaxKind.EqualsToken || kind === ts13.SyntaxKind.PlusEqualsToken || kind === ts13.SyntaxKind.MinusEqualsToken || kind === ts13.SyntaxKind.AsteriskEqualsToken || kind === ts13.SyntaxKind.SlashEqualsToken || kind === ts13.SyntaxKind.PercentEqualsToken || kind === ts13.SyntaxKind.AmpersandEqualsToken || kind === ts13.SyntaxKind.BarEqualsToken || kind === ts13.SyntaxKind.CaretEqualsToken || kind === ts13.SyntaxKind.LessThanLessThanEqualsToken || kind === ts13.SyntaxKind.GreaterThanGreaterThanEqualsToken || kind === ts13.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || kind === ts13.SyntaxKind.AsteriskAsteriskEqualsToken || kind === ts13.SyntaxKind.BarBarEqualsToken || kind === ts13.SyntaxKind.AmpersandAmpersandEqualsToken || kind === ts13.SyntaxKind.QuestionQuestionEqualsToken;
+var isSafeLiteral = (expression) => {
+  const node = peel(expression);
+  if (ts13.isStringLiteral(node) || ts13.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts13.isNumericLiteral(node)) return true;
+  if (node.kind === ts13.SyntaxKind.TrueKeyword || node.kind === ts13.SyntaxKind.FalseKeyword || node.kind === ts13.SyntaxKind.NullKeyword) {
+    return true;
+  }
+  if (ts13.isIdentifier(node) && (node.text === "undefined" || node.text === "NaN")) return true;
+  if (ts13.isPrefixUnaryExpression(node) && node.operator === ts13.SyntaxKind.MinusToken && ts13.isNumericLiteral(node.operand)) {
+    return true;
+  }
+  return ts13.isVoidExpression(node) && ts13.isNumericLiteral(peel(node.expression)) && peel(node.expression).getText() === "0";
+};
+var isPropertyRead = (node) => {
+  if (ts13.isPropertyAccessExpression(node)) {
+    return !ts13.isPrivateIdentifier(node.name) && node.expression.kind !== ts13.SyntaxKind.SuperKeyword;
+  }
+  if (ts13.isElementAccessExpression(node)) {
+    return node.expression.kind !== ts13.SyntaxKind.SuperKeyword;
+  }
+  return false;
+};
+var isMetaChain = (node) => {
+  if (ts13.isMetaProperty(node)) return true;
+  if (ts13.isPropertyAccessExpression(node)) return isMetaChain(node.expression);
+  if (ts13.isElementAccessExpression(node)) return isMetaChain(node.expression);
+  return false;
+};
+var isPatternParent = (parent, child) => {
+  if (ts13.isParenthesizedExpression(parent) && parent.expression === child) return true;
+  if (ts13.isAsExpression(parent) && parent.expression === child) return true;
+  if (ts13.isTypeAssertionExpression(parent) && parent.expression === child) return true;
+  if (ts13.isNonNullExpression(parent) && parent.expression === child) return true;
+  if (ts13.isSatisfiesExpression(parent) && parent.expression === child) return true;
+  if (ts13.isPropertyAssignment(parent) && parent.initializer === child) return true;
+  if (ts13.isShorthandPropertyAssignment(parent)) return true;
+  if (ts13.isSpreadAssignment(parent) && parent.expression === child) return true;
+  if (ts13.isSpreadElement(parent) && parent.expression === child) return true;
+  if (ts13.isArrayLiteralExpression(parent)) return true;
+  if (ts13.isObjectLiteralExpression(parent)) return true;
+  return false;
+};
+var isAssignmentTarget = (node) => {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (ts13.isComputedPropertyName(parent) && parent.expression === current) return false;
+    if (ts13.isBinaryExpression(parent) && isAssignmentOperator(parent.operatorToken.kind)) {
+      return parent.left === current;
+    }
+    if ((ts13.isForOfStatement(parent) || ts13.isForInStatement(parent)) && parent.initializer === current) {
+      return true;
+    }
+    if (!isPatternParent(parent, current)) return false;
+    current = parent;
+  }
+  return false;
+};
+var isValueContext = (node) => {
+  if (isAssignmentTarget(node)) return false;
+  const parent = node.parent;
+  if (!parent) return false;
+  if (ts13.isVariableDeclaration(parent) && parent.initializer === node) return true;
+  if (ts13.isReturnStatement(parent) && parent.expression === node) return true;
+  if (ts13.isPropertyAssignment(parent) && parent.initializer === node) return true;
+  if (ts13.isParenthesizedExpression(parent) || ts13.isNonNullExpression(parent) || ts13.isAsExpression(parent) || ts13.isTypeAssertionExpression(parent) || ts13.isSatisfiesExpression(parent)) {
+    return isValueContext(parent);
+  }
+  return false;
+};
+var isCoalesceWithLiteral = (node) => {
+  if (!ts13.isBinaryExpression(node)) return false;
+  const operator = node.operatorToken.kind;
+  if (operator !== ts13.SyntaxKind.QuestionQuestionToken && operator !== ts13.SyntaxKind.BarBarToken) {
+    return false;
+  }
+  return isSafeLiteral(node.right);
+};
+var shouldWrapPropertyRead = (node) => {
+  if (isMetaChain(node)) return false;
+  const parent = node.parent;
+  if (!parent) return false;
+  if (ts13.isPropertyAccessExpression(parent) && parent.expression === node) return false;
+  if (ts13.isElementAccessExpression(parent) && parent.expression === node) return false;
+  if (ts13.isCallExpression(parent) && parent.expression === node) return false;
+  if (ts13.isNewExpression(parent) && parent.expression === node) return false;
+  if (ts13.isTaggedTemplateExpression(parent) && parent.tag === node) return false;
+  if (ts13.isDeleteExpression(parent)) return false;
+  if (ts13.isPrefixUnaryExpression(parent) && (parent.operator === ts13.SyntaxKind.PlusPlusToken || parent.operator === ts13.SyntaxKind.MinusMinusToken)) {
+    return false;
+  }
+  if (ts13.isPostfixUnaryExpression(parent) && (parent.operator === ts13.SyntaxKind.PlusPlusToken || parent.operator === ts13.SyntaxKind.MinusMinusToken)) {
+    return false;
+  }
+  if (ts13.isBinaryExpression(parent) && isAssignmentOperator(parent.operatorToken.kind)) {
+    if (parent.left === node) return false;
+  }
+  if (isValueContext(node)) return true;
+  if (isCoalesceWithLiteral(parent) && parent.left === node) {
+    return isValueContext(parent);
+  }
+  return false;
+};
+var shouldWrapRead = (node, classifications, sourceFile) => {
+  if (isAssignmentTarget(node)) return false;
+  return shouldWrapPropertyRead(node) || isReactiveArrowValue(node, classifications, sourceFile);
+};
+var hasOptional = (node) => !!node.questionDotToken;
+var isInternalProperty = (node) => {
+  if (ts13.isPropertyAccessExpression(node)) return node.name.text.startsWith("__");
+  if (!ts13.isStringLiteral(node.argumentExpression) && !ts13.isNoSubstitutionTemplateLiteral(node.argumentExpression)) {
+    return false;
+  }
+  return node.argumentExpression.text.startsWith("__");
+};
+var staticPropertyName = (node) => {
+  if (ts13.isPropertyAccessExpression(node)) return node.name.text;
+  if (ts13.isStringLiteral(node.argumentExpression) || ts13.isNoSubstitutionTemplateLiteral(node.argumentExpression)) {
+    return node.argumentExpression.text;
+  }
+  return void 0;
+};
+var BROWSER_SENSITIVE_SURFACES = /* @__PURE__ */ new Set([
+  "value",
+  "textContent",
+  "innerText",
+  "innerHTML",
+  "href",
+  "search",
+  "URL"
+]);
+var isSensitiveRead = (node) => {
+  const name = staticPropertyName(node);
+  if (name === void 0) return false;
+  return propertyNameIsSensitive(name) || BROWSER_SENSITIVE_SURFACES.has(name);
+};
+var allowsExpressionCapture = (owner) => owner.captureClass === "full" || owner.captureClass === "reactive-sparse" || owner.captureReason === "svelte component wrapper";
+var isReactiveArrowValue = (node, classifications, sourceFile) => {
+  let current = node;
+  while (current) {
+    const parent = current.parent;
+    if (!parent) return false;
+    if (ts13.isArrowFunction(parent) && parent.body === current) {
+      const owner = owningFunction2(node.getStart(sourceFile), classifications);
+      return owner?.captureClass === "reactive-sparse";
+    }
+    if (ts13.isBinaryExpression(parent) && (parent.left === current || parent.right === current) && !isAssignmentOperator(parent.operatorToken.kind)) {
+      current = parent;
+      continue;
+    }
+    if (ts13.isParenthesizedExpression(parent) || ts13.isNonNullExpression(parent) || ts13.isAsExpression(parent) || ts13.isTypeAssertionExpression(parent) || ts13.isSatisfiesExpression(parent)) {
+      current = parent;
+      continue;
+    }
+    return false;
+  }
+  return false;
+};
+var owningFunction2 = (position, classifications) => {
+  if (!classifications || classifications.length === 0) return void 0;
+  let owner;
+  let span = Number.POSITIVE_INFINITY;
+  for (const item of classifications) {
+    if (position < item.bodyStart || position >= item.bodyEnd) continue;
+    const size = item.bodyEnd - item.bodyStart;
+    if (size < span) {
+      owner = item;
+      span = size;
+    }
+  }
+  return owner;
+};
+var collectObserveSiteEdits = (source, filePath, options = {}, sourceFile = parseSource(source, filePath)) => {
+  const absolutePath = resolve4(filePath);
+  const emitIds = options.emitIds ?? { value: 1 };
+  const queued = [];
+  const visit = (node) => {
+    if (isPropertyRead(node) && shouldWrapRead(node, options.classifications, sourceFile) && !isInternalProperty(node) && !isSensitiveRead(node)) {
+      if (options.classifications) {
+        const owner = owningFunction2(node.getStart(sourceFile), options.classifications);
+        if (!owner || !allowsExpressionCapture(owner)) {
+          ts13.forEachChild(node, visit);
+          return;
+        }
+      }
+      const start = node.getStart(sourceFile);
+      const text = node.getText(sourceFile);
+      const location = sourceFile.getLineAndCharacterOfPosition(start);
+      const line = location.line + 1;
+      const column = location.character + 1;
+      queued.push({
+        start,
+        end: node.end,
+        site: {
+          siteId: siteIdFor(absolutePath, line, column, text),
+          emitId: emitIds.value++,
+          filePath: absolutePath,
+          line,
+          column,
+          kind: hasOptional(node) ? "optional-chain" : "property-read",
+          sourceText: text.length > 80 ? `${text.slice(0, 77)}...` : text,
+          start,
+          end: node.end
+        }
+      });
+    }
+    ts13.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  queued.sort((left, right) => right.start - left.start);
+  const applied = [];
+  const edits = [];
+  let lastStart = Number.POSITIVE_INFINITY;
+  for (const item of queued) {
+    if (item.end > lastStart) continue;
+    edits.push({
+      position: item.start,
+      text: `${OBSERVE_CALLEE}(${item.site.emitId},`,
+      deleteCount: 0,
+      depth: 20,
+      width: item.end - item.start,
+      kind: "open"
+    });
+    edits.push({
+      position: item.end,
+      text: ")",
+      deleteCount: 0,
+      depth: 20,
+      width: item.end - item.start,
+      kind: "close"
+    });
+    applied.push(item.site);
+    lastStart = item.start;
+  }
+  applied.reverse();
+  return { edits, sites: applied };
+};
+
+// ../instrumentation/src/verify-browser-source.ts
+import ts14 from "typescript";
+var RASPUTIN_IDENT = /^__rasputin/;
+var BROWSER_GLOBALS = /* @__PURE__ */ new Set([
+  "__rasputinO",
+  "__rasputinK",
+  "__rasputinR",
+  "__rasputinL",
+  "__rasputinT",
+  "__rasputinD",
+  "__rasputinReg",
+  "__rasputinM",
+  "__rasputinA",
+  "__rasputinP",
+  "__rasputinN"
+]);
+var isRasputinName = (name) => RASPUTIN_IDENT.test(name);
+var identText = (node) => {
+  if (ts14.isIdentifier(node)) return node.text;
+  if (ts14.isPrivateIdentifier(node)) return node.text;
+  return void 0;
+};
+var calleeName = (expression) => {
+  if (ts14.isIdentifier(expression)) return expression.text;
+  if (ts14.isPropertyAccessExpression(expression)) {
+    const object = identText(expression.expression);
+    const property = identText(expression.name);
+    if (object && isRasputinName(object) && property) return `${object}.${property}`;
+    if (object === "globalThis" && property && BROWSER_GLOBALS.has(property)) return property;
+  }
+  return void 0;
+};
+var isRasputinCall = (node) => {
+  if (!ts14.isCallExpression(node)) return false;
+  const name = calleeName(node.expression);
+  return Boolean(name && (isRasputinName(name) || BROWSER_GLOBALS.has(name)));
+};
+var isRasputinAssignment = (node) => {
+  if (!ts14.isBinaryExpression(node)) return false;
+  const operator = node.operatorToken.kind;
+  if (operator !== ts14.SyntaxKind.EqualsToken && operator !== ts14.SyntaxKind.QuestionQuestionEqualsToken) {
+    return false;
+  }
+  if (ts14.isPropertyAccessExpression(node.left)) {
+    const object = identText(node.left.expression);
+    const property = identText(node.left.name);
+    return object === "globalThis" && property !== void 0 && BROWSER_GLOBALS.has(property);
+  }
+  const name = identText(node.left);
+  return Boolean(name && isRasputinName(name));
+};
+var isRasputinOnlyInitializer = (expression) => {
+  if (!expression) return true;
+  const unwrapped = unwrapCall(expression);
+  if (unwrapped !== expression) {
+    return ts14.isExpression(unwrapped) ? isRasputinOnlyInitializer(unwrapped) : false;
+  }
+  return isRasputinCall(expression);
+};
+var jsonAwaitSlot = (node) => {
+  if (node.operatorToken.kind !== ts14.SyntaxKind.CommaToken) return void 0;
+  const assigned = node.left;
+  if (!ts14.isBinaryExpression(assigned) || assigned.operatorToken.kind !== ts14.SyntaxKind.EqualsToken || !ts14.isIdentifier(assigned.left) || !isRasputinName(assigned.left.text) || !ts14.isObjectLiteralExpression(assigned.right)) {
+    return void 0;
+  }
+  const property = assigned.right.properties[0];
+  if (!property || !ts14.isPropertyAssignment(property) || !ts14.isIdentifier(property.name) || property.name.text !== "p") {
+    return void 0;
+  }
+  if (!ts14.isPropertyAccessExpression(node.right) || !ts14.isIdentifier(node.right.expression) || !isRasputinName(node.right.expression.text) || node.right.name.text !== "p") {
+    return void 0;
+  }
+  return property.initializer;
+};
+var peelParens = (node) => {
+  let current = node;
+  while (ts14.isParenthesizedExpression(current)) current = current.expression;
+  return current;
+};
+var jsonMethodCall = (node) => {
+  const receiver = node.arguments[0];
+  const fn = node.arguments[1];
+  if (!receiver || !fn) return void 0;
+  const args = node.arguments.slice(2);
+  if (!ts14.isPropertyAccessExpression(fn)) return void 0;
+  return ts14.factory.createCallExpression(
+    ts14.factory.createPropertyAccessExpression(receiver, fn.name),
+    void 0,
+    args
+  );
+};
+var unwrapAdoptIife = (node) => {
+  if (node.arguments.length !== 1) return void 0;
+  const adopted = node.arguments[0];
+  if (!adopted) return void 0;
+  const callee = peelParens(node.expression);
+  if (!ts14.isArrowFunction(callee) || callee.parameters.length !== 1 || ts14.isBlock(callee.body)) {
+    return void 0;
+  }
+  const param = callee.parameters[0];
+  if (!param || !ts14.isIdentifier(param.name) || param.dotDotDotToken || param.initializer) {
+    return void 0;
+  }
+  const body = peelParens(callee.body);
+  if (ts14.isCallExpression(body) && calleeName(body.expression) === "__rasputinP") {
+    const invoked = body.arguments[0];
+    if (invoked && ts14.isCallExpression(invoked) && ts14.isIdentifier(invoked.expression) && invoked.expression.text === param.name.text) {
+      return ts14.factory.createCallExpression(adopted, void 0, invoked.arguments);
+    }
+    return void 0;
+  }
+  if (!ts14.isCallExpression(body) || body.arguments.length !== 1) return void 0;
+  const methodLookup = body.arguments[0];
+  if (!methodLookup) return void 0;
+  const inner = peelParens(body.expression);
+  if (!ts14.isArrowFunction(inner) || inner.parameters.length !== 1 || ts14.isBlock(inner.body)) {
+    return void 0;
+  }
+  const fnParam = inner.parameters[0];
+  if (!fnParam || !ts14.isIdentifier(fnParam.name) || fnParam.dotDotDotToken || fnParam.initializer) {
+    return void 0;
+  }
+  const innerBody = peelParens(inner.body);
+  if (!ts14.isCallExpression(innerBody) || calleeName(innerBody.expression) !== "__rasputinP") {
+    return void 0;
+  }
+  const applied = innerBody.arguments[0];
+  if (!applied || !ts14.isCallExpression(applied)) return void 0;
+  const applyCallee = peelParens(applied.expression);
+  if (!ts14.isPropertyAccessExpression(applyCallee) || applyCallee.name.text !== "apply" || !ts14.isIdentifier(applyCallee.expression) || applyCallee.expression.text !== "Reflect") {
+    return void 0;
+  }
+  const appliedFn = applied.arguments[0];
+  const thisArg = applied.arguments[1];
+  const argsArg = applied.arguments[2];
+  if (!appliedFn || !ts14.isIdentifier(appliedFn) || appliedFn.text !== fnParam.name.text) {
+    return void 0;
+  }
+  if (!thisArg || !ts14.isIdentifier(thisArg) || thisArg.text !== param.name.text) return void 0;
+  if (!argsArg || !ts14.isArrayLiteralExpression(argsArg)) return void 0;
+  if (!ts14.isPropertyAccessExpression(methodLookup) || !ts14.isIdentifier(methodLookup.expression) || methodLookup.expression.text !== param.name.text || ts14.isPrivateIdentifier(methodLookup.name)) {
+    return void 0;
+  }
+  return ts14.factory.createCallExpression(
+    ts14.factory.createPropertyAccessExpression(adopted, methodLookup.name),
+    void 0,
+    [...argsArg.elements]
+  );
+};
+var unwrapProducerIife = (node) => {
+  if (node.arguments.length !== 1) return void 0;
+  const receiver = node.arguments[0];
+  if (!receiver) return void 0;
+  const callee = peelParens(node.expression);
+  if (!ts14.isArrowFunction(callee) || callee.parameters.length !== 1 || ts14.isBlock(callee.body)) {
+    return void 0;
+  }
+  const param = callee.parameters[0];
+  if (!param || !ts14.isIdentifier(param.name) || param.dotDotDotToken || param.initializer) {
+    return void 0;
+  }
+  const body = peelParens(callee.body);
+  if (!ts14.isCallExpression(body) || !isRasputinCall(body)) return void 0;
+  if (calleeName(body.expression) !== "__rasputinM") return void 0;
+  const bound = body.arguments[0];
+  const fn = body.arguments[1];
+  if (!bound || !fn || !ts14.isIdentifier(bound) || bound.text !== param.name.text) return void 0;
+  if (!ts14.isPropertyAccessExpression(fn)) return void 0;
+  if (!ts14.isIdentifier(fn.expression) || fn.expression.text !== param.name.text) return void 0;
+  return ts14.factory.createCallExpression(
+    ts14.factory.createPropertyAccessExpression(receiver, fn.name),
+    void 0,
+    body.arguments.slice(2)
+  );
+};
+var unwrapCall = (node) => {
+  let current = node;
+  while (true) {
+    if (ts14.isParenthesizedExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (ts14.isBinaryExpression(current)) {
+      const slot = jsonAwaitSlot(current);
+      if (slot) {
+        current = slot;
+        continue;
+      }
+    }
+    if (ts14.isConditionalExpression(current) && isRasputinName(identText(current.condition) ?? "")) {
+      current = current.whenTrue;
+      continue;
+    }
+    if (ts14.isCallExpression(current)) {
+      const adopted = unwrapAdoptIife(current);
+      if (adopted) {
+        current = adopted;
+        continue;
+      }
+      const producer = unwrapProducerIife(current);
+      if (producer) {
+        current = producer;
+        continue;
+      }
+    }
+    if (ts14.isCallExpression(current) && isRasputinCall(current)) {
+      const name = calleeName(current.expression);
+      if ((name === "__rasputinO" || name === "__rasputinL") && current.arguments.length >= 2 && current.arguments[1]) {
+        current = current.arguments[1];
+        continue;
+      }
+      if ((name === "__rasputinA" || name === "__rasputinP") && current.arguments[0]) {
+        current = current.arguments[0];
+        continue;
+      }
+      if (name === "__rasputinK" && current.arguments[0]) {
+        current = current.arguments[0];
+        continue;
+      }
+      if (name === "__rasputinM") {
+        const reconstructed = jsonMethodCall(current);
+        if (reconstructed) {
+          current = reconstructed;
+          continue;
+        }
+      }
+      if (current.arguments.length === 1 && current.arguments[0] && name && (name.endsWith(".leave") || name.endsWith(".suspend") || name.endsWith(".resume"))) {
+        current = current.arguments[0];
+        continue;
+      }
+    }
+    break;
+  }
+  return current;
+};
+var isRasputinIf = (node) => {
+  if (node.elseStatement) return false;
+  const condition = node.expression;
+  const negated = ts14.isPrefixUnaryExpression(condition) && condition.operator === ts14.SyntaxKind.ExclamationToken && isRasputinName(identText(condition.operand) ?? "");
+  if (!negated) return false;
+  const then = node.thenStatement;
+  if (ts14.isExpressionStatement(then) && isRasputinCall(then.expression)) return true;
+  return ts14.isBlock(then) && then.statements.every((statement) => isRasputinStatement(statement));
+};
+var isRasputinStatement = (node) => {
+  if (ts14.isEmptyStatement(node)) return true;
+  if (ts14.isVariableStatement(node)) {
+    return node.declarationList.declarations.every((declaration) => {
+      const name = identText(declaration.name);
+      return Boolean(name && isRasputinName(name));
+    });
+  }
+  if (ts14.isExpressionStatement(node)) {
+    if (isRasputinAssignment(node.expression)) return true;
+    if (!isRasputinCall(node.expression)) return false;
+    return unwrapCall(node.expression) === node.expression;
+  }
+  if (ts14.isIfStatement(node)) return isRasputinIf(node);
+  return false;
+};
+var isRasputinTryWrapper = (node) => {
+  const catchClause = node.catchClause;
+  if (!catchClause || !node.finallyBlock) return false;
+  const catchCalls = catchClause.block.statements.filter(
+    (statement) => !isRasputinStatement(statement)
+  );
+  const leftover = catchCalls[0];
+  const leftoverThrow = catchCalls.length === 1 && leftover !== void 0 && ts14.isThrowStatement(leftover) && ts14.isIdentifier(leftover.expression);
+  if (!leftoverThrow && catchCalls.length > 0) return false;
+  return node.finallyBlock.statements.every((statement) => isRasputinStatement(statement));
+};
+var customerTempInit = (statement) => {
+  if (!ts14.isVariableStatement(statement)) return void 0;
+  for (const declaration of statement.declarationList.declarations) {
+    const name = identText(declaration.name);
+    if (!name || !isRasputinName(name) || !declaration.initializer) continue;
+    if (isRasputinOnlyInitializer(declaration.initializer)) continue;
+    return { name, init: declaration.initializer };
+  }
+  return void 0;
+};
+var flattenStatements = (statements) => {
+  const flattened = [];
+  for (const statement of statements) {
+    if (isRasputinStatement(statement)) continue;
+    if (ts14.isTryStatement(statement) && isRasputinTryWrapper(statement)) {
+      flattened.push(...flattenStatements(statement.tryBlock.statements));
+      continue;
+    }
+    flattened.push(statement);
+  }
+  return flattened;
+};
+var isRememberIife = (node) => {
+  if (!ts14.isCallExpression(node) || node.arguments.length > 0) return void 0;
+  let callee = node.expression;
+  if (ts14.isParenthesizedExpression(callee)) callee = callee.expression;
+  if (!ts14.isArrowFunction(callee) || callee.parameters.length > 0 || !ts14.isBlock(callee.body)) {
+    return void 0;
+  }
+  const statements = callee.body.statements;
+  const last = statements.at(-1);
+  if (!last || !ts14.isReturnStatement(last) || !last.expression) return void 0;
+  let returned = last.expression;
+  while (ts14.isParenthesizedExpression(returned)) returned = returned.expression;
+  if (!ts14.isCallExpression(returned)) return void 0;
+  const name = calleeName(returned.expression);
+  if (name !== "__rasputinK") return void 0;
+  const objectArg = returned.arguments[0];
+  if (!objectArg || !ts14.isIdentifier(objectArg)) return void 0;
+  const temps = /* @__PURE__ */ new Map();
+  for (const statement of statements.slice(0, -1)) {
+    if (!ts14.isVariableStatement(statement)) return void 0;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts14.isIdentifier(declaration.name) || !declaration.initializer) return void 0;
+      temps.set(declaration.name.text, declaration.initializer);
+    }
+  }
+  const object = temps.get(objectArg.text);
+  if (!object) return void 0;
+  return { object, temps };
+};
+var resolveRememberTemp = (expression, temps, seen) => {
+  let current = expression;
+  while (ts14.isParenthesizedExpression(current) || ts14.isNonNullExpression(current) || ts14.isAsExpression(current) || ts14.isTypeAssertionExpression(current) || ts14.isSatisfiesExpression(current)) {
+    current = current.expression;
+  }
+  if (ts14.isIdentifier(current) && temps.has(current.text) && !seen.has(current.text)) {
+    const next = temps.get(current.text);
+    if (!next) return current;
+    seen.add(current.text);
+    return resolveRememberTemp(next, temps, seen);
+  }
+  return current;
+};
+var extra = (node) => {
+  if (ts14.isIdentifier(node) || ts14.isPrivateIdentifier(node)) {
+    return isRasputinName(node.text) ? "" : node.text;
+  }
+  if (ts14.isStringLiteral(node) || ts14.isNumericLiteral(node) || ts14.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+  if (ts14.isToken(node) && !ts14.isIdentifier(node)) return ts14.SyntaxKind[node.kind] ?? "";
+  return "";
+};
+var signatureOfSubstituted = (node, temps) => {
+  const remembered = isRememberIife(node);
+  if (remembered) return signatureOfSubstituted(remembered.object, remembered.temps);
+  if (ts14.isObjectLiteralExpression(node)) {
+    const parts = node.properties.map((property) => {
+      if (ts14.isShorthandPropertyAssignment(property)) return signatureOf(property);
+      if (!ts14.isPropertyAssignment(property)) return signatureOf(property);
+      const init = resolveRememberTemp(property.initializer, temps, /* @__PURE__ */ new Set());
+      if (ts14.isIdentifier(property.name) && ts14.isIdentifier(init) && property.name.text === init.text) {
+        return signatureOf(ts14.factory.createShorthandPropertyAssignment(property.name));
+      }
+      if (ts14.isComputedPropertyName(property.name)) {
+        const key = resolveRememberTemp(property.name.expression, temps, /* @__PURE__ */ new Set());
+        return `PropertyAssignment[ComputedPropertyName[${signatureOfSubstituted(key, temps)}],${signatureOfSubstituted(init, temps)}]`;
+      }
+      return `PropertyAssignment[${signatureOf(property.name)},${signatureOfSubstituted(init, temps)}]`;
+    });
+    return `ObjectLiteralExpression[${parts.join(",")}]`;
+  }
+  if (ts14.isArrayLiteralExpression(node)) {
+    const parts = node.elements.map(
+      (element) => signatureOfSubstituted(resolveRememberTemp(element, temps, /* @__PURE__ */ new Set()), temps)
+    );
+    return `ArrayLiteralExpression[${parts.join(",")}]`;
+  }
+  return signatureOf(node);
+};
+var signatureOfRememberedLiteral = (node) => {
+  const parsed = isRememberIife(node);
+  if (!parsed) return void 0;
+  return signatureOfSubstituted(parsed.object, parsed.temps);
+};
+var signatureOf = (node) => {
+  const unwrapped = unwrapCall(node);
+  if (unwrapped !== node) return signatureOf(unwrapped);
+  const remembered = signatureOfRememberedLiteral(unwrapped);
+  if (remembered !== void 0) return remembered;
+  if (ts14.isPropertyAssignment(unwrapped) && ts14.isIdentifier(unwrapped.name) && ts14.isIdentifier(unwrapped.initializer) && unwrapped.name.text === unwrapped.initializer.text) {
+    return signatureOf(ts14.factory.createShorthandPropertyAssignment(unwrapped.name));
+  }
+  if (ts14.isEmptyStatement(unwrapped) || isRasputinStatement(unwrapped)) return "";
+  if (ts14.isTryStatement(unwrapped) && isRasputinTryWrapper(unwrapped)) {
+    return flattenStatements(unwrapped.tryBlock.statements).map(signatureOf).filter(Boolean).join("");
+  }
+  if (ts14.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 (ts14.isBlock(unwrapped)) {
+    const statements = flattenStatements(unwrapped.statements);
+    return `Block[${statements.map(signatureOf).filter(Boolean).join(",")}]`;
+  }
+  if (ts14.isArrowFunction(unwrapped) && ts14.isBlock(unwrapped.body)) {
+    const raw = unwrapped.body.statements;
+    const tryWrap = raw.length === 1 && raw[0] && ts14.isTryStatement(raw[0]) ? raw[0] : void 0;
+    const inner = tryWrap && isRasputinTryWrapper(tryWrap) ? tryWrap.tryBlock.statements : raw;
+    const temp = inner[0] ? customerTempInit(inner[0]) : void 0;
+    const returned = inner[1];
+    if (temp && returned && ts14.isReturnStatement(returned) && returned.expression && inner.length === 2) {
+      const value = unwrapCall(returned.expression);
+      if (ts14.isIdentifier(value) && value.text === temp.name) {
+        const parts2 = [];
+        ts14.forEachChild(unwrapped, (child) => {
+          if (child === unwrapped.body) {
+            const part2 = signatureOf(temp.init);
+            if (part2) parts2.push(part2);
+            return;
+          }
+          const part = signatureOf(child);
+          if (part) parts2.push(part);
+        });
+        return `ArrowFunction[${parts2.join(",")}]`;
+      }
+    }
+    const statements = flattenStatements(unwrapped.body.statements);
+    const only = statements[0];
+    const onlyExpression = only && ts14.isReturnStatement(only) ? only.expression : void 0;
+    if (statements.length === 1 && onlyExpression) {
+      const parts2 = [];
+      ts14.forEachChild(unwrapped, (child) => {
+        if (child === unwrapped.body) {
+          const part2 = signatureOf(onlyExpression);
+          if (part2) parts2.push(part2);
+          return;
+        }
+        const part = signatureOf(child);
+        if (part) parts2.push(part);
+      });
+      return `ArrowFunction[${parts2.join(",")}]`;
+    }
+  }
+  if (ts14.isReturnStatement(unwrapped)) {
+    if (!unwrapped.expression) return "ReturnStatement[]";
+    const expression = unwrapCall(unwrapped.expression);
+    if (ts14.isVoidExpression(expression) && isRasputinCall(expression.expression)) {
+      return "ReturnStatement[]";
+    }
+    return `Return[${signatureOf(unwrapped.expression)}]`;
+  }
+  const parts = [];
+  ts14.forEachChild(unwrapped, (child) => {
+    const part = signatureOf(child);
+    if (part) parts.push(part);
+  });
+  const kind = ts14.SyntaxKind[unwrapped.kind] ?? "Node";
+  return `${kind}${extra(unwrapped)}[${parts.join(",")}]`;
+};
+var browserInstrumentationIsSafe = (filePath, original, transformed) => {
+  if (transformedSourceIsInvalid(filePath, transformed)) return false;
+  try {
+    parseSource(transformed, filePath);
+  } catch {
+    return false;
+  }
+  return signatureOf(parseSource(original, filePath)) === signatureOf(parseSource(transformed, filePath));
+};
+
+// ../instrumentation/src/instrument-browser-source.ts
+var refuse = (source, classifications) => ({
+  code: source,
+  delta: { functions: [], callSites: [], destructures: [] },
+  classifications,
+  sites: [],
+  identities: [],
+  verificationFailed: true
+});
+var instrumentBrowserSource = (source, filePath, emitIds, reactiveIds, moduleIndex = 0, options) => {
+  if (source.includes("@rasputin-ignore-file") || sourceIsRasputinInstrumented(source)) {
+    return {
+      code: source,
+      classifications: [],
+      sites: [],
+      identities: [],
+      delta: { functions: [], callSites: [], destructures: [], alreadyInstrumented: true }
+    };
+  }
+  const sourceFile = parseSource(source, filePath);
+  const classifications = classifyFunctions(source, filePath, options?.mapLocation);
+  const observe = collectObserveSiteEdits(
+    source,
+    filePath,
+    { classifications, emitIds },
+    sourceFile
+  );
+  const literals = collectLiteralSiteEdits(source, filePath, { classifications }, sourceFile);
+  const json = collectJsonProducerEdits(source, filePath, sourceFile, { adoptCalls: true });
+  const functions = collectBrowserFunctionEdits(
+    source,
+    sourceFile,
+    classifications,
+    moduleIndex,
+    reactiveIds ?? { value: 1 },
+    {
+      observe: observe.sites.length > 0,
+      struct: literals.edits.length > 0,
+      includePlans: options?.includePlans === true,
+      mapLocation: options?.mapLocation
+    }
+  );
+  const edits = [...observe.edits, ...literals.edits, ...json.edits, ...functions.edits];
+  if (edits.length === 0) {
+    return {
+      code: source,
+      classifications,
+      sites: [],
+      identities: [],
+      delta: functions.delta
+    };
+  }
+  const code = applyEdits(source, edits);
+  if (!browserInstrumentationIsSafe(filePath, source, code)) {
+    return refuse(source, classifications);
+  }
+  return {
+    code,
+    map: exactTransformMap(source, code, basename2(filePath), edits),
+    delta: functions.delta,
+    classifications,
+    sites: observe.sites,
+    identities: functions.identities
+  };
+};
+
+// ../instrumentation/src/instrument-provenance-source.ts
+import { basename as basename3 } from "node:path";
+
+// ../instrumentation/src/provenance-function-edits.ts
+import ts15 from "typescript";
+var PROVENANCE_HANDLE_CALLEE = "globalThis.__rasputinN";
+var PROVENANCE_HANDLE_GUARD = "globalThis.__rasputinN??=function(){return{leave:function(v){return v},end:function(){},suspend:function(v){return v},resume:function(v){return v}}};";
+var isProvenanceTarget = (node) => (ts15.isFunctionDeclaration(node) || ts15.isFunctionExpression(node) || ts15.isArrowFunction(node) || ts15.isMethodDeclaration(node)) && node.body !== void 0 && !node.asteriskToken;
+var isDirectivePrologue2 = (statement) => ts15.isExpressionStatement(statement) && ts15.isStringLiteral(statement.expression);
+var insertPositionAfterPrologue2 = (source, sourceFile) => {
+  const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
+  let end = shebangEnd;
+  for (const statement of sourceFile.statements) {
+    if (!isDirectivePrologue2(statement)) break;
+    end = statement.end;
+  }
+  return end;
+};
+var preambleInsert2 = (source, position, preamble) => {
+  if (position <= 0) return preamble;
+  const previous = source[position - 1];
+  return previous === ";" || previous === "\n" || previous === "\r" ? preamble : `;${preamble}`;
+};
+var functionBodyPrologueEnd2 = (body, sourceFile) => {
+  let end = body.getStart(sourceFile) + 1;
+  for (const statement of body.statements) {
+    if (!isDirectivePrologue2(statement)) break;
+    end = statement.end;
+  }
+  return end;
+};
+var walkOwnBody2 = (node, visitNode) => {
+  if (!node.body) return;
+  const visit = (candidate) => {
+    if (candidate !== node && ts15.isFunctionLike(candidate)) return;
+    visitNode(candidate);
+    ts15.forEachChild(candidate, visit);
+  };
+  visit(node.body);
+};
+var producerName = (node) => {
+  const callee = peel(node.expression);
+  if (ts15.isPropertyAccessExpression(callee) && ts15.isIdentifier(callee.name)) {
+    return callee.name.text;
+  }
+  return void 0;
+};
+var NON_PROVENANCE_ROOTS2 = /* @__PURE__ */ new Set([
+  "String",
+  "Number",
+  "Boolean",
+  "Object",
+  "Array",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "URIError",
+  "EvalError",
+  "ReferenceError",
+  "Symbol",
+  "BigInt",
+  "Math",
+  "JSON",
+  "Date",
+  "Promise",
+  "console",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI"
+]);
+var callCanCarryProvenance2 = (node) => {
+  const name = producerName(node);
+  if (name === "json" || name === "parse") return true;
+  if (name === "call" || name === "apply") return false;
+  const callee = peel(node.expression);
+  if (ts15.isIdentifier(callee)) return !NON_PROVENANCE_ROOTS2.has(callee.text);
+  if (ts15.isPropertyAccessExpression(callee)) {
+    const object = peel(callee.expression);
+    if (ts15.isIdentifier(object) && NON_PROVENANCE_ROOTS2.has(object.text)) {
+      return object.text === "JSON" && callee.name.text === "parse";
+    }
+  }
+  return true;
+};
+var returnedExpressionNeedsProvenance = (expression) => {
+  const inner = peel(expression);
+  if (ts15.isAwaitExpression(inner)) return true;
+  if (ts15.isCallExpression(inner)) return callCanCarryProvenance2(inner);
+  return false;
+};
+var functionNeedsProvenance = (node) => {
+  if (ts15.isArrowFunction(node) && !ts15.isBlock(node.body)) {
+    const body = peel(node.body);
+    if (ts15.isAwaitExpression(body)) return true;
+    if (ts15.isCallExpression(body)) return callCanCarryProvenance2(body);
+    return false;
+  }
+  let needed = false;
+  walkOwnBody2(node, (candidate) => {
+    if (needed) return;
+    if (ts15.isAwaitExpression(candidate)) {
+      needed = true;
+      return;
+    }
+    if (ts15.isReturnStatement(candidate) && candidate.expression) {
+      if (returnedExpressionNeedsProvenance(candidate.expression)) needed = true;
+      return;
+    }
+    if (ts15.isCallExpression(candidate)) {
+      const name = producerName(candidate);
+      if (name === "json" || name === "parse") needed = true;
+    }
+  });
+  return needed;
+};
+var collectReturnWraps2 = (node, sourceFile, handleName, edits) => {
+  if (!ts15.isBlock(node.body)) return;
+  walkOwnBody2(node, (candidate) => {
+    if (!ts15.isReturnStatement(candidate) || !candidate.expression) return;
+    wrap(
+      edits,
+      candidate.expression.getStart(sourceFile),
+      candidate.expression.end,
+      `(${handleName}.leave((`,
+      ")))",
+      1
+    );
+  });
+};
+var collectAwaitSuspends = (node, sourceFile, handleName, edits) => {
+  walkOwnBody2(node, (candidate) => {
+    if (!ts15.isAwaitExpression(candidate)) return;
+    wrap(
+      edits,
+      candidate.expression.getStart(sourceFile),
+      candidate.expression.end,
+      `${handleName}.suspend(`,
+      ")",
+      15
+    );
+  });
+};
+var functionRef2 = (node) => {
+  if (node.name && ts15.isIdentifier(node.name)) {
+    if (ts15.isMethodDeclaration(node)) return void 0;
+    return node.name.text;
+  }
+  const parent = node.parent;
+  if (ts15.isVariableDeclaration(parent) && ts15.isIdentifier(parent.name) && parent.initializer === node) {
+    return parent.name.text;
+  }
+  return void 0;
+};
+var collectProvenanceFunctionEdits = (source, sourceFile) => {
+  const edits = [];
+  const handleName = uniqueName(source, "__rasputinPH__");
+  const errorName = uniqueName(source, "__rasputinPE__");
+  let functionWraps = 0;
+  const visit = (node) => {
+    if (isProvenanceTarget(node) && functionNeedsProvenance(node)) {
+      const decision = isAsyncFunctionLike(node) ? decideAsyncInstrumentation(node, sourceFile) : { action: "inline" };
+      if (decision.action !== "skip") {
+        const ref = functionRef2(node);
+        const enter = ref ? `${PROVENANCE_HANDLE_CALLEE}(${ref})` : `${PROVENANCE_HANDLE_CALLEE}()`;
+        const epilogue = `}catch(${errorName}){throw ${errorName};}finally{${handleName}.end();}`;
+        if (ts15.isBlock(node.body)) {
+          const openAt = functionBodyPrologueEnd2(node.body, sourceFile);
+          const closeAt = node.body.end - 1;
+          wrap(edits, openAt, closeAt, `;const ${handleName}=${enter};try{`, epilogue, 0);
+          collectReturnWraps2(node, sourceFile, handleName, edits);
+          if (decision.action === "suspend_resume") {
+            collectAwaitSuspends(node, sourceFile, handleName, edits);
+          }
+        } else {
+          wrap(
+            edits,
+            node.body.getStart(sourceFile),
+            node.body.end,
+            `{;const ${handleName}=${enter};try{return (${handleName}.leave((`,
+            `)));${epilogue}}`,
+            0
+          );
+          if (decision.action === "suspend_resume") {
+            collectAwaitSuspends(node, sourceFile, handleName, edits);
+          }
+        }
+        functionWraps += 1;
+      }
+    }
+    ts15.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  if (functionWraps > 0) {
+    const insertAt = insertPositionAfterPrologue2(source, sourceFile);
+    edits.push({
+      position: insertAt,
+      text: preambleInsert2(
+        source,
+        insertAt,
+        `${RASPUTIN_INSTRUMENTATION_PREAMBLE}${PROVENANCE_HANDLE_GUARD}`
+      ),
+      deleteCount: 0,
+      depth: -1,
+      width: 0,
+      kind: "replace"
+    });
+  }
+  return { edits, functionWraps };
+};
+
+// ../instrumentation/src/instrument-provenance-source.ts
+var instrumentProvenanceSource = (source, filePath) => {
+  if (source.includes("@rasputin-ignore-file") || sourceIsRasputinInstrumented(source)) {
+    return {
+      code: source,
+      awaitWraps: 0,
+      callWraps: 0,
+      functionWraps: 0,
+      provenanceSkippedComplexCall: 0
+    };
+  }
+  const sourceFile = parseSource(source, filePath);
+  const json = collectJsonProducerEdits(source, filePath, sourceFile, { adoptCalls: true });
+  const functions = collectProvenanceFunctionEdits(source, sourceFile);
+  const edits = [...json.edits, ...functions.edits];
+  if (edits.length === 0) {
+    return {
+      code: source,
+      awaitWraps: 0,
+      callWraps: 0,
+      functionWraps: 0,
+      provenanceSkippedComplexCall: json.provenanceSkippedComplexCall
+    };
+  }
+  const code = applyEdits(source, edits);
+  if (!browserInstrumentationIsSafe(filePath, source, code)) {
+    return {
+      code: source,
+      awaitWraps: 0,
+      callWraps: 0,
+      functionWraps: 0,
+      provenanceSkippedComplexCall: json.provenanceSkippedComplexCall,
+      verificationFailed: true
+    };
+  }
+  return {
+    code,
+    map: exactTransformMap(source, code, basename3(filePath), edits),
+    awaitWraps: json.awaitWraps,
+    callWraps: json.callWraps,
+    functionWraps: functions.functionWraps,
+    provenanceSkippedComplexCall: json.provenanceSkippedComplexCall
+  };
+};
+
+// ../instrumentation/src/provenance-coverage.ts
+var isRasputinSdkPath = (path) => path.includes("/@rasputin-ai/") || path.includes("/recorder/src/") || path.includes("/recorder/dist/") || path.includes("/instrumentation/src/") || path.includes("/instrumentation/dist/") || path.includes("/browser/src/") || path.includes("/browser/dist/") || path.includes("/core/src/") || path.includes("/core/dist/") || path.includes("/node/src/") || path.includes("/elysia/src/");
+var isBundledDependencyPath = (path) => /(^|\/)node_modules\//.test(path) || path.includes("/.vite/deps/") || path.includes("node_modules/.vite/deps/");
+var coverageForModule = (filePath, options) => {
+  const path = filePath.replaceAll("\\", "/");
+  if (!path || path.includes("\0")) return "none";
+  if (options?.skipPaths?.some((segment) => path.includes(segment.replaceAll("\\", "/")))) {
+    return "none";
+  }
+  if (isRasputinSdkPath(path)) return "none";
+  if (isBundledDependencyPath(path)) {
+    const mode = options?.dependencyCoverage ?? (options?.provenanceDependencies === true ? "provenance" : "none");
+    if (mode === "full") return "full";
+    if (mode === "provenance") return "provenance";
+    return "none";
+  }
+  return "full";
+};
+
+// ../instrumentation/src/source-map-location.ts
+import { dirname as dirname2, join } from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
+var baseName = (path) => path.replaceAll("\\", "/").split("/").pop()?.split("?")[0] ?? "";
+var isWindowsAbsolute = (path) => /^[A-Za-z]:[\\/]/.test(path);
+var sameSourceFile = (source, generatedPath) => {
+  const sourceName = baseName(source);
+  const generatedName = baseName(generatedPath);
+  return sourceName.length > 0 && sourceName === generatedName;
+};
+var toFilePath = (source, generatedPath) => {
+  if (sameSourceFile(source, generatedPath)) return generatedPath;
+  if (source.startsWith("file:")) {
+    try {
+      return fileURLToPath2(source);
+    } catch {
+      return generatedPath;
+    }
+  }
+  if (isWindowsAbsolute(source) || source.startsWith("/")) return source;
+  return join(dirname2(generatedPath), source);
+};
+var isSourceMapInput = (value) => {
+  if (typeof value === "string") return true;
+  if (!value || typeof value !== "object") return false;
+  return value instanceof TraceMap || "mappings" in value;
+};
+var createSourceMapLocationMapper = (generatedPath, map) => {
+  if (!isSourceMapInput(map)) return void 0;
+  try {
+    const traceMap = new TraceMap(map, pathToFileURL(generatedPath).href);
+    return (generated) => {
+      let original = originalPositionFor(traceMap, {
+        line: generated.line,
+        column: Math.max(0, generated.column - 1)
+      });
+      if (!original.source || original.line == null) {
+        original = originalPositionFor(traceMap, {
+          line: generated.line,
+          column: 0
+        });
+      }
+      if (!original.source || original.line == null) return void 0;
+      return {
+        filePath: toFilePath(original.source, generatedPath),
+        line: original.line,
+        column: (original.column ?? 0) + 1
+      };
+    };
+  } catch {
+    return void 0;
+  }
+};
+
+// src/vite/artifacts.ts
+import { createHash as createHash3 } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var contentDebugId = (source) => {
+  const hex = createHash3("sha256").update(source).digest("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+};
+var contentHash = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
+var summarizeClassification = (functions, expressionSites) => {
+  const counts = {
+    full: 0,
+    structure: 0,
+    skip: 0,
+    reactiveSparse: 0,
+    expressionSites: expressionSites.length
+  };
+  for (const fn of functions) {
+    if (fn.captureClass === "structure") counts.structure += 1;
+    else if (fn.captureClass === "skip") counts.skip += 1;
+    else if (fn.captureClass === "reactive-sparse") counts.reactiveSparse += 1;
+    else counts.full += 1;
+  }
+  return counts;
+};
+var writeLocalArtifacts = (directory, artifacts) => {
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(join2(directory, "artifacts.json"), `${JSON.stringify(artifacts, null, "	")}
+`);
+  writeFileSync(
+    join2(directory, "classification.json"),
+    `${JSON.stringify(
+      {
+        ...artifacts.classification,
+        functions: artifacts.functions.map((fn) => ({
+          functionId: fn.functionId,
+          name: fn.name,
+          captureClass: fn.captureClass,
+          captureReason: fn.captureReason,
+          filePath: fn.filePath,
+          line: fn.line,
+          column: fn.column
+        })),
+        expressionSites: artifacts.expressionSites
+      },
+      null,
+      "	"
+    )}
+`
+  );
+};
+
+// src/vite/resolve-build-identity.ts
+import { randomUUID } from "node:crypto";
+var isGitSha = (value) => /^[0-9a-f]{7,40}$/i.test(value.trim());
+var createBrowserCompileId = () => `b_${randomUUID()}`;
+var normalizeExplicitCompileId = (value) => {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  if (isGitSha(trimmed)) return "";
+  return trimmed;
+};
+
+// src/vite/upload-browser-artifacts.ts
+var DEFAULT_API_URL = "https://api.rasputinai.dev";
+var uploadBrowserArtifacts = async (input) => {
+  const key = (input.projectApiKey ?? process.env.RASPUTIN_PROJECT_API_KEY ?? "").trim();
+  if (key.length === 0 || key.startsWith("rdn_") || key.includes("@")) return "skipped";
+  const apiUrl = (input.apiUrl ?? process.env.RASPUTIN_API_URL ?? DEFAULT_API_URL).replace(
+    /\/+$/,
+    ""
+  );
+  try {
+    const response = await fetch(`${apiUrl}/browserArtifacts`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${key}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        buildId: input.artifacts.buildId,
+        release: input.release,
+        contentHash: contentHash(input.artifacts),
+        artifact: input.artifacts,
+        ...input.replace === true ? { replace: true } : {}
+      })
+    });
+    if (response.status === 409) return "conflict";
+    if (response.status === 200 || response.status === 201) {
+      const body = await response.json().catch(() => ({}));
+      if (body && typeof body === "object" && "duplicate" in body && body.duplicate === true) {
+        return "duplicate";
+      }
+      return "uploaded";
+    }
+    console.warn(
+      `[rasputin] artifact upload failed (${response.status}); the build still succeeded`
+    );
+    return "failed";
+  } catch {
+    console.warn("[rasputin] artifact upload failed; the build still succeeded");
+    return "failed";
+  }
+};
+
+// src/vite/plugin.ts
+var isServerModule = (path) => path.includes(".server.") || path.endsWith("+server.ts") || path.endsWith("+server.js") || path.includes("/hooks.server.");
+var isRasputinSdkModule = (path) => path.includes("/@rasputin-ai/") || path.includes("/recorder/src/") || path.includes("/recorder/dist/") || path.includes("/instrumentation/src/") || path.includes("/instrumentation/dist/") || path.includes("/browser/src/") || path.includes("/browser/dist/") || path.includes("/core/src/") || path.includes("/core/dist/") || path.includes("/node/src/") || path.includes("/elysia/src/");
+var isRasputinBrowserRuntimeSource = (code) => code.includes("rasputin.browser.client.v1");
+var isJsModulePath = (path) => /\.[cm]?[jt]sx?$/.test(path) && !isSvelteCompiledPath(path);
+var MAX_PROVENANCE_SOURCE_CHARS = 15e5;
+var countToken = (code, token) => {
+  let count = 0;
+  let from = 0;
+  while (true) {
+    const at = code.indexOf(token, from);
+    if (at === -1) return count;
+    count += 1;
+    from = at + token.length;
+  }
+};
+var isApplicationModule = (id, onlyIfPathIncludes) => {
+  const path = id.split("?")[0]?.replaceAll("\\", "/") ?? "";
+  if (!path) return false;
+  if (path.includes("/node_modules/")) return false;
+  if (path.includes("\0")) return false;
+  if (isRasputinSdkModule(path)) return false;
+  if (path.includes("virtual:rasputin")) return false;
+  if (isSvelteCompiledPath(path)) return false;
+  if (isServerModule(path)) return false;
+  if (onlyIfPathIncludes && onlyIfPathIncludes.length > 0) {
+    if (!onlyIfPathIncludes.some((segment) => path.includes(segment.replaceAll("\\", "/")))) {
+      return false;
+    }
+  }
+  return /\.[cm]?[jt]sx?$/.test(path);
+};
+var recoveredWindowsPath = (filePath) => {
+  const path = filePath.replaceAll("\\", "/");
+  const parts = path.split(/(?=[A-Za-z]:\/)/);
+  return parts.length > 1 ? parts.at(-1) ?? path : path;
+};
+var artifactSourcePath = (filePath, projectRoot) => {
+  const recovered = recoveredWindowsPath(filePath);
+  if (projectRoot && (isAbsolute2(recovered) || /^[A-Za-z]:\//.test(recovered))) {
+    return relative2(projectRoot, recovered).replaceAll("\\", "/");
+  }
+  return recovered.replace(/^\.\//, "");
+};
+var toArtifactCallSite = (site, projectRoot, packageName) => ({
+  callerFunctionId: site.callerFunctionId,
+  calleeName: site.calleeName,
+  calleeText: site.calleeText,
+  packageName,
+  packageRelativePath: artifactSourcePath(site.filePath, projectRoot),
+  line: site.line,
+  column: site.column,
+  endLine: site.endLine,
+  endColumn: site.endColumn,
+  resultBinding: site.resultBinding,
+  argIdentifiers: site.argIdentifiers
+});
+var toArtifactDestructure = (destructure, projectRoot, packageName) => ({
+  callerFunctionId: destructure.callerFunctionId,
+  sourceParam: destructure.sourceParam,
+  packageName,
+  packageRelativePath: artifactSourcePath(destructure.filePath, projectRoot),
+  line: destructure.line,
+  column: destructure.column,
+  binding: destructure.binding
+});
+var isCompiledSvelteModule = (id, onlyIfPathIncludes) => {
+  const [filePath, query] = id.split("?");
+  const path = filePath?.replaceAll("\\", "/") ?? "";
+  if (!isSvelteCompiledPath(path)) return false;
+  if (path.includes("/node_modules/")) return false;
+  if (path.includes("\0")) return false;
+  if (query?.includes("type=style") || query?.includes("type=preprocessed")) return false;
+  if (isServerModule(path)) return false;
+  if (onlyIfPathIncludes && onlyIfPathIncludes.length > 0) {
+    if (!onlyIfPathIncludes.some((segment) => path.includes(segment.replaceAll("\\", "/")))) {
+      return false;
+    }
+  }
+  return true;
+};
+var classificationById = (classifications) => {
+  const found2 = /* @__PURE__ */ new Map();
+  for (const item of classifications) found2.set(item.functionId, item);
+  return found2;
+};
+var toManifestFunctions = (delta, classifications, identities) => {
+  const classified = classificationById(classifications);
+  const indexed = new Map(identities.map((item) => [item.functionId, item]));
+  return delta.functions.map((fn) => {
+    const match = classified.get(fn.functionId);
+    const index = indexed.get(fn.functionId);
+    return {
+      functionId: fn.functionId,
+      name: fn.name,
+      packageName: fn.plan[2],
+      packageRelativePath: fn.plan[3],
+      line: fn.plan[4],
+      column: fn.plan[5],
+      endLine: fn.endLine,
+      endColumn: fn.endColumn,
+      params: fn.params,
+      filePath: fn.filePath,
+      captureClass: match?.captureClass ?? "full",
+      captureReason: match?.captureReason ?? "unclassified-default",
+      ...index ? { moduleIndex: index.moduleIndex, planIndex: index.planIndex } : {},
+      ...index?.siteId === void 0 ? {} : { siteId: index.siteId }
+    };
+  });
+};
+var publicDsn = (value) => {
+  return (value ?? process.env.VITE_RASPUTIN_DSN ?? "").trim();
+};
+var VIRTUAL_INIT_ID = "virtual:rasputin-init";
+var RESOLVED_VIRTUAL_INIT_ID = `\0${VIRTUAL_INIT_ID}`;
+var isVirtualInitId = (id) => id === VIRTUAL_INIT_ID || id === RESOLVED_VIRTUAL_INIT_ID;
+var isArtifactsPath = (filePath, directory) => {
+  const file = filePath.replaceAll("\\", "/");
+  const root = directory.replaceAll("\\", "/");
+  return file === root || file.startsWith(`${root}/`);
+};
+var rasputin = (options) => {
+  if (options.enabled === false) return [];
+  const functions = /* @__PURE__ */ new Map();
+  const callSites = /* @__PURE__ */ new Map();
+  const destructures = /* @__PURE__ */ new Map();
+  const BUILD_IDENTITIES_MARKER = "@@RASPUTIN_IDENTITIES@@";
+  const BUILD_STATS_MARKER = "@@RASPUTIN_STATS@@";
+  const runtimeIdentities = [];
+  const expressionSites = /* @__PURE__ */ new Map();
+  const verificationFailed = /* @__PURE__ */ new Set();
+  const emitIds = { value: 1 };
+  const reactiveIds = { value: 1 };
+  let nextModuleIndex = 0;
+  let artifactsDir = options.artifactsDir;
+  const identity = {
+    buildId: normalizeExplicitCompileId(options.buildId) || createBrowserCompileId(),
+    release: options.release.trim()
+  };
+  const environment = options.environment.trim();
+  let projectRoot = "";
+  let keepPublicMaps = false;
+  let includeRuntimeNames = options.includeRuntimeNames ?? true;
+  let command = "unknown";
+  const dependencyCoverage = options.dependencyCoverage ?? "provenance";
+  const provenanceStats = {
+    modules: 0,
+    functionWraps: 0,
+    awaitWraps: 0,
+    callWraps: 0,
+    skippedComplexCall: 0,
+    n: 0,
+    p: 0,
+    a: 0,
+    m: 0
+  };
+  const snapshotArtifacts = (debugImages = []) => {
+    const manifestFunctions = [...functions.values()];
+    const sites = [...expressionSites.values()];
+    return {
+      schema_version: 1,
+      buildId: identity.buildId,
+      functions: manifestFunctions,
+      identities: runtimeIdentities.map((item) => {
+        const match = manifestFunctions.find(
+          (fn) => fn.moduleIndex === item.moduleIndex && fn.planIndex === item.planIndex
+        );
+        return {
+          ...item,
+          functionId: match?.functionId ?? item.functionId
+        };
+      }),
+      callSites: [...callSites.values()],
+      destructures: [...destructures.values()],
+      expressionSites: sites,
+      classification: summarizeClassification(manifestFunctions, sites),
+      debugImages,
+      verificationFailed: [...verificationFailed],
+      provenance: { ...provenanceStats }
+    };
+  };
+  const persistArtifacts = (input) => {
+    if (!artifactsDir) return;
+    const artifacts = snapshotArtifacts(input.debugImages ?? []);
+    writeLocalArtifacts(artifactsDir, artifacts);
+    if (!input.upload || options.uploadArtifacts === false) return;
+    void uploadBrowserArtifacts({
+      artifacts,
+      release: identity.release,
+      projectApiKey: options.projectApiKey,
+      apiUrl: options.apiUrl,
+      replace: input.replace === true
+    });
+  };
+  const recordInstrumented = (code, filePath, original, incomingMap) => {
+    const instrumented = instrumentBrowserSource(
+      code,
+      filePath,
+      emitIds,
+      reactiveIds,
+      nextModuleIndex++,
+      {
+        includePlans: includeRuntimeNames,
+        mapLocation: createSourceMapLocationMapper(filePath, incomingMap)
+      }
+    );
+    if (instrumented.verificationFailed) {
+      verificationFailed.add(filePath);
+      return code === original ? void 0 : { code: original, map: null };
+    }
+    if (instrumented.delta) {
+      const nextFunctions = toManifestFunctions(
+        instrumented.delta,
+        instrumented.classifications,
+        instrumented.identities
+      );
+      for (const fn of nextFunctions) functions.set(fn.functionId, fn);
+      const packageNameOf = (functionId) => functions.get(functionId)?.packageName ?? null;
+      for (const site of instrumented.delta.callSites) {
+        const artifact = toArtifactCallSite(
+          site,
+          projectRoot,
+          packageNameOf(site.callerFunctionId)
+        );
+        callSites.set(
+          `${site.callerFunctionId}:${site.line}:${site.column}:${site.calleeName}`,
+          artifact
+        );
+      }
+      for (const destructure of instrumented.delta.destructures) {
+        destructures.set(
+          `${destructure.callerFunctionId}:${destructure.line}:${destructure.column}:${destructure.sourceParam}`,
+          toArtifactDestructure(
+            destructure,
+            projectRoot,
+            packageNameOf(destructure.callerFunctionId)
+          )
+        );
+      }
+    }
+    const moduleIdentities = instrumented.identities.map((identity2) => ({
+      compactId: identity2.compactId,
+      functionId: identity2.compactId,
+      name: identity2.name,
+      captureClass: identity2.captureClass,
+      packageRelativePath: projectRoot ? artifactSourcePath(identity2.filePath, projectRoot) : null,
+      line: identity2.line,
+      column: identity2.column,
+      ...identity2.siteId === void 0 ? {} : { siteId: identity2.siteId },
+      moduleIndex: identity2.moduleIndex,
+      planIndex: identity2.planIndex
+    }));
+    for (const identity2 of moduleIdentities) runtimeIdentities.push(identity2);
+    for (const site of instrumented.sites) {
+      expressionSites.set(site.siteId, site);
+    }
+    if (!instrumented.delta && instrumented.sites.length === 0 && instrumented.code === code) {
+      return code === original ? void 0 : { code, map: null };
+    }
+    const source = projectRoot ? relative2(projectRoot, filePath).replaceAll("\\", "/") : filePath.replaceAll("\\", "/");
+    const map = instrumented.map ? {
+      ...instrumented.map,
+      file: source,
+      sources: [source],
+      names: instrumented.map.names ?? []
+    } : null;
+    let nextCode = instrumented.code;
+    if (includeRuntimeNames && moduleIdentities.length > 0) {
+      nextCode = `${nextCode}
+;globalThis.__rasputinRegisterIdentities?.(${JSON.stringify(moduleIdentities)});`;
+    }
+    return { code: nextCode, map };
+  };
+  const recordProvenance = (code, filePath, original) => {
+    if (code.length > MAX_PROVENANCE_SOURCE_CHARS) {
+      return code === original ? void 0 : { code: original, map: null };
+    }
+    const instrumented = instrumentProvenanceSource(code, filePath);
+    if (instrumented.verificationFailed) {
+      verificationFailed.add(filePath);
+      return code === original ? void 0 : { code: original, map: null };
+    }
+    if (instrumented.code === code) {
+      return code === original ? void 0 : { code, map: null };
+    }
+    provenanceStats.modules += 1;
+    provenanceStats.functionWraps += instrumented.functionWraps;
+    provenanceStats.awaitWraps += instrumented.awaitWraps;
+    provenanceStats.callWraps += instrumented.callWraps;
+    provenanceStats.skippedComplexCall += instrumented.provenanceSkippedComplexCall;
+    provenanceStats.n += countToken(instrumented.code, "__rasputinN(");
+    provenanceStats.p += countToken(instrumented.code, "__rasputinP(");
+    provenanceStats.a += countToken(instrumented.code, "__rasputinA(");
+    provenanceStats.m += countToken(instrumented.code, "__rasputinM(");
+    const source = projectRoot ? relative2(projectRoot, filePath).replaceAll("\\", "/") : filePath.replaceAll("\\", "/");
+    const map = instrumented.map ? {
+      ...instrumented.map,
+      file: source,
+      sources: [source],
+      names: instrumented.map.names ?? []
+    } : null;
+    return { code: instrumented.code, map };
+  };
+  const plugin = {
+    name: "rasputin-browser",
+    enforce: "pre",
+    config(config) {
+      const requested = config.build?.sourcemap;
+      keepPublicMaps = requested === true || requested === "inline";
+      if (requested === false || keepPublicMaps) return void 0;
+      return {
+        build: {
+          sourcemap: "hidden"
+        }
+      };
+    },
+    configResolved(config) {
+      artifactsDir = options.artifactsDir ?? resolve5(config.root, ".rasputin");
+      projectRoot = config.root;
+      command = config.command === "serve" || config.command === "build" ? config.command : "unknown";
+      includeRuntimeNames = options.includeRuntimeNames ?? (config.command !== "build" || config.mode !== "production");
+    },
+    configureServer(server) {
+      if (artifactsDir) server.watcher?.unwatch?.(artifactsDir);
+    },
+    resolveId(id) {
+      if (isVirtualInitId(id)) return RESOLVED_VIRTUAL_INIT_ID;
+      return void 0;
+    },
+    load(id) {
+      if (!isVirtualInitId(id)) return void 0;
+      const dsn = publicDsn(options.dsn);
+      const ingest = options.ingest !== false;
+      return `import { RasputinInit } from '@rasputin-ai/browser';
+globalThis.__RASPUTIN_BUILD_ID__ = ${JSON.stringify(identity.buildId)};
+globalThis.__RASPUTIN_RELEASE__ = ${JSON.stringify(identity.release)};
+globalThis.__RASPUTIN_ENVIRONMENT__ = ${JSON.stringify(environment)};
+globalThis.__RASPUTIN_DSN__ = ${JSON.stringify(dsn)};
+globalThis.__RASPUTIN_BUILD_IDENTITIES__ = globalThis.__RASPUTIN_BUILD_IDENTITIES__ ?? "${BUILD_IDENTITIES_MARKER}";
+globalThis.__RASPUTIN_BUILD_STATS__ = globalThis.__RASPUTIN_BUILD_STATS__ ?? "${BUILD_STATS_MARKER}";
+RasputinInit({
+	dsn: ${JSON.stringify(dsn)},
+	environment: ${JSON.stringify(environment)},
+	release: ${JSON.stringify(identity.release)},
+	buildId: ${JSON.stringify(identity.buildId)},
+	ingest: ${ingest ? "true" : "false"},
+	identities: globalThis.__RASPUTIN_BUILD_IDENTITIES__,
+});
+`;
+    },
+    transform(code, id, transformOptions) {
+      if (transformOptions?.ssr) return void 0;
+      const filePath = id.split("?")[0];
+      if (!filePath) return void 0;
+      const normalized = filePath.replaceAll("\\", "/");
+      let next = code;
+      if (normalized.endsWith("/src/main.ts") || normalized.endsWith("/hooks.client.ts")) {
+        const extras = (options.bootstrapImports ?? []).map((moduleId) => `import '${moduleId}';`).join("\n");
+        next = `import 'virtual:rasputin-init';
+${extras}${extras ? "\n" : ""}${code}`;
+      }
+      if (isRasputinBrowserRuntimeSource(next)) {
+        return next === code ? void 0 : { code: next, map: null };
+      }
+      if (isServerModule(normalized)) {
+        return next === code ? void 0 : { code: next, map: null };
+      }
+      const coverage = coverageForModule(normalized, { dependencyCoverage });
+      if (coverage === "none") {
+        return next === code ? void 0 : { code: next, map: null };
+      }
+      if (coverage === "provenance") {
+        if (!isJsModulePath(normalized)) {
+          return next === code ? void 0 : { code: next, map: null };
+        }
+        return recordProvenance(next, filePath, code);
+      }
+      if (!isApplicationModule(id, options.onlyIfPathIncludes)) {
+        if (dependencyCoverage === "full" && isJsModulePath(normalized)) {
+          return recordInstrumented(next, filePath, code);
+        }
+        return next === code ? void 0 : { code: next, map: null };
+      }
+      return recordInstrumented(next, filePath, code);
+    },
+    generateBundle(_output, bundle) {
+      const environmentName = this && typeof this === "object" ? Reflect.get(this, "environment") : void 0;
+      const name = environmentName && typeof environmentName === "object" ? Reflect.get(environmentName, "name") : void 0;
+      if (name === "ssr") return;
+      const debugImages = [];
+      const identitiesJson = includeRuntimeNames ? JSON.stringify(runtimeIdentities) : "[]";
+      const classification = summarizeClassification(
+        [...functions.values()],
+        [...expressionSites.values()]
+      );
+      const statsJson = JSON.stringify({
+        functions: functions.size,
+        full: classification.full,
+        structure: classification.structure,
+        skip: classification.skip,
+        reactiveSparse: classification.reactiveSparse,
+        verificationFailed: verificationFailed.size,
+        provenanceModules: provenanceStats.modules,
+        provenanceN: provenanceStats.n,
+        provenanceP: provenanceStats.p,
+        provenanceA: provenanceStats.a,
+        provenanceM: provenanceStats.m,
+        dependencyCoverage
+      });
+      for (const [fileName, item] of Object.entries(bundle)) {
+        if (!keepPublicMaps && fileName.endsWith(".map")) {
+          Reflect.deleteProperty(bundle, fileName);
+          continue;
+        }
+        if (item.type !== "chunk") continue;
+        const debugId = contentDebugId(item.code);
+        item.code = item.code.replaceAll(
+          new RegExp(`[\`"']${BUILD_IDENTITIES_MARKER}[\`"']`, "g"),
+          identitiesJson
+        );
+        item.code = item.code.replaceAll(
+          new RegExp(`[\`"']${BUILD_STATS_MARKER}[\`"']`, "g"),
+          statsJson
+        );
+        item.code = `${item.code.replace(/\n?$/, "\n")}//# debugId=${debugId}
+`;
+        if (!keepPublicMaps) {
+          item.code = item.code.replace(/\n\/\/# sourceMappingURL=[^\n]+/g, "\n");
+        }
+        debugImages.push({
+          debugId,
+          fileName: item.fileName,
+          map: item.map ?? null
+        });
+        if (!keepPublicMaps) item.map = null;
+      }
+      if (command !== "serve") {
+        persistArtifacts({
+          debugImages,
+          upload: command === "build"
+        });
+      }
+    },
+    handleHotUpdate(ctx) {
+      if (artifactsDir && isArtifactsPath(ctx.file, artifactsDir)) return [];
+      return void 0;
+    }
+  };
+  Reflect.set(plugin, "applyToEnvironment", (environmentRef) => {
+    return environmentRef.name !== "ssr";
+  });
+  const sveltePlugin = {
+    name: "rasputin-browser-svelte",
+    enforce: "post",
+    configResolved(config) {
+      artifactsDir = options.artifactsDir ?? resolve5(config.root, ".rasputin");
+      projectRoot = config.root;
+    },
+    transform: {
+      order: "post",
+      handler(code, id, transformOptions) {
+        if (transformOptions?.ssr) return void 0;
+        if (!isCompiledSvelteModule(id, options.onlyIfPathIncludes)) return void 0;
+        const filePath = id.split("?")[0];
+        if (!filePath) return void 0;
+        let incomingMap;
+        try {
+          incomingMap = typeof this.getCombinedSourcemap === "function" ? this.getCombinedSourcemap() : void 0;
+        } catch {
+          incomingMap = void 0;
+        }
+        return recordInstrumented(code, filePath, code, incomingMap);
+      }
+    }
+  };
+  Reflect.set(sveltePlugin, "applyToEnvironment", (environmentRef) => {
+    return environmentRef.name !== "ssr";
+  });
+  return [plugin, sveltePlugin];
+};
+export {
+  rasputin
+};