@rasputin-ai/browser 0.6.0

package/dist/index.js

@@ -0,0 +1,3706 @@
+// ../core/src/create-client/parse-dsn.ts
+var DSN_PUBLIC_KEY_PREFIX = "rdn_";
+var parseDsn = (value) => {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  if (!trimmed) return null;
+  try {
+    const url = new URL(trimmed);
+    const publicKey = decodeURIComponent(url.username);
+    if (!publicKey.startsWith(DSN_PUBLIC_KEY_PREFIX)) return null;
+    if (!url.host) return null;
+    const projectId = url.pathname.replace(/^\/+|\/+$/g, "").split("/")[0] ?? "";
+    if (!projectId) return null;
+    return {
+      publicKey,
+      apiUrl: `${url.protocol}//${url.host}`,
+      projectId
+    };
+  } catch {
+    return null;
+  }
+};
+var isLocalDsnPublicKey = (publicKey) => publicKey === "rdn_local" || publicKey.endsWith("_local");
+
+// ../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;
+};
+
+// ../core/src/create-ingest-event/truncate-ingest-message.ts
+var MAX_MESSAGE_BYTES = 8 * 1024;
+
+// ../core/src/create-ingest-event/create-ingest-event.ts
+var MAX_STACK_FRAMES = 50;
+var toStackFrame = (frame) => {
+  const preferred = frame.original ?? frame.generated;
+  const filename = (preferred.file || frame.generated.file).trim();
+  if (!filename) return null;
+  const fn = frame.function ?? frame.original?.name;
+  return {
+    filename,
+    ...frame.source ? { source: frame.source } : {},
+    ...fn ? { function: fn } : {},
+    ...preferred.line !== void 0 ? { lineno: preferred.line } : {},
+    ...preferred.column !== void 0 ? { colno: preferred.column } : {},
+    in_app: frame.in_app
+  };
+};
+var framesToStackFrames = (frames) => frames.slice(0, MAX_STACK_FRAMES).map(toStackFrame).filter((frame) => frame !== null);
+
+// ../core/src/suppression/identity-needs-message-template.ts
+var identityNeedsMessageTemplate = (type, code) => {
+  if (code != null && code !== "") return false;
+  return type === "Error";
+};
+
+// ../core/src/suppression/parameterize-message.ts
+var MAX_INPUT_LENGTH = 8192;
+var IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+var isIpAddress = (value) => {
+  if (IPV4.test(value)) return true;
+  try {
+    return new URL(`http://[${value}]`).hostname.length > 2;
+  } catch {
+    return false;
+  }
+};
+var RULES = [
+  {
+    token: "email",
+    pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,63}\b/giu
+  },
+  {
+    token: "url",
+    pattern: /\b(?:https?|wss?):\/\/[^\s"'<>]+/giu
+  },
+  {
+    token: "traceparent",
+    pattern: /\b00-[0-9a-f]{32}-[0-9a-f]{16}-0[01]\b/giu
+  },
+  {
+    token: "aws_trace_id",
+    pattern: /\b1-[0-9a-f]{8}-[0-9a-f]{24}\b/giu
+  },
+  {
+    token: "uuid",
+    pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/giu
+  },
+  {
+    token: "timestamp",
+    pattern: /\b\d{4}-\d{2}-\d{2}[T ][0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b/gu
+  },
+  {
+    token: "mac",
+    pattern: /\b(?:[0-9a-f]{2}[:-]){5}[0-9a-f]{2}\b/giu
+  },
+  {
+    token: "ip",
+    pattern: /\b(?:\d{1,3}\.){3}\d{1,3}\b|(?<![\w:])(?:[0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}(?![\w:])/giu,
+    validate: isIpAddress
+  },
+  {
+    token: "hash",
+    pattern: /\b[0-9a-f]{16,128}\b/giu
+  },
+  {
+    token: "hex",
+    pattern: /\b0x[0-9a-f]+\b/giu
+  },
+  {
+    token: "duration",
+    pattern: /\b\d+(?:\.\d+)?\s?(?:ns|µs|us|ms|secs?|seconds?|mins?|minutes?|hrs?|hours?|days?)\b/giu
+  },
+  {
+    token: "id",
+    pattern: /\b(?=[a-z0-9]*[a-z])(?=[a-z0-9]*\d)[a-z0-9]{8,}\b/giu
+  }
+];
+var normalizeForIdentity = (normalized) => {
+  try {
+    return JSON.stringify(JSON.parse(normalized));
+  } catch {
+  }
+  const lines = normalized.split("\n").filter((line) => line.trim());
+  let result = lines.slice(0, 2).join("\n");
+  if (result !== normalized) {
+    result += "...";
+  }
+  return result;
+};
+var parameterizeMessage = (rawMessage) => {
+  if (rawMessage.length > MAX_INPUT_LENGTH) return rawMessage;
+  const normalized = rawMessage.normalize("NFKC").replace(/\r\n?/g, "\n").trim();
+  let result = normalizeForIdentity(normalized);
+  result = result.replace(/\b([A-Za-z_][\w.-]*)=(["'])(?:\\.|(?!\2).)*\2/gu, "$1=<string>");
+  result = result.replace(/\b([A-Za-z_][\w.-]*)=(?:true|false)\b/giu, "$1=<bool>");
+  for (const rule of RULES) {
+    result = result.replace(rule.pattern, (match) => {
+      if (rule.validate && !rule.validate(match)) {
+        return match;
+      }
+      return `<${rule.token}>`;
+    });
+  }
+  result = result.replace(/(?<![\w.])-?\d+\.\d+(?:e[+-]?\d+)?(?![\w.])/giu, "<float>").replace(/(?<![\w.])-?\d+(?![\w.])/gu, "<int>");
+  return result;
+};
+
+// ../core/src/suppression/compute-burst-key.ts
+var FRAME_COUNT = 4;
+var preferredFile = (frame) => (frame.original ?? frame.generated).file;
+var normalizeFunction = (raw) => {
+  if (!raw) return "";
+  const name = raw.trim();
+  if (name === "<anonymous>" || name === "anonymous") return "";
+  return name.replace(/^(async|new|get|set|bound)\s+/, "").replace(/^Object\./, "").replace(/\s+\[as .+\]$/, "");
+};
+var collapseConsecutive = (frames) => {
+  const out = [];
+  let previousKey = null;
+  for (const frame of frames) {
+    const file = preferredFile(frame);
+    const fn = normalizeFunction(frame.function ?? frame.original?.name);
+    const key = `${file}#${fn}`;
+    if (key !== previousKey) {
+      out.push(frame);
+      previousKey = key;
+    }
+  }
+  return out;
+};
+var frameBurstParts = (frames) => {
+  const collapsed = collapseConsecutive(frames);
+  const inApp = collapsed.filter((frame) => frame.in_app);
+  const selected = (inApp.length > 0 ? inApp : collapsed).slice(0, FRAME_COUNT);
+  return selected.map((frame) => {
+    const file = preferredFile(frame);
+    const fn = normalizeFunction(frame.function ?? frame.original?.name);
+    return `${file}:${fn}`;
+  });
+};
+var computeBurstKey = (errorType, message, code, frames) => {
+  const parts = frameBurstParts(frames);
+  const codePart = code ?? "";
+  let key = `${errorType}\0${codePart}\0${parts.join("\0")}`;
+  if (parts.length === 0 || identityNeedsMessageTemplate(errorType, code)) {
+    key += `\0${parameterizeMessage(message)}`;
+  }
+  return key;
+};
+
+// ../core/src/suppression/create-suppression.ts
+var DEFAULTS = {
+  windowMs: 6e4,
+  capPerWindow: 5,
+  maxBurstBuckets: 1e3,
+  maxPendingSummaries: 1e3
+};
+var sameDim = (a, b) => (a ?? null) === (b ?? null);
+var captureIdentity = (input) => ({
+  type: input.errorType,
+  message: input.message,
+  stack_frames: framesToStackFrames(input.frames),
+  origin: input.origin,
+  ...input.code !== void 0 ? { code: input.code } : {},
+  resolution: "none"
+});
+var createSuppression = (options = {}) => {
+  const windowMs = options.windowMs ?? DEFAULTS.windowMs;
+  const capPerWindow = options.capPerWindow ?? DEFAULTS.capPerWindow;
+  const maxBurstBuckets = options.maxBurstBuckets ?? DEFAULTS.maxBurstBuckets;
+  const maxPendingSummaries = options.maxPendingSummaries ?? DEFAULTS.maxPendingSummaries;
+  const burstBuckets = /* @__PURE__ */ new Map();
+  const pending = [];
+  const pushPending = (draft) => {
+    pending.push(draft);
+    if (pending.length > maxPendingSummaries)
+      pending.splice(0, pending.length - maxPendingSummaries);
+  };
+  const touch = (burstKey, bucket) => {
+    burstBuckets.delete(burstKey);
+    burstBuckets.set(burstKey, bucket);
+  };
+  const evictIfNeeded = () => {
+    while (burstBuckets.size > maxBurstBuckets) {
+      const oldest = burstBuckets.keys().next().value;
+      if (oldest === void 0) break;
+      const bucket = burstBuckets.get(oldest);
+      if (bucket && bucket.suppressed > 0) {
+        pushPending(toDraft(bucket, Date.now()));
+      }
+      burstBuckets.delete(oldest);
+    }
+  };
+  const toDraft = (bucket, windowEndMs) => ({
+    count: bucket.suppressed,
+    windowStart: bucket.windowStart,
+    windowEndMs,
+    lastRelease: bucket.lastRelease,
+    lastEnvironment: bucket.lastEnvironment,
+    identity: bucket.identity,
+    captureRawFrames: bucket.captureRawFrames
+  });
+  const toSummary = (draft, identity) => ({
+    count: draft.count,
+    window_start: new Date(draft.windowStart).toISOString(),
+    window_end: new Date(draft.windowEndMs).toISOString(),
+    release: draft.lastRelease,
+    environment: draft.lastEnvironment,
+    ...identity
+  });
+  const flushSuppressed = (bucket, windowEndMs) => {
+    if (bucket.suppressed <= 0) return;
+    pushPending(toDraft(bucket, windowEndMs));
+    bucket.suppressed = 0;
+  };
+  const decide = (input) => {
+    const now = input.now ?? Date.now();
+    const identity = captureIdentity(input);
+    const captureRawFrames = (input.rawFrames ?? []).slice(0, MAX_STACK_FRAMES);
+    const burstKey = computeBurstKey(input.errorType, input.message, input.code, input.frames);
+    const release = input.release;
+    const route = input.route ?? null;
+    let bucket = burstBuckets.get(burstKey);
+    if (!bucket) {
+      bucket = {
+        sentInWindow: 1,
+        suppressed: 0,
+        windowStart: now,
+        lastRelease: release,
+        lastRoute: route,
+        lastEnvironment: input.environment,
+        identity,
+        captureRawFrames
+      };
+      burstBuckets.set(burstKey, bucket);
+      evictIfNeeded();
+      return { action: "send", priority: "first" };
+    }
+    touch(burstKey, bucket);
+    const dimensionChanged = !sameDim(release, bucket.lastRelease) || !sameDim(route, bucket.lastRoute) || bucket.lastEnvironment !== input.environment;
+    const windowExpired = now - bucket.windowStart >= windowMs;
+    if (dimensionChanged || windowExpired) {
+      flushSuppressed(bucket, now);
+      bucket.sentInWindow = 1;
+      bucket.windowStart = now;
+      bucket.lastRelease = release;
+      bucket.lastRoute = route;
+      bucket.lastEnvironment = input.environment;
+      bucket.identity = identity;
+      bucket.captureRawFrames = captureRawFrames;
+      return { action: "send", priority: "first" };
+    }
+    if (bucket.sentInWindow < capPerWindow) {
+      bucket.sentInWindow += 1;
+      bucket.lastRelease = release;
+      bucket.lastRoute = route;
+      bucket.lastEnvironment = input.environment;
+      return { action: "send", priority: "repeat" };
+    }
+    bucket.suppressed += 1;
+    return { action: "suppress" };
+  };
+  const drainSummaries = (now = Date.now()) => {
+    const drafts = pending.splice(0, pending.length);
+    for (const bucket of burstBuckets.values()) {
+      if (bucket.suppressed > 0) {
+        drafts.push(toDraft(bucket, now));
+        bucket.suppressed = 0;
+      }
+    }
+    return drafts.map((draft) => ({
+      summary: toSummary(draft, draft.identity),
+      rawFrames: draft.captureRawFrames
+    }));
+  };
+  const takeSummaries = async (now = Date.now(), prepareSummary) => {
+    const drafts = drainSummaries(now);
+    if (!prepareSummary) return drafts.map((draft) => draft.summary);
+    const out = [];
+    for (const draft of drafts) {
+      if (draft.rawFrames.length === 0) {
+        out.push(draft.summary);
+        continue;
+      }
+      try {
+        const resolved = await prepareSummary(draft.rawFrames);
+        out.push({ ...draft.summary, ...resolved });
+      } catch {
+        out.push(draft.summary);
+      }
+    }
+    return out;
+  };
+  return {
+    decide,
+    drainSummaries,
+    takeSummaries,
+    /** Test helper — number of active burst buckets. */
+    size: () => burstBuckets.size
+  };
+};
+
+// src/stack/fold-synthetic-frames.ts
+var RASPUTIN_SHELL_PREFIX = "__rasputinShell__";
+var RASPUTIN_HANDLE_RUN_PREFIX = "__rasputinHandleRun__";
+var frameFile = (frame) => (frame.file ?? frame.generated?.file ?? "").replaceAll("\\", "/");
+var functionName = (frame) => frame.function ?? "";
+var coreFunctionName = (name) => name.trim().replace(/^(async|new|get|set|bound)\s+/, "").replace(/^Object\./, "");
+var isRasputinShellFrame = (name) => typeof name === "string" && coreFunctionName(name).startsWith(RASPUTIN_SHELL_PREFIX);
+var isRasputinHandleRunFrame = (name) => typeof name === "string" && coreFunctionName(name).startsWith(RASPUTIN_HANDLE_RUN_PREFIX);
+var isEngineAsyncStoreFile = (file) => /^(node:|bun:)/i.test(file) && /async[_-]?hooks|async_local_storage|async_context_frame/i.test(file);
+var isInternalAsyncStoreFrame = (frame) => {
+  const name = functionName(frame);
+  const file = frameFile(frame);
+  if (name === "AsyncLocalStorage.run") return true;
+  if ((name === "run" || name === "Object.run") && isEngineAsyncStoreFile(file)) return true;
+  return false;
+};
+var isSyntheticRasputinFrame = (frame) => {
+  const name = functionName(frame);
+  if (isRasputinShellFrame(name) || isRasputinHandleRunFrame(name)) return true;
+  return isInternalAsyncStoreFrame(frame);
+};
+var foldSyntheticFrames = (frames) => {
+  const filtered = frames.filter((frame) => !isSyntheticRasputinFrame(frame));
+  if (filtered.length > 0) return filtered;
+  const withoutInternals = frames.filter((frame) => !isInternalAsyncStoreFrame(frame));
+  return withoutInternals.length > 0 ? withoutInternals : [...frames];
+};
+
+// src/stack/parse-stack.ts
+var V8 = /^\s*at (?<fn>.*?) ?\((?<loc>(?:file|https?|blob|native|eval|webpack|rsc|node|bun|data|<anonymous>|\/|[a-z]:\\|\\\\).*?)(?::(?<line>\d+))?(?::(?<col>\d+))?\)?\s*$/i;
+var V8_EVAL = /\((?<loc>\S+)(?::(?<line>\d+))(?::(?<col>\d+))\)/;
+var NODE = /^\s*at (?:(?<fn>(?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(?<loc>.+?):(?<line>\d+)(?::(?<col>\d+))?\)?\s*$/i;
+var JSC = /^\s*(?:(?<fn>[^@]*)(?:\(.*?\))?@)?(?<loc>\S.*?):(?<line>\d+)(?::(?<col>\d+))?\s*$/i;
+var convertToNumber = (value) => {
+  if (value === void 0 || value === "") return void 0;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : void 0;
+};
+var cleanFunctionName = (fn) => {
+  if (!fn) return void 0;
+  const trimmed = fn.trim();
+  if (!trimmed || trimmed === "<anonymous>" || trimmed === "<unknown>") return void 0;
+  return trimmed.startsWith("async ") ? trimmed.slice(6) || void 0 : trimmed;
+};
+var stripQueryAndHash = (file) => {
+  const query = file.indexOf("?");
+  const hash = file.indexOf("#");
+  let end = file.length;
+  if (query >= 0) end = query;
+  if (hash >= 0 && hash < end) end = hash;
+  return file.slice(0, end);
+};
+var cleanFilePath = (loc) => {
+  if (loc.startsWith("native")) return "native";
+  if (loc.startsWith("file:///")) {
+    const rest = loc.slice("file://".length);
+    const path = /^\/[A-Za-z]:/.test(rest) ? rest.slice(1) : rest;
+    return stripQueryAndHash(path);
+  }
+  if (loc.startsWith("file://")) return stripQueryAndHash(loc.slice("file://".length));
+  if (/^https?:\/\//i.test(loc)) {
+    try {
+      return decodeURIComponent(new URL(loc).pathname);
+    } catch {
+      return stripQueryAndHash(loc);
+    }
+  }
+  return stripQueryAndHash(loc);
+};
+var createFrame = (fn, loc, line, col) => ({
+  file: cleanFilePath(loc),
+  function: cleanFunctionName(fn),
+  line: convertToNumber(line),
+  column: convertToNumber(col)
+});
+var parseV8 = (line) => {
+  const g = V8.exec(line)?.groups;
+  if (!g?.loc) return null;
+  if (g.loc.startsWith("eval")) {
+    const inner = V8_EVAL.exec(g.loc)?.groups;
+    if (inner?.loc) return createFrame(g.fn, inner.loc, inner.line, inner.col);
+  }
+  return createFrame(g.fn, g.loc, g.line, g.col);
+};
+var parseNode = (line) => {
+  const g = NODE.exec(line)?.groups;
+  return g?.loc ? createFrame(g.fn, g.loc, g.line, g.col) : null;
+};
+var parseJsc = (line) => {
+  if (!line.includes("@")) return null;
+  const g = JSC.exec(line)?.groups;
+  return g?.loc ? createFrame(g.fn, g.loc, g.line, g.col) : null;
+};
+var parseStack = (stack) => {
+  const frames = [];
+  for (const line of stack.split(/\r?\n/)) {
+    const parsed = parseV8(line) ?? parseNode(line) ?? parseJsc(line);
+    if (parsed) frames.push(parsed);
+  }
+  return frames;
+};
+
+// src/browser-frames.ts
+var stackOf = (error) => {
+  if (error instanceof Error && typeof error.stack === "string") return error.stack;
+  return "";
+};
+var isAppFrame = (file) => {
+  if (!file) return false;
+  if (file === "native" || file === "<anonymous>") return false;
+  return !/node_modules|chrome-extension:|moz-extension:|safari-extension:|webkit-masked-url:|\/@rasputin-ai\/|rasputin-javascript-sdk\//i.test(
+    file
+  );
+};
+var framesFromError = (error) => {
+  const raw = foldSyntheticFrames(parseStack(stackOf(error)));
+  return raw.map((frame) => ({
+    generated: { file: frame.file, line: frame.line, column: frame.column },
+    ...frame.function ? { function: frame.function } : {},
+    in_app: isAppFrame(frame.file)
+  }));
+};
+
+// src/browser-ingest-event.ts
+var MAX_MESSAGE_BYTES2 = 8 * 1024;
+var MAX_STACK_FRAMES2 = 50;
+var utf8 = new TextEncoder();
+var truncateMessage = (value) => {
+  if (utf8.encode(value).byteLength <= MAX_MESSAGE_BYTES2) return value;
+  let end = Math.min(value.length, MAX_MESSAGE_BYTES2);
+  while (end > 0 && utf8.encode(value.slice(0, end)).byteLength > MAX_MESSAGE_BYTES2) end -= 1;
+  return value.slice(0, end);
+};
+var errorFields = (error) => {
+  if (error instanceof Error) {
+    const code = "code" in error && (typeof error.code === "string" || typeof error.code === "number") ? String(error.code) : void 0;
+    return {
+      type: error.name || "Error",
+      message: error.message || String(error),
+      ...code === void 0 ? {} : { code }
+    };
+  }
+  if (typeof error === "string") return { type: "string", message: error };
+  return { type: "Error", message: String(error) };
+};
+var createBrowserIngestEvent = (input) => {
+  const extracted = errorFields(input.error);
+  const event = {
+    type: extracted.type,
+    message: truncateMessage(extracted.message),
+    stack_frames: input.frames.slice(0, MAX_STACK_FRAMES2).flatMap((frame) => {
+      const filename = frame.generated.file.trim();
+      if (!filename) return [];
+      return [
+        {
+          filename,
+          ...frame.function ? { function: frame.function } : {},
+          ...frame.generated.line !== void 0 ? { lineno: frame.generated.line } : {},
+          ...frame.generated.column !== void 0 ? { colno: frame.generated.column } : {},
+          in_app: frame.in_app
+        }
+      ];
+    }),
+    occurred_at: (/* @__PURE__ */ new Date()).toISOString(),
+    environment: input.environment,
+    origin: "client",
+    resolution: "none",
+    release: input.release
+  };
+  if (extracted.code !== void 0) event.code = extracted.code;
+  if (input.runtimeState) event.runtime_state = input.runtimeState;
+  return event;
+};
+
+// src/captured-value.ts
+var MAX_BROWSER_STRING_LENGTH = 500;
+var MAX_ORDINARY_CAPTURE_DEPTH = 3;
+var MAX_ORDINARY_KEYS = 30;
+var MAX_ORDINARY_ARRAY_ELEMENTS = 20;
+var MAX_ORDINARY_NODES = 80;
+var MAX_ORDINARY_BYTES = 8 * 1024;
+var MAX_OWN_KEYS_ENUMERATION = 256;
+var REDACTED_SENTINEL = Symbol.for("rasputin.redacted.v1");
+var ownKeys = Reflect.ownKeys;
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var isArray = Array.isArray;
+var verifiedOrdinary = /* @__PURE__ */ new WeakSet();
+var wideOrdinary = /* @__PURE__ */ new WeakSet();
+var redactKey = (key) => key.length > 0 && propertyNameIsSensitive(key);
+var safeArrayFlag = (value) => {
+  try {
+    return isArray(value);
+  } catch {
+    return void 0;
+  }
+};
+var tagVerifiedOrdinary = (object) => {
+  if (object === null || typeof object !== "object") return object;
+  try {
+    verifiedOrdinary.add(object);
+  } catch {
+  }
+  return object;
+};
+var isVerifiedOrdinary = (object) => {
+  if (object === null || typeof object !== "object") return false;
+  try {
+    return verifiedOrdinary.has(object);
+  } catch {
+    return false;
+  }
+};
+var rememberKnownLiteral = (object, _keys, _values) => tagVerifiedOrdinary(object);
+var passthroughKnownLiteral = (object) => object;
+var tagDescriptorChild = (object, key, depth, nodes) => {
+  let descriptor;
+  try {
+    descriptor = getOwnPropertyDescriptor(object, key);
+  } catch {
+    return;
+  }
+  if (!descriptor || descriptor.get !== void 0 || descriptor.set !== void 0) return;
+  if ("value" in descriptor) tagJsonTree(descriptor.value, depth + 1, nodes);
+};
+var tagJsonTree = (value, depth, nodes) => {
+  if (value === null || typeof value !== "object") return;
+  if (depth > MAX_ORDINARY_CAPTURE_DEPTH || nodes.count >= MAX_ORDINARY_NODES) return;
+  if (isVerifiedOrdinary(value)) return;
+  tagVerifiedOrdinary(value);
+  nodes.count += 1;
+  if (safeArrayFlag(value) === true) {
+    let length = 0;
+    try {
+      const lengthDescriptor = getOwnPropertyDescriptor(value, "length");
+      if (lengthDescriptor && typeof lengthDescriptor.value === "number") {
+        length = lengthDescriptor.value;
+      }
+    } catch {
+      return;
+    }
+    const limit2 = Math.min(Math.max(0, length), MAX_ORDINARY_ARRAY_ELEMENTS);
+    for (let index = 0; index < limit2; index += 1) {
+      tagDescriptorChild(value, String(index), depth, nodes);
+    }
+    return;
+  }
+  let keys;
+  try {
+    keys = ownKeys(value);
+  } catch {
+    return;
+  }
+  if (keys.length > MAX_OWN_KEYS_ENUMERATION) {
+    wideOrdinary.add(value);
+    return;
+  }
+  const limit = Math.min(keys.length, MAX_ORDINARY_KEYS);
+  for (let index = 0; index < limit; index += 1) {
+    const key = keys[index];
+    if (key === void 0 || typeof key === "symbol") continue;
+    tagDescriptorChild(value, key, depth, nodes);
+  }
+};
+var tagJsonParseResult = (value) => {
+  tagJsonTree(value, 0, { count: 0 });
+  return value;
+};
+var addBytes = (budget, amount) => {
+  budget.bytes += amount;
+};
+var budgetOverflowReason = (budget) => budget.bytes >= MAX_ORDINARY_BYTES ? "max_bytes" : "max_nodes";
+var captureValueAt = (value, depth, path, seen, budget) => {
+  try {
+    if (value === REDACTED_SENTINEL) return { kind: "redacted" };
+    if (value === null) return { kind: "null" };
+    if (typeof value === "undefined") return { kind: "undefined" };
+    if (typeof value === "string") {
+      if (value.length > MAX_BROWSER_STRING_LENGTH) {
+        addBytes(budget, 24 + MAX_BROWSER_STRING_LENGTH);
+        return {
+          kind: "primitive",
+          value: value.slice(0, MAX_BROWSER_STRING_LENGTH),
+          originalLength: value.length,
+          truncated: true,
+          reason: "max_string_length"
+        };
+      }
+      addBytes(budget, 24 + value.length);
+      return { kind: "primitive", value };
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      addBytes(budget, 32);
+      return { kind: "primitive", value };
+    }
+    if (typeof value === "bigint") {
+      const text = value.toString();
+      addBytes(budget, 24 + text.length);
+      return { kind: "bigint", value: text };
+    }
+    if (typeof value === "symbol") return { kind: "opaque", jsType: "symbol" };
+    if (typeof value === "function") return { kind: "opaque", jsType: "function" };
+    if (typeof value !== "object") return { kind: "opaque", jsType: typeof value };
+    if (path.has(value)) return { kind: "circular" };
+    if (seen.has(value)) return { kind: "shared" };
+    if (verifiedOrdinary.has(value)) {
+      if (wideOrdinary.has(value)) {
+        return { kind: "struct", entries: [], truncated: true, reason: "wide_object" };
+      }
+      return walkOrdinary(value, depth, path, seen, budget);
+    }
+    const array = safeArrayFlag(value);
+    addBytes(budget, 32);
+    return array === void 0 ? { kind: "opaque", jsType: "object" } : { kind: "opaque", jsType: "object", array };
+  } catch {
+    return { kind: "opaque", jsType: "object" };
+  }
+};
+var walkOrdinary = (value, depth, path, seen, budget) => {
+  if (budget.nodes >= MAX_ORDINARY_NODES) {
+    return { kind: "struct", entries: [], truncated: true, reason: "max_nodes" };
+  }
+  if (budget.bytes >= MAX_ORDINARY_BYTES) {
+    return { kind: "struct", entries: [], truncated: true, reason: "max_bytes" };
+  }
+  if (depth >= MAX_ORDINARY_CAPTURE_DEPTH) {
+    return { kind: "struct", entries: [], truncated: true, reason: "max_depth" };
+  }
+  path.add(value);
+  seen.add(value);
+  budget.nodes += 1;
+  addBytes(budget, 24);
+  const array = safeArrayFlag(value) === true;
+  if (array) {
+    const captured = walkOrdinaryArray(value, depth, path, seen, budget);
+    path.delete(value);
+    return captured;
+  }
+  let keys;
+  try {
+    keys = ownKeys(value);
+  } catch {
+    path.delete(value);
+    return { kind: "opaque", jsType: "object" };
+  }
+  if (keys.length > MAX_OWN_KEYS_ENUMERATION) {
+    path.delete(value);
+    return { kind: "struct", entries: [], truncated: true, reason: "wide_object" };
+  }
+  const overKeyCap = keys.length > MAX_ORDINARY_KEYS;
+  const limit = Math.min(keys.length, MAX_ORDINARY_KEYS);
+  const entries = [];
+  let skippedSymbols = false;
+  for (let index = 0; index < limit; index += 1) {
+    if (budget.nodes >= MAX_ORDINARY_NODES || budget.bytes >= MAX_ORDINARY_BYTES) {
+      path.delete(value);
+      return { kind: "struct", entries, truncated: true, reason: budgetOverflowReason(budget) };
+    }
+    const key = keys[index];
+    if (key === void 0) continue;
+    if (typeof key === "symbol") {
+      skippedSymbols = true;
+      continue;
+    }
+    const text = String(key);
+    addBytes(budget, 8 + text.length);
+    if (redactKey(text)) {
+      entries.push({ key: text, value: { kind: "redacted" } });
+      continue;
+    }
+    entries.push({
+      key: text,
+      value: captureDescriptorValue(value, key, depth, path, seen, budget)
+    });
+  }
+  if (!skippedSymbols) {
+    for (let index = limit; index < keys.length; index += 1) {
+      if (typeof keys[index] === "symbol") {
+        skippedSymbols = true;
+        break;
+      }
+    }
+  }
+  path.delete(value);
+  const truncated = overKeyCap || skippedSymbols;
+  const reason = overKeyCap ? "max_keys" : "omitted_symbols";
+  return {
+    kind: "struct",
+    entries,
+    ...truncated ? { truncated: true, reason } : {}
+  };
+};
+var walkOrdinaryArray = (value, depth, path, seen, budget) => {
+  let length = 0;
+  try {
+    const lengthDescriptor = getOwnPropertyDescriptor(value, "length");
+    if (lengthDescriptor && typeof lengthDescriptor.value === "number") {
+      length = lengthDescriptor.value;
+    }
+  } catch {
+    return { kind: "opaque", jsType: "object", array: true };
+  }
+  const truncatedByLength = length > MAX_ORDINARY_ARRAY_ELEMENTS;
+  const limit = Math.min(Math.max(0, length), MAX_ORDINARY_ARRAY_ELEMENTS);
+  const entries = [];
+  for (let index = 0; index < limit; index += 1) {
+    if (budget.nodes >= MAX_ORDINARY_NODES || budget.bytes >= MAX_ORDINARY_BYTES) {
+      return {
+        kind: "struct",
+        array: true,
+        entries,
+        truncated: true,
+        reason: budgetOverflowReason(budget)
+      };
+    }
+    const key = String(index);
+    addBytes(budget, 8 + key.length);
+    entries.push({
+      key,
+      value: captureDescriptorValue(value, key, depth, path, seen, budget, "hole")
+    });
+  }
+  let omittedExtraKeys = false;
+  if (!truncatedByLength && length <= MAX_ORDINARY_ARRAY_ELEMENTS) {
+    try {
+      const keys = ownKeys(value);
+      for (const key of keys) {
+        if (key === "length") continue;
+        if (typeof key === "symbol") {
+          omittedExtraKeys = true;
+          break;
+        }
+        if (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= length) {
+          omittedExtraKeys = true;
+          break;
+        }
+      }
+    } catch {
+      omittedExtraKeys = true;
+    }
+  }
+  const truncated = truncatedByLength || omittedExtraKeys;
+  const reason = truncatedByLength ? "max_keys" : "omitted_extra_keys";
+  return {
+    kind: "struct",
+    array: true,
+    entries,
+    ...truncated ? { truncated: true, reason } : {}
+  };
+};
+var captureDescriptorValue = (object, key, depth, path, seen, budget, absent = "undefined") => {
+  let descriptor;
+  try {
+    descriptor = getOwnPropertyDescriptor(object, key);
+  } catch {
+    return { kind: "opaque", jsType: "object" };
+  }
+  if (!descriptor) return { kind: absent };
+  if (descriptor.get !== void 0 || descriptor.set !== void 0) return { kind: "accessor" };
+  if (!("value" in descriptor)) return { kind: absent };
+  return captureValueAt(descriptor.value, depth + 1, path, seen, budget);
+};
+var captureValue = (value) => captureValueAt(value, 0, /* @__PURE__ */ new WeakSet(), /* @__PURE__ */ new WeakSet(), { nodes: 0, bytes: 0 });
+var estimateCapturedBytes = (value) => {
+  if (value.kind === "primitive" && typeof value.value === "string") {
+    return 24 + value.value.length;
+  }
+  if (value.kind === "bigint") return 24 + value.value.length;
+  if (value.kind === "struct") {
+    return 24 + value.entries.reduce(
+      (sum, entry) => sum + 8 + entry.key.length + estimateCapturedBytes(entry.value),
+      0
+    );
+  }
+  return 32;
+};
+
+// src/native-json-producer.ts
+var nativeResponseJson = (() => {
+  const response = Reflect.get(globalThis, "Response");
+  if (typeof response !== "function") return void 0;
+  const proto = Reflect.get(response, "prototype");
+  if (!proto || typeof proto !== "object") return void 0;
+  const json = Reflect.get(proto, "json");
+  return typeof json === "function" ? json : void 0;
+})();
+var nativeJsonParse = (() => {
+  const json = Reflect.get(globalThis, "JSON");
+  if (!json || typeof json !== "object") return void 0;
+  const parse = Reflect.get(json, "parse");
+  return typeof parse === "function" ? parse : void 0;
+})();
+var nativeJsonPromises = /* @__PURE__ */ new WeakSet();
+var notedDependents = /* @__PURE__ */ new WeakMap();
+var adoptStack = [];
+var jsonProducerStats = {
+  method: 0,
+  await: 0,
+  adopt: 0,
+  handle: 0
+};
+var applyCall = (fn, receiver, args) => {
+  if (typeof fn === "function") return Reflect.apply(fn, receiver, args);
+  return Reflect.apply(fn, receiver, args);
+};
+var isObject = (value) => value !== null && typeof value === "object";
+var isFn = (value) => typeof value === "function";
+var pruneAdoptedFrames = () => {
+  while (adoptStack.length > 0) {
+    const top = adoptStack[adoptStack.length - 1];
+    if (!top?.adopted) break;
+    adoptStack.pop();
+  }
+};
+var noteNativeJsonPromise = (value) => {
+  if (!isObject(value)) return;
+  try {
+    if (nativeJsonPromises.has(value)) return;
+    nativeJsonPromises.add(value);
+  } catch {
+    return;
+  }
+  const dependents = notedDependents.get(value);
+  if (!dependents) return;
+  notedDependents.delete(value);
+  for (const dependent of dependents) noteNativeJsonPromise(dependent);
+};
+var linkNotedPromise = (from, to) => {
+  if (from === to) return;
+  if (isNotedNativeJsonPromise(from)) {
+    noteNativeJsonPromise(to);
+    return;
+  }
+  const existing = notedDependents.get(from);
+  if (existing) existing.push(to);
+  else notedDependents.set(from, [to]);
+};
+var isNotedNativeJsonPromise = (value) => {
+  if (!isObject(value)) return false;
+  try {
+    return nativeJsonPromises.has(value);
+  } catch {
+    return false;
+  }
+};
+var hasCallableReviver = (args) => args.some((argument) => typeof argument === "function");
+var finishNativeCall = (fn, result, args) => {
+  if (fn === nativeResponseJson) {
+    noteNativeJsonPromise(result);
+    return result;
+  }
+  if (fn === nativeJsonParse && !hasCallableReviver(args)) {
+    tagJsonParseResult(result);
+  }
+  return result;
+};
+var invokeNativeJsonMethod = (receiver, fn, ...args) => {
+  jsonProducerStats.method += 1;
+  const result = applyCall(fn, receiver, args);
+  return finishNativeCall(fn, result, args);
+};
+var tagJsonAwaitResult = (value, promise) => {
+  jsonProducerStats.await += 1;
+  if (isNotedNativeJsonPromise(promise)) tagJsonParseResult(value);
+  return value;
+};
+var emptyFrame = () => ({
+  fn: void 0,
+  yielded: false,
+  exited: false,
+  adopted: true,
+  bound: false,
+  left: void 0,
+  asyncPromise: void 0
+});
+var discardUnboundFramesFor = (fn) => {
+  for (const frame of adoptStack) {
+    if (frame.fn !== fn || frame.bound || frame.adopted || !frame.exited) continue;
+    frame.adopted = true;
+  }
+  pruneAdoptedFrames();
+};
+var createJsonAdoptFrame = (fn) => {
+  if (!fn) return emptyFrame();
+  discardUnboundFramesFor(fn);
+  const frame = {
+    fn,
+    yielded: false,
+    exited: false,
+    adopted: false,
+    bound: false,
+    left: void 0,
+    asyncPromise: void 0
+  };
+  adoptStack.push(frame);
+  return frame;
+};
+var bindFrame = (frame, value) => {
+  frame.asyncPromise = value;
+  frame.bound = true;
+  if (frame.left && frame.left !== value) linkNotedPromise(frame.left, value);
+  if (isNotedNativeJsonPromise(frame.left) || isNotedNativeJsonPromise(value)) {
+    noteNativeJsonPromise(value);
+  }
+  frame.adopted = true;
+  pruneAdoptedFrames();
+};
+var bindByCallee = (value, callee) => {
+  for (let index = adoptStack.length - 1; index >= 0; index -= 1) {
+    const frame = adoptStack[index];
+    if (!frame || frame.adopted || frame.bound) continue;
+    if (frame.fn !== callee) continue;
+    bindFrame(frame, value);
+    return true;
+  }
+  return false;
+};
+var notifyJsonProducerLeave = (frame, value) => {
+  frame.exited = true;
+  if (isObject(value)) frame.left = value;
+  if (isObject(value) && frame.asyncPromise && value !== frame.asyncPromise) {
+    linkNotedPromise(value, frame.asyncPromise);
+  }
+  if (isNotedNativeJsonPromise(value) && frame.asyncPromise) {
+    noteNativeJsonPromise(frame.asyncPromise);
+  }
+  return value;
+};
+var notifyJsonProducerSuspend = (frame) => {
+  frame.yielded = true;
+};
+var notifyJsonProducerEnd = (frame) => {
+  frame.exited = true;
+  if (frame.bound || frame.left === void 0 || !frame.fn) frame.adopted = true;
+  pruneAdoptedFrames();
+};
+var adoptAsyncJsonPromise = (value, callee) => {
+  jsonProducerStats.adopt += 1;
+  if (!isObject(value) || !isFn(callee)) return value;
+  bindByCallee(value, callee);
+  return value;
+};
+var resetJsonProducerAdopt = () => {
+  adoptStack.length = 0;
+  jsonProducerStats.method = 0;
+  jsonProducerStats.await = 0;
+  jsonProducerStats.adopt = 0;
+  jsonProducerStats.handle = 0;
+};
+var passthroughAdopt = (value) => value;
+var createProvenanceHandle = (fn) => {
+  jsonProducerStats.handle += 1;
+  const frame = createJsonAdoptFrame(isFn(fn) ? fn : void 0);
+  return {
+    leave: (value) => notifyJsonProducerLeave(frame, value),
+    end: () => {
+      notifyJsonProducerEnd(frame);
+    },
+    suspend: (value) => {
+      notifyJsonProducerSuspend(frame);
+      return value;
+    },
+    resume: (value) => value
+  };
+};
+var passthroughProvenanceHandle = (_fn) => ({
+  leave: (value) => value,
+  end: () => {
+  },
+  suspend: (value) => value,
+  resume: (value) => value
+});
+var passthroughNativeJsonMethod = (receiver, fn, ...args) => applyCall(fn, receiver, args);
+var passthroughJsonAwait = (value, _promise) => value;
+
+// src/browser-recorder.ts
+var THROW_TIME_NOTE = "throw-time ancestor materialized";
+var DISCRETE_EVENTS = /* @__PURE__ */ new Set([
+  "click",
+  "submit",
+  "pointerdown",
+  "pointerup",
+  "keydown",
+  "keyup",
+  "input",
+  "change"
+]);
+var VALUES_OFF_AFTER = 64;
+var HELPERS_SPARSE_AFTER = 160;
+var STRUCTURAL_NOTE = "structural events truncated";
+var VALUE_NOTE = "value observations omitted";
+var REPEAT_NOTE = "repeated calls suppressed";
+var OPEN_CAP_NOTE = "maximum open executions reached";
+var HOLD_NOTE = "closed by hold budget";
+var VALUES_OFF_NOTE = "capture profile: values-off";
+var HELPERS_SPARSE_NOTE = "capture profile: helpers-sparse";
+var nowMs = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+var eventTypeOf = (event) => {
+  if (!("type" in event)) return "";
+  const type = Reflect.get(event, "type");
+  return typeof type === "string" ? type : "";
+};
+var isDiscreteEvent = (event) => DISCRETE_EVENTS.has(eventTypeOf(event));
+var windowEvent = () => {
+  const root = globalThis;
+  const event = root.window?.event;
+  return event && typeof event === "object" ? event : void 0;
+};
+var summarize = (execution) => ({
+  executionId: execution.id,
+  kind: execution.kind,
+  ...execution.eventType ? { eventType: execution.eventType } : {},
+  functionNames: [...execution.functions.values()].map((definition) => definition.name),
+  durationMs: execution.lastActivityAt - execution.startedAt,
+  hadError: execution.hasError
+});
+var snapshotCaptureMode = (execution, configured) => execution.captureProfile === "normal" ? configured : "structure";
+var snapshotOf = (execution, captureMode) => ({
+  executionId: execution.id,
+  kind: execution.kind,
+  ...execution.eventType ? { eventType: execution.eventType } : {},
+  startedAt: execution.startedAt,
+  startedAtIso: new Date(execution.startedAtWallMs).toISOString(),
+  durationMs: execution.lastActivityAt - execution.startedAt,
+  provenanceNotes: [...execution.provenanceNotes],
+  functions: [...execution.functions.values()],
+  events: [...execution.events],
+  captureMode: snapshotCaptureMode(execution, captureMode),
+  writes: [...execution.writes],
+  reads: [...execution.reads],
+  historyLinks: [],
+  ...execution.partial ? { partial: true } : {},
+  captureProfile: execution.captureProfile
+});
+var emptyCosts = () => ({
+  enterMs: 0,
+  leaveEndMs: 0,
+  journalMs: 0,
+  resolveMs: 0,
+  handleAllocMs: 0,
+  structureMs: 0,
+  suppressMs: 0,
+  observeMs: 0,
+  captureMs: 0,
+  historyMs: 0,
+  statsMs: 0,
+  entersFull: 0,
+  entersStructure: 0,
+  entersSkip: 0,
+  entersSparse: 0,
+  observeCalls: 0,
+  reactiveHitMs: 0,
+  reactiveRepeats: 0
+});
+var emptyStats = () => ({
+  functionCallsObserved: 0,
+  functionCallsCaptured: 0,
+  successfulExecutionsDiscarded: 0,
+  errorSnapshots: 0,
+  activeExecutions: 0,
+  peakActiveExecutions: 0,
+  activeEstimatedBytes: 0,
+  peakActiveEstimatedBytes: 0,
+  attributionInferred: 0,
+  attributionInferredAmbiguous: 0,
+  attributionUnlinked: 0,
+  truncatedEvents: 0,
+  truncatedStructural: 0,
+  omittedValueObservations: 0,
+  expressionObservations: 0,
+  repeatedCallsSuppressed: 0,
+  executionsDroppedUnderPressure: 0,
+  reactiveCallbackInvocations: 0,
+  reactiveRecordedEntries: 0,
+  reactiveSparseCounted: 0,
+  reactiveThrows: 0
+});
+var addCost = (costs, key, started) => {
+  const current = costs[key];
+  if (typeof current === "number") {
+    costs[key] = current + (nowMs() - started);
+  }
+};
+var maxRepeatsFor = (captureClass, profile, fullCap) => {
+  if (captureClass === "skip") return 0;
+  if (captureClass === "structure" || captureClass === "reactive-sparse" || profile === "helpers-sparse") {
+    return 1;
+  }
+  return fullCap;
+};
+var createBrowserRecorder = (options = {}) => {
+  const config = {
+    settlingMs: options.settlingMs ?? 80,
+    holdMs: options.holdMs ?? 3e4,
+    captureMode: options.captureMode ?? "values",
+    maxStructuralEvents: options.maxStructuralEvents ?? 240,
+    maxValueEvents: options.maxValueEvents ?? 80,
+    maxCapturedCallsPerFunction: options.maxCapturedCallsPerFunction ?? 3,
+    maxRecentExecutions: options.maxRecentExecutions ?? 20,
+    maxRetainedSnapshots: options.maxRetainedSnapshots ?? 32,
+    maxHistory: options.maxHistory ?? 16,
+    maxOpenExecutions: options.maxOpenExecutions ?? 32,
+    profileCosts: options.profileCosts === true
+  };
+  const costs = emptyCosts();
+  const identities = /* @__PURE__ */ new Map();
+  const identitiesBySite = /* @__PURE__ */ new Map();
+  const registeredReactiveSites = /* @__PURE__ */ new Map();
+  const internedIds = /* @__PURE__ */ new Map();
+  let nextIntern = 1;
+  let current = null;
+  let nextCallId = 1;
+  let nextExecution = 1;
+  const open = /* @__PURE__ */ new Set();
+  const recent = [];
+  const snapshots = [];
+  const history = [];
+  const errors = /* @__PURE__ */ new WeakMap();
+  const eventRoots = /* @__PURE__ */ new WeakMap();
+  const stats = emptyStats();
+  const reactiveHandles = [];
+  const reactiveSampled = [];
+  const reactiveInvocations = [];
+  const reactiveOwned = [];
+  const emptyArgs = [];
+  const passthrough = isolateHandle({
+    leave: (value) => value,
+    fail: () => {
+    },
+    end: () => {
+    },
+    run: (callback) => callback(),
+    suspend: (value) => value,
+    resume: (value) => value
+  });
+  const identityFromIndex = (moduleIndex, planIndex, captureClass, plan) => {
+    const compactId = `${moduleIndex}.${planIndex}`;
+    const cached = identities.get(compactId) ?? (plan ? identities.get(plan[0]) : void 0);
+    if (cached) {
+      if (plan) {
+        if (!cached.packageRelativePath && plan[3]) cached.packageRelativePath = plan[3];
+        if (cached.line == null && plan[4] != null) cached.line = plan[4];
+        if (cached.column == null && plan[5] != null) cached.column = plan[5];
+        if (!cached.name || cached.name === compactId) cached.name = plan[1];
+        if (cached.packageName == null && plan[2]) cached.packageName = plan[2];
+      }
+      identities.set(compactId, cached);
+      if (plan) identities.set(plan[0], cached);
+      return cached;
+    }
+    const resolvedClass = plan?.[9] === 1 ? "reactive-sparse" : plan?.[8] === 1 ? "skip" : plan?.[6] === 1 ? "structure" : captureClass;
+    const identity = plan ? {
+      functionId: compactId,
+      name: plan[1],
+      packageName: plan[2],
+      packageRelativePath: plan[3],
+      line: plan[4],
+      column: plan[5],
+      captureClass: resolvedClass,
+      moduleIndex,
+      planIndex
+    } : {
+      functionId: compactId,
+      name: compactId,
+      packageName: null,
+      packageRelativePath: null,
+      line: null,
+      column: null,
+      captureClass: resolvedClass,
+      moduleIndex,
+      planIndex
+    };
+    identities.set(compactId, identity);
+    identities.set(identity.functionId, identity);
+    return identity;
+  };
+  const registerIdentities = (items) => {
+    for (const item of items) {
+      const identity = {
+        functionId: item.functionId,
+        name: item.name,
+        packageName: null,
+        packageRelativePath: item.packageRelativePath ?? null,
+        line: item.line,
+        column: item.column,
+        captureClass: item.captureClass,
+        moduleIndex: item.moduleIndex,
+        planIndex: item.planIndex
+      };
+      identities.set(item.compactId, identity);
+      identities.set(item.functionId, identity);
+      if (item.siteId !== void 0) {
+        identitiesBySite.set(item.siteId, identity);
+        rememberReactiveSite(item.siteId, identity);
+      }
+    }
+  };
+  const addBytes2 = (execution, delta) => {
+    execution.estimatedBytes += delta;
+    stats.activeEstimatedBytes += delta;
+    if (stats.activeEstimatedBytes > stats.peakActiveEstimatedBytes) {
+      stats.peakActiveEstimatedBytes = stats.activeEstimatedBytes;
+    }
+  };
+  const noteOnce = (execution, note) => {
+    if (execution.provenanceNotes.includes(note)) return;
+    execution.provenanceNotes.push(note);
+    execution.partial = true;
+  };
+  const updateProfile = (execution) => {
+    if (execution.enterCount >= HELPERS_SPARSE_AFTER) {
+      if (execution.captureProfile !== "helpers-sparse") {
+        execution.captureProfile = "helpers-sparse";
+        noteOnce(execution, HELPERS_SPARSE_NOTE);
+      }
+      return;
+    }
+    if (execution.valueCount >= VALUES_OFF_AFTER && execution.captureProfile === "normal") {
+      execution.captureProfile = "values-off";
+      noteOnce(execution, VALUES_OFF_NOTE);
+    }
+  };
+  const internId = (functionId) => {
+    const existing = internedIds.get(functionId);
+    if (existing !== void 0) return existing;
+    const assigned = nextIntern;
+    nextIntern += 1;
+    internedIds.set(functionId, assigned);
+    return assigned;
+  };
+  const repeatKey = (functionId, parentFunctionId) => internId(functionId) << 16 | (parentFunctionId ? internId(parentFunctionId) : 0);
+  const recordingOpen = (execution) => execution.phase !== "closed";
+  const activeCarrier = () => current && !current.ended && recordingOpen(current.execution) ? current : null;
+  const valuesAllowed = (execution) => config.captureMode === "values" && execution.captureProfile === "normal";
+  const frontierAllowsValues = (execution) => {
+    if (config.captureMode !== "values") return false;
+    if (current?.identity.captureClass === "reactive-sparse") {
+      return execution.captureProfile === "normal";
+    }
+    if (execution.captureProfile === "normal") return true;
+    return !!current && current.recordedEnter && current.identity.captureClass === "full";
+  };
+  const appendEvent = (execution, event, extraBytes) => {
+    if (!recordingOpen(execution)) return;
+    execution.lastActivityAt = event.timestampMs;
+    execution.events.push(event);
+    addBytes2(execution, 96 + extraBytes);
+  };
+  const liveCallIds = (execution) => {
+    const ids = /* @__PURE__ */ new Set();
+    let cursor = current;
+    while (cursor) {
+      if (cursor.execution === execution && !cursor.ended) ids.add(cursor.callId);
+      cursor = cursor.previous;
+    }
+    return ids;
+  };
+  const evictCompletedLeaf = (execution) => {
+    const live = liveCallIds(execution);
+    const parentIds = /* @__PURE__ */ new Set();
+    const exitByCall = /* @__PURE__ */ new Map();
+    const throwIds = /* @__PURE__ */ new Set();
+    for (let index = 0; index < execution.events.length; index += 1) {
+      const event = execution.events[index];
+      if (!event) continue;
+      if (event.type === "function_enter" && event.parentCallId !== void 0) {
+        parentIds.add(event.parentCallId);
+      } else if (event.type === "function_calls_suppressed" && event.parentCallId !== void 0) {
+        parentIds.add(event.parentCallId);
+      } else if (event.type === "function_exit") {
+        exitByCall.set(event.callId, index);
+      } else if (event.type === "function_throw") {
+        throwIds.add(event.callId);
+      }
+    }
+    for (let index = 0; index < execution.events.length; index += 1) {
+      const event = execution.events[index];
+      if (event?.type !== "function_enter") continue;
+      if (live.has(event.callId) || parentIds.has(event.callId) || throwIds.has(event.callId)) {
+        continue;
+      }
+      const terminal = exitByCall.get(event.callId);
+      if (terminal === void 0) continue;
+      const later = Math.max(index, terminal);
+      const earlier = Math.min(index, terminal);
+      execution.events.splice(later, 1);
+      execution.events.splice(earlier, 1);
+      execution.structuralCount = Math.max(0, execution.structuralCount - 2);
+      stats.truncatedEvents += 1;
+      stats.truncatedStructural += 1;
+      noteOnce(execution, STRUCTURAL_NOTE);
+      return true;
+    }
+    return false;
+  };
+  const pushStructural = (execution, event, extraBytes) => {
+    const journalStarted = config.profileCosts ? nowMs() : 0;
+    if (!recordingOpen(execution)) {
+      if (config.profileCosts) addCost(costs, "journalMs", journalStarted);
+      return;
+    }
+    if (event.type === "function_throw") {
+      while (execution.structuralCount >= config.maxStructuralEvents) {
+        if (!evictCompletedLeaf(execution)) break;
+      }
+      execution.structuralCount += 1;
+      appendEvent(execution, event, extraBytes);
+      if (config.profileCosts) addCost(costs, "journalMs", journalStarted);
+      return;
+    }
+    if (execution.structuralCount >= config.maxStructuralEvents) {
+      if (!evictCompletedLeaf(execution) || execution.structuralCount >= config.maxStructuralEvents) {
+        stats.truncatedEvents += 1;
+        stats.truncatedStructural += 1;
+        noteOnce(execution, STRUCTURAL_NOTE);
+        if (config.profileCosts) addCost(costs, "journalMs", journalStarted);
+        return;
+      }
+    }
+    execution.structuralCount += 1;
+    appendEvent(execution, event, extraBytes);
+    if (config.profileCosts) addCost(costs, "journalMs", journalStarted);
+  };
+  const hasValueBudget = (execution) => {
+    if (execution.valueCount < config.maxValueEvents) return true;
+    stats.omittedValueObservations += 1;
+    noteOnce(execution, VALUE_NOTE);
+    return false;
+  };
+  const consumeValue = (execution) => {
+    execution.valueCount += 1;
+  };
+  const captureArgs = (args) => {
+    try {
+      const captureStarted = config.profileCosts ? nowMs() : 0;
+      const captured = [];
+      for (let index = 0; index < args.length; index += 1) {
+        captured.push(captureValue(args[index]));
+      }
+      if (config.profileCosts) addCost(costs, "captureMs", captureStarted);
+      return captured;
+    } catch {
+      return void 0;
+    }
+  };
+  const linkHistory = (execution) => {
+    const historyStarted = config.profileCosts ? nowMs() : 0;
+    const links = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const read of execution.reads) {
+      let last;
+      for (const record of history) {
+        if (record.executionId === execution.id) continue;
+        if (record.writes.some((write) => write.key === read.key)) last = record;
+      }
+      if (!last) continue;
+      seen.add(last.executionId);
+      links.push({
+        executionId: last.executionId,
+        relationship: "last-observed-write",
+        key: read.key
+      });
+      for (const record of history) {
+        if (record.executionId === last.executionId || record.executionId === execution.id) {
+          continue;
+        }
+        if (!record.writes.some((write) => write.key === read.key)) continue;
+        if (seen.has(`${record.executionId}:${read.key}`)) continue;
+        seen.add(`${record.executionId}:${read.key}`);
+        links.push({
+          executionId: record.executionId,
+          relationship: "observed-write",
+          key: read.key
+        });
+      }
+    }
+    if (links.length === 0 && history.length > 0) {
+      const prior = history[history.length - 1];
+      if (prior && prior.executionId !== execution.id) {
+        links.push({ executionId: prior.executionId, relationship: "inferred" });
+      }
+    }
+    if (config.profileCosts) addCost(costs, "historyMs", historyStarted);
+    return links;
+  };
+  const closeExecution = (execution) => {
+    if (execution.phase === "closed") return;
+    execution.phase = "closed";
+    if (execution.settlingTimer !== void 0) clearTimeout(execution.settlingTimer);
+    if (execution.holdTimer !== void 0) clearTimeout(execution.holdTimer);
+    execution.settlingTimer = void 0;
+    execution.holdTimer = void 0;
+    open.delete(execution);
+    stats.activeEstimatedBytes = Math.max(0, stats.activeEstimatedBytes - execution.estimatedBytes);
+    stats.activeExecutions = open.size;
+    execution.lastActivityAt = nowMs();
+    const summary = summarize(execution);
+    recent.push(summary);
+    if (recent.length > config.maxRecentExecutions) recent.shift();
+    if (execution.hasError) {
+      const snapshot = snapshotOf(execution, config.captureMode);
+      snapshot.historyLinks = linkHistory(execution);
+      snapshots.push(snapshot);
+      if (snapshots.length > config.maxRetainedSnapshots) snapshots.shift();
+      stats.errorSnapshots += 1;
+    } else {
+      const forcedClose = execution.provenanceNotes.includes(HOLD_NOTE) || execution.provenanceNotes.includes(OPEN_CAP_NOTE);
+      if (!forcedClose) {
+        history.push({
+          executionId: execution.id,
+          kind: execution.kind,
+          ...execution.eventType ? { eventType: execution.eventType } : {},
+          startedAt: execution.startedAt,
+          durationMs: execution.lastActivityAt - execution.startedAt,
+          functionNames: [...execution.functions.values()].map((definition) => definition.name),
+          writes: [...execution.writes]
+        });
+        if (history.length > config.maxHistory) history.shift();
+        stats.successfulExecutionsDiscarded += 1;
+      }
+      execution.events.length = 0;
+      execution.functions.clear();
+      execution.suppressionByContext.clear();
+      execution.estimatedBytes = 0;
+    }
+  };
+  const scheduleClose = (execution) => {
+    if (execution.phase !== "open" || execution.inFlight > 0) return;
+    execution.phase = "settling";
+    execution.settlingTimer = setTimeout(() => {
+      execution.settlingTimer = void 0;
+      if (execution.inFlight > 0) {
+        execution.phase = "open";
+        return;
+      }
+      closeExecution(execution);
+    }, config.settlingMs);
+  };
+  const reopenIfSettling = (execution) => {
+    if (execution.phase === "closed") return;
+    if (execution.settlingTimer !== void 0) clearTimeout(execution.settlingTimer);
+    execution.settlingTimer = void 0;
+    if (execution.phase === "settling") execution.phase = "open";
+  };
+  const openEvictionScore = (execution) => {
+    const errorBias = execution.hasError ? 1e3 : 0;
+    const kindBias = execution.kind === "interaction" ? 100 : 0;
+    const flight = execution.inFlight > 0 ? 20 + execution.inFlight : 0;
+    const settling = execution.phase === "settling" ? 0 : 10;
+    return errorBias + kindBias + flight + settling;
+  };
+  const closeLowestValueOpen = () => {
+    const carrier = activeCarrier()?.execution;
+    let victim;
+    let best = Number.POSITIVE_INFINITY;
+    for (const execution of open) {
+      if (execution === carrier || execution.phase === "closed") continue;
+      const score = openEvictionScore(execution);
+      if (score < best || score === best && victim !== void 0 && execution.startedAt < victim.startedAt) {
+        best = score;
+        victim = execution;
+      }
+    }
+    if (!victim) return false;
+    noteOnce(victim, OPEN_CAP_NOTE);
+    stats.executionsDroppedUnderPressure += 1;
+    closeExecution(victim);
+    return true;
+  };
+  const ensureOpenCapacity = () => {
+    while (open.size >= config.maxOpenExecutions) {
+      if (!closeLowestValueOpen()) break;
+    }
+  };
+  const createExecution = (kind, eventType) => {
+    ensureOpenCapacity();
+    const startedAt = nowMs();
+    const execution = {
+      id: `be_${nextExecution}`,
+      kind,
+      ...eventType ? { eventType } : {},
+      phase: "open",
+      startedAt,
+      startedAtWallMs: Date.now(),
+      lastActivityAt: startedAt,
+      inFlight: 0,
+      hasError: false,
+      partial: false,
+      events: [],
+      functions: /* @__PURE__ */ new Map(),
+      successCounts: /* @__PURE__ */ new Map(),
+      suppressionByContext: /* @__PURE__ */ new Map(),
+      structuralCount: 0,
+      valueCount: 0,
+      enterCount: 0,
+      captureProfile: "normal",
+      estimatedBytes: 128,
+      provenanceNotes: [],
+      writes: [],
+      reads: [],
+      capturedErrors: /* @__PURE__ */ new WeakMap(),
+      settlingTimer: void 0,
+      holdTimer: void 0
+    };
+    nextExecution += 1;
+    open.add(execution);
+    stats.activeEstimatedBytes += execution.estimatedBytes;
+    stats.activeExecutions = open.size;
+    if (stats.activeEstimatedBytes > stats.peakActiveEstimatedBytes) {
+      stats.peakActiveEstimatedBytes = stats.activeEstimatedBytes;
+    }
+    if (open.size > stats.peakActiveExecutions) stats.peakActiveExecutions = open.size;
+    execution.holdTimer = setTimeout(() => {
+      execution.partial = true;
+      execution.provenanceNotes.push(HOLD_NOTE);
+      closeExecution(execution);
+    }, config.holdMs);
+    return execution;
+  };
+  const resolveExecution = () => {
+    const carrier = activeCarrier();
+    if (carrier) {
+      return {
+        execution: carrier.execution,
+        parentCallId: carrier.callId,
+        provenance: "observed"
+      };
+    }
+    const event = windowEvent();
+    if (event) {
+      const existing = eventRoots.get(event);
+      if (existing && existing.phase !== "closed") {
+        reopenIfSettling(existing);
+        return { execution: existing, provenance: "observed" };
+      }
+      if (isDiscreteEvent(event)) {
+        const execution2 = createExecution("interaction", eventTypeOf(event));
+        eventRoots.set(event, execution2);
+        return { execution: execution2, provenance: "observed" };
+      }
+    }
+    const live = [...open].filter((execution2) => execution2.phase !== "closed");
+    const joinable = live.filter(
+      (execution2) => execution2.phase === "settling" || execution2.inFlight === 0
+    );
+    if (joinable.length === 1) {
+      const execution2 = joinable[0];
+      reopenIfSettling(execution2);
+      execution2.provenanceNotes.push("joined during settling window");
+      stats.attributionInferred += 1;
+      return { execution: execution2, provenance: "inferred" };
+    }
+    const settling = live.filter((execution2) => execution2.phase === "settling");
+    if (settling.length > 1) {
+      const execution2 = settling.reduce(
+        (latest, candidate) => candidate.lastActivityAt >= latest.lastActivityAt ? candidate : latest
+      );
+      reopenIfSettling(execution2);
+      execution2.provenanceNotes.push("joined most recent of multiple settling executions");
+      stats.attributionInferred += 1;
+      stats.attributionInferredAmbiguous += 1;
+      return { execution: execution2, provenance: "inferred-ambiguous" };
+    }
+    const execution = createExecution("detached");
+    execution.provenanceNotes.push("no observed carrier or discrete event");
+    stats.attributionUnlinked += 1;
+    return { execution, provenance: "unlinked" };
+  };
+  const safeFact = (key, value) => {
+    if (typeof value === "object" && value !== null) return void 0;
+    return {
+      key,
+      value: captureValue(value),
+      timestampMs: nowMs()
+    };
+  };
+  const activeExecution = () => {
+    const carrier = activeCarrier();
+    if (carrier) return carrier.execution;
+    const settling = [...open].filter((execution) => execution.phase !== "closed");
+    return settling.length === 1 ? settling[0] : void 0;
+  };
+  const noteStateWrite = (key, value) => {
+    try {
+      const execution = activeExecution();
+      const fact = safeFact(key, value);
+      if (!execution || !fact || !recordingOpen(execution)) return;
+      const carrier = activeCarrier();
+      if (carrier) {
+        const identity = execution.functions.get(carrier.functionId);
+        if (identity) fact.functionName = identity.name;
+      }
+      execution.writes.push(fact);
+    } catch {
+    }
+  };
+  const noteStateRead = (key, value) => {
+    try {
+      const execution = activeExecution();
+      const fact = safeFact(key, value);
+      if (!execution || !fact || !recordingOpen(execution)) return;
+      const carrier = activeCarrier();
+      if (carrier) {
+        const identity = execution.functions.get(carrier.functionId);
+        if (identity) fact.functionName = identity.name;
+      }
+      execution.reads.push(fact);
+    } catch {
+    }
+  };
+  const rememberError = (error, execution) => {
+    execution.hasError = true;
+    if (typeof error === "object" && error !== null && !errors.has(error)) {
+      errors.set(error, execution);
+    }
+  };
+  const inheritedDataString = (error, key) => {
+    let current2 = error;
+    while (current2) {
+      const descriptor = Object.getOwnPropertyDescriptor(current2, key);
+      if (descriptor) {
+        if (descriptor.get || typeof descriptor.value !== "string") return void 0;
+        return descriptor.value;
+      }
+      current2 = Object.getPrototypeOf(current2);
+    }
+    return void 0;
+  };
+  const thrownFields = (error) => {
+    if (typeof error !== "object" || error === null) return {};
+    const errorName = inheritedDataString(error, "name") ?? (error instanceof Error && typeof error.constructor.name === "string" ? error.constructor.name : void 0);
+    const errorMessage = inheritedDataString(error, "message");
+    return {
+      ...errorName === void 0 || errorName.length === 0 ? {} : { errorName },
+      ...errorMessage === void 0 ? {} : { errorMessage }
+    };
+  };
+  const suppressionContextKey = (functionId, parentFunctionId) => parentFunctionId ? `${functionId}\0${parentFunctionId}` : functionId;
+  const noteSuppressed = (execution, identity, parentCallId, parentFunctionId) => {
+    stats.repeatedCallsSuppressed += 1;
+    noteOnce(execution, REPEAT_NOTE);
+    if (!recordingOpen(execution)) return;
+    const key = suppressionContextKey(identity.functionId, parentFunctionId);
+    const existing = execution.suppressionByContext.get(key);
+    if (existing) {
+      existing.suppressedCallCount += 1;
+      return;
+    }
+    const event = {
+      type: "function_calls_suppressed",
+      functionId: identity.functionId,
+      ...parentCallId === void 0 ? {} : { parentCallId },
+      timestampMs: nowMs(),
+      suppressedCallCount: 1
+    };
+    execution.suppressionByContext.set(key, event);
+    appendEvent(execution, event, 16);
+  };
+  const recordThrow = (execution, identity, error, callId, priorSuccessfulRuns) => {
+    if (!recordingOpen(execution)) return;
+    execution.functions.set(identity.functionId, identity);
+    rememberError(error, execution);
+    const key = (typeof error === "object" || typeof error === "function") && error !== null ? error : void 0;
+    const referencedCallId = key ? execution.capturedErrors.get(key) : void 0;
+    if (referencedCallId !== void 0) {
+      pushStructural(
+        execution,
+        {
+          type: "function_throw",
+          callId,
+          timestampMs: nowMs(),
+          error: { __rasputin_type: "ErrorReference", callId: referencedCallId },
+          ...priorSuccessfulRuns === void 0 ? {} : { priorSuccessfulRuns }
+        },
+        32
+      );
+      return;
+    }
+    if (key) execution.capturedErrors.set(key, callId);
+    pushStructural(
+      execution,
+      {
+        type: "function_throw",
+        callId,
+        timestampMs: nowMs(),
+        ...thrownFields(error),
+        ...priorSuccessfulRuns === void 0 ? {} : { priorSuccessfulRuns }
+      },
+      32
+    );
+  };
+  const countSuccessfulRepeat = (frame) => {
+    if (frame.threw || frame.successCounted || !frame.recordedEnter) return;
+    frame.successCounted = true;
+    const parentId = frame.previous?.functionId;
+    const key = repeatKey(frame.functionId, parentId);
+    frame.execution.successCounts.set(key, (frame.execution.successCounts.get(key) ?? 0) + 1);
+  };
+  const isCheapPrimitive = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  const leaveRecorded = (frame, value) => {
+    const leaveStarted = config.profileCosts ? nowMs() : 0;
+    if (frame.recordedEnter && !frame.exited) {
+      frame.exited = true;
+      const structurePrimitive = frame.omitValues && frame.identity.captureClass === "structure" && isCheapPrimitive(value);
+      const capture = (!frame.omitValues || structurePrimitive) && valuesAllowed(frame.execution) && hasValueBudget(frame.execution) ? captureValue(value) : void 0;
+      if (capture) consumeValue(frame.execution);
+      pushStructural(
+        frame.execution,
+        {
+          type: "function_exit",
+          callId: frame.callId,
+          timestampMs: nowMs(),
+          ...capture ? { returnValue: capture } : {}
+        },
+        capture ? estimateCapturedBytes(capture) : 0
+      );
+    }
+    countSuccessfulRepeat(frame);
+    if (config.profileCosts) addCost(costs, "leaveEndMs", leaveStarted);
+    return value;
+  };
+  const failRecorded = (frame, error, liveArgs) => {
+    if (frame.threw) return;
+    frame.threw = true;
+    materializeThrowChain(frame, liveArgs);
+    recordThrow(frame.execution, frame.identity, error, frame.callId);
+  };
+  const endFrame = (frame) => {
+    const endStarted = config.profileCosts ? nowMs() : 0;
+    if (frame.ended) {
+      if (config.profileCosts) addCost(costs, "leaveEndMs", endStarted);
+      return;
+    }
+    frame.ended = true;
+    frame.suspended = false;
+    if (frame.recordedEnter && !frame.threw && !frame.exited) {
+      frame.exited = true;
+      pushStructural(
+        frame.execution,
+        {
+          type: "function_exit",
+          callId: frame.callId,
+          timestampMs: nowMs()
+        },
+        0
+      );
+    }
+    countSuccessfulRepeat(frame);
+    if (current === frame) current = frame.previous;
+    if (recordingOpen(frame.execution)) {
+      frame.execution.inFlight = Math.max(0, frame.execution.inFlight - 1);
+      if (frame.execution.inFlight === 0) scheduleClose(frame.execution);
+    }
+    if (config.profileCosts) addCost(costs, "leaveEndMs", endStarted);
+  };
+  const suspendFrame = (frame) => {
+    if (frame.ended || frame.suspended) return;
+    frame.suspended = true;
+    if (current === frame) current = frame.previous;
+  };
+  const resumeFrame = (frame, restored) => {
+    if (frame.ended) return restored[0];
+    frame.suspended = false;
+    if (!recordingOpen(frame.execution)) return restored[0];
+    current = frame;
+    reopenIfSettling(frame.execution);
+    if (restored.length > 0 && frame.recordedEnter) {
+      const captured = !frame.omitValues && valuesAllowed(frame.execution) && hasValueBudget(frame.execution) ? captureValue(restored[0]) : void 0;
+      if (captured) consumeValue(frame.execution);
+      pushStructural(
+        frame.execution,
+        {
+          type: "awaited",
+          callId: frame.callId,
+          timestampMs: nowMs(),
+          ...captured ? { value: captured } : { omitted: true }
+        },
+        captured ? estimateCapturedBytes(captured) : 0
+      );
+    }
+    return restored[0];
+  };
+  const attachThrowArgs = (event, liveArgs) => {
+    if (event.args !== void 0) return;
+    const captured = captureArgs(liveArgs);
+    if (!captured) return;
+    event.args = captured;
+    delete event.argsOmitted;
+    event.materialized = event.materialized ?? "throw-time";
+  };
+  const materializeThrowChain = (frame, liveArgs) => {
+    if (!recordingOpen(frame.execution)) return;
+    const chain = [];
+    let cursor = frame;
+    while (cursor && cursor.execution === frame.execution) {
+      chain.push(cursor);
+      cursor = cursor.previous;
+    }
+    chain.reverse();
+    let missing = false;
+    for (const ancestor of chain) {
+      const present = frame.execution.events.find(
+        (event) => event.type === "function_enter" && event.callId === ancestor.callId
+      );
+      if (present && present.type === "function_enter") {
+        if (ancestor === frame && liveArgs !== void 0) attachThrowArgs(present, liveArgs);
+        continue;
+      }
+      missing = true;
+      const parentCallId = ancestor.previous && ancestor.previous.execution === frame.execution ? ancestor.previous.callId : ancestor.parentCallId;
+      const captured = ancestor === frame && liveArgs !== void 0 ? captureArgs(liveArgs) : void 0;
+      appendEvent(
+        frame.execution,
+        {
+          type: "function_enter",
+          callId: ancestor.callId,
+          functionId: ancestor.functionId,
+          ...parentCallId === void 0 ? {} : { parentCallId },
+          timestampMs: nowMs(),
+          provenance: ancestor.recordedEnter ? "observed" : "inferred",
+          materialized: "throw-time",
+          ...captured ? { args: captured } : { argsOmitted: true }
+        },
+        16
+      );
+      frame.execution.functions.set(ancestor.functionId, ancestor.identity);
+      frame.execution.structuralCount += 1;
+    }
+    if (missing) noteOnce(frame.execution, THROW_TIME_NOTE);
+  };
+  const isAdoptValue = (value) => value !== null && typeof value === "object";
+  const ensureAdopt = (frame) => {
+    if (frame.adopt) return frame.adopt;
+    if (frame.identity.captureClass === "reactive-sparse") return void 0;
+    frame.adopt = createJsonAdoptFrame(frame.callee);
+    return frame.adopt;
+  };
+  const makeHandle = (frame) => isolateHandle({
+    leave: (value) => {
+      const result = frame.recordedEnter ? leaveRecorded(frame, value) : value;
+      if (isAdoptValue(result) || frame.adopt) {
+        const adopt = ensureAdopt(frame);
+        if (adopt) notifyJsonProducerLeave(adopt, result);
+      }
+      return result;
+    },
+    fail: (error, liveArgs) => {
+      failRecorded(frame, error, liveArgs);
+    },
+    end: () => {
+      if (frame.adopt) notifyJsonProducerEnd(frame.adopt);
+      endFrame(frame);
+    },
+    run: (callback) => callback(),
+    suspend: (value) => {
+      const adopt = ensureAdopt(frame);
+      if (adopt) notifyJsonProducerSuspend(adopt);
+      suspendFrame(frame);
+      return value;
+    },
+    resume: (...restored) => resumeFrame(frame, restored)
+  });
+  const pushFrame = (execution, identity, parentCallId, omitValues, recordedEnter, counted, callee) => {
+    const frame = {
+      callId: nextCallId,
+      functionId: identity.functionId,
+      identity,
+      execution,
+      previous: current,
+      parentCallId,
+      omitValues,
+      recordedEnter,
+      counted,
+      suspended: false,
+      ended: false,
+      threw: false,
+      exited: false,
+      successCounted: false,
+      ...callee ? { callee } : {}
+    };
+    nextCallId += 1;
+    current = frame;
+    if (recordingOpen(execution)) execution.inFlight += 1;
+    execution.functions.set(identity.functionId, identity);
+    return frame;
+  };
+  const enterSparse = (execution, identity, parentCallId, parentFunctionId, callee) => {
+    const suppressStarted = config.profileCosts ? nowMs() : 0;
+    const frame = pushFrame(execution, identity, parentCallId, true, false, true, callee);
+    noteSuppressed(execution, identity, parentCallId, parentFunctionId);
+    if (config.profileCosts) {
+      if (identity.captureClass === "skip") costs.entersSkip += 1;
+      else costs.entersSparse += 1;
+      addCost(costs, "suppressMs", suppressStarted);
+    }
+    return makeHandle(frame);
+  };
+  const enterRecorded = (execution, identity, parentCallId, provenance, args, omitValues, callee) => {
+    const omit = omitValues || !valuesAllowed(execution);
+    const frame = pushFrame(execution, identity, parentCallId, omit, true, false, callee);
+    const captured = omit || !hasValueBudget(execution) ? void 0 : captureArgs(args);
+    if (captured) consumeValue(execution);
+    let extra = 0;
+    if (captured) {
+      for (const value of captured) extra += estimateCapturedBytes(value);
+    }
+    pushStructural(
+      execution,
+      {
+        type: "function_enter",
+        callId: frame.callId,
+        functionId: identity.functionId,
+        ...parentCallId === void 0 ? {} : { parentCallId },
+        timestampMs: nowMs(),
+        provenance,
+        ...captured ? { args: captured } : { argsOmitted: true }
+      },
+      extra
+    );
+    stats.functionCallsCaptured += 1;
+    const handleStarted = config.profileCosts ? nowMs() : 0;
+    const handle = makeHandle(frame);
+    if (config.profileCosts) {
+      if (identity.captureClass === "full") costs.entersFull += 1;
+      else costs.entersStructure += 1;
+      addCost(costs, "handleAllocMs", handleStarted);
+    }
+    return handle;
+  };
+  const enterWithIdentity = (identity, args, omitValues, callee) => {
+    const enterStarted = config.profileCosts ? nowMs() : 0;
+    const liveArgs = args ?? emptyArgs;
+    stats.functionCallsObserved += 1;
+    const carrier = activeCarrier();
+    if (carrier) {
+      const execution2 = carrier.execution;
+      const parentCallId2 = carrier.callId;
+      const parentFn2 = carrier.functionId;
+      execution2.enterCount += 1;
+      updateProfile(execution2);
+      const seen2 = execution2.successCounts.get(repeatKey(identity.functionId, parentFn2)) ?? 0;
+      const cap2 = maxRepeatsFor(
+        identity.captureClass,
+        execution2.captureProfile,
+        config.maxCapturedCallsPerFunction
+      );
+      const handle2 = seen2 >= cap2 ? enterSparse(execution2, identity, parentCallId2, parentFn2, callee) : enterRecorded(
+        execution2,
+        identity,
+        parentCallId2,
+        "observed",
+        liveArgs,
+        omitValues === true || identity.captureClass !== "full",
+        callee
+      );
+      if (config.profileCosts) addCost(costs, "enterMs", enterStarted);
+      return handle2;
+    }
+    const resolveStarted = config.profileCosts ? nowMs() : 0;
+    const { execution, parentCallId, provenance } = resolveExecution();
+    if (config.profileCosts) addCost(costs, "resolveMs", resolveStarted);
+    if (!recordingOpen(execution)) return passthrough;
+    const parentFn = current?.functionId;
+    execution.enterCount += 1;
+    updateProfile(execution);
+    const seen = execution.successCounts.get(repeatKey(identity.functionId, parentFn)) ?? 0;
+    const cap = maxRepeatsFor(
+      identity.captureClass,
+      execution.captureProfile,
+      config.maxCapturedCallsPerFunction
+    );
+    const handle = seen >= cap ? enterSparse(execution, identity, parentCallId, parentFn, callee) : enterRecorded(
+      execution,
+      identity,
+      parentCallId,
+      provenance,
+      liveArgs,
+      omitValues === true || identity.captureClass !== "full",
+      callee
+    );
+    if (config.profileCosts) addCost(costs, "enterMs", enterStarted);
+    return handle;
+  };
+  const enterInner = (moduleIndex, planIndex, args, omitValues, plan, callee) => {
+    const captureClass = omitValues === true || args === void 0 ? "structure" : "full";
+    return enterWithIdentity(
+      identityFromIndex(moduleIndex, planIndex, captureClass, plan),
+      args,
+      omitValues,
+      callee
+    );
+  };
+  const enter = (moduleIndex, planIndex, args, omitValues, plan, callee) => {
+    try {
+      return enterInner(moduleIndex, planIndex, args, omitValues, plan, callee);
+    } catch {
+      return passthrough;
+    }
+  };
+  const observe = (siteId, value) => {
+    try {
+      const observeStarted = config.profileCosts ? nowMs() : 0;
+      if (config.profileCosts) costs.observeCalls += 1;
+      if (current?.counted) {
+        if (config.profileCosts) addCost(costs, "observeMs", observeStarted);
+        return value;
+      }
+      const execution = activeCarrier()?.execution ?? activeExecution();
+      if (!execution || !recordingOpen(execution) || !frontierAllowsValues(execution) || !hasValueBudget(execution)) {
+        if (config.profileCosts) addCost(costs, "observeMs", observeStarted);
+        return value;
+      }
+      const captureStarted = config.profileCosts ? nowMs() : 0;
+      const captured = captureValue(value);
+      if (config.profileCosts) addCost(costs, "captureMs", captureStarted);
+      consumeValue(execution);
+      appendEvent(
+        execution,
+        {
+          type: "expression_observed",
+          siteId,
+          ...current ? { callId: current.callId } : {},
+          timestampMs: nowMs(),
+          value: captured
+        },
+        estimateCapturedBytes(captured)
+      );
+      stats.expressionObservations += 1;
+      if (config.profileCosts) addCost(costs, "observeMs", observeStarted);
+      return value;
+    } catch {
+      return value;
+    }
+  };
+  const enterReactiveIdentity = (identity) => {
+    try {
+      return enterWithIdentity(identity, emptyArgs, true);
+    } catch {
+      return passthrough;
+    }
+  };
+  const rememberReactiveSite = (id, identity) => {
+    registeredReactiveSites.set(id, identity);
+    identities.set(identity.functionId, identity);
+    identitiesBySite.set(id, identity);
+    if (id >= reactiveSampled.length) {
+      reactiveSampled.length = id + 1;
+      reactiveInvocations.length = id + 1;
+      reactiveHandles.length = id + 1;
+    }
+  };
+  const reactiveRegister = (entries) => {
+    if (!Array.isArray(entries)) return;
+    for (const entry of entries) {
+      if (typeof entry === "number") {
+        const identity = identitiesBySite.get(entry) ?? {
+          functionId: `r${entry}`,
+          name: `r${entry}`,
+          packageName: null,
+          packageRelativePath: null,
+          line: null,
+          column: null,
+          captureClass: "reactive-sparse"
+        };
+        rememberReactiveSite(entry, identity);
+        continue;
+      }
+      if (!Array.isArray(entry) || typeof entry[0] !== "number") continue;
+      const id = entry[0];
+      const functionId = typeof entry[1] === "string" ? entry[1] : `r${id}`;
+      const name = typeof entry[2] === "string" ? entry[2] : functionId;
+      rememberReactiveSite(id, {
+        functionId,
+        name,
+        packageName: null,
+        packageRelativePath: null,
+        line: typeof entry[3] === "number" ? entry[3] : null,
+        column: typeof entry[4] === "number" ? entry[4] : null,
+        captureClass: "reactive-sparse"
+      });
+    }
+  };
+  const reactiveHit = (id) => {
+    try {
+      const hitStarted = config.profileCosts ? nowMs() : 0;
+      stats.reactiveCallbackInvocations += 1;
+      if (id >= reactiveInvocations.length) {
+        reactiveSampled.length = id + 1;
+        reactiveInvocations.length = id + 1;
+        reactiveHandles.length = id + 1;
+      }
+      reactiveInvocations[id] = (reactiveInvocations[id] ?? 0) + 1;
+      const identity = registeredReactiveSites.get(id);
+      if (reactiveSampled[id]) {
+        let owned = false;
+        try {
+          if (identity) {
+            const carrier = activeCarrier();
+            const resolved = carrier ? {
+              execution: carrier.execution,
+              parentCallId: carrier.callId
+            } : resolveExecution();
+            if (recordingOpen(resolved.execution)) {
+              pushFrame(resolved.execution, identity, resolved.parentCallId, true, false, true);
+              owned = true;
+            }
+          }
+        } finally {
+          reactiveOwned.push(owned);
+        }
+        if (config.profileCosts) addCost(costs, "reactiveHitMs", hitStarted);
+        return true;
+      }
+      reactiveOwned.push(false);
+      if (!identity) {
+        reactiveSampled[id] = true;
+        if (config.profileCosts) addCost(costs, "reactiveHitMs", hitStarted);
+        return true;
+      }
+      reactiveHandles[id] = enterReactiveIdentity(identity);
+      stats.reactiveRecordedEntries += 1;
+      if (config.profileCosts) addCost(costs, "reactiveHitMs", hitStarted);
+      return false;
+    } catch {
+      return true;
+    }
+  };
+  const reactiveLeave = (id, value) => {
+    try {
+      const handle = reactiveHandles[id];
+      if (!handle) return value;
+      reactiveHandles[id] = void 0;
+      reactiveSampled[id] = true;
+      const result = handle.leave(value);
+      handle.end();
+      return result;
+    } catch {
+      return value;
+    }
+  };
+  const reactiveThrow = (id, error) => {
+    try {
+      stats.reactiveThrows += 1;
+      const handle = reactiveHandles[id];
+      if (handle) {
+        reactiveHandles[id] = void 0;
+        handle.fail(error);
+        handle.end();
+        return;
+      }
+      const identity = registeredReactiveSites.get(id);
+      if (current?.counted && identity && current.functionId === identity.functionId) {
+        if (!current.threw) {
+          current.threw = true;
+          materializeThrowChain(current);
+          recordThrow(
+            current.execution,
+            identity,
+            error,
+            current.callId,
+            Math.max(0, (reactiveInvocations[id] ?? 1) - 1)
+          );
+        }
+        return;
+      }
+      if (!identity) return;
+      const resolved = resolveExecution();
+      if (!recordingOpen(resolved.execution)) return;
+      let enteredCallId;
+      for (let index = resolved.execution.events.length - 1; index >= 0; index -= 1) {
+        const event = resolved.execution.events[index];
+        if (event?.type === "function_enter" && event.functionId === identity.functionId) {
+          enteredCallId = event.callId;
+          break;
+        }
+      }
+      if (enteredCallId === void 0) return;
+      recordThrow(
+        resolved.execution,
+        identity,
+        error,
+        enteredCallId,
+        Math.max(0, (reactiveInvocations[id] ?? 1) - 1)
+      );
+      if (resolved.execution.inFlight === 0) scheduleClose(resolved.execution);
+    } catch {
+    }
+  };
+  const reactiveDone = () => {
+    try {
+      const owned = reactiveOwned.pop() === true;
+      if (!owned || !current?.counted || current.ended) return;
+      const thrown = current.threw;
+      endFrame(current);
+      if (thrown) return;
+      stats.reactiveSparseCounted += 1;
+      if (config.profileCosts) costs.reactiveRepeats += 1;
+    } catch {
+    }
+  };
+  return {
+    enter,
+    registerIdentities,
+    observe,
+    reactiveRegister,
+    reactiveHit,
+    reactiveLeave,
+    reactiveThrow,
+    reactiveDone,
+    noteStateWrite,
+    noteStateRead,
+    getHistory: () => [...history],
+    getErrorState(error) {
+      if (typeof error !== "object" || error === null) return void 0;
+      const execution = errors.get(error);
+      if (!execution) return void 0;
+      const snapshot = snapshotOf(execution, config.captureMode);
+      snapshot.historyLinks = linkHistory(execution);
+      return snapshot;
+    },
+    getState() {
+      return {
+        open: [...open].map(summarize),
+        recent: [...recent],
+        snapshots: [...snapshots],
+        history: [...history],
+        stats: { ...stats, ...config.profileCosts ? { costs: { ...costs } } : {} }
+      };
+    },
+    reset() {
+      for (const execution of [...open]) closeExecution(execution);
+      open.clear();
+      recent.length = 0;
+      snapshots.length = 0;
+      history.length = 0;
+      current = null;
+      nextCallId = 1;
+      nextExecution = 1;
+      identities.clear();
+      identitiesBySite.clear();
+      registeredReactiveSites.clear();
+      internedIds.clear();
+      nextIntern = 1;
+      reactiveHandles.length = 0;
+      reactiveSampled.length = 0;
+      reactiveInvocations.length = 0;
+      reactiveOwned.length = 0;
+      Object.assign(stats, emptyStats());
+      Object.assign(costs, emptyCosts());
+      resetJsonProducerAdopt();
+    }
+  };
+};
+var isolateHandle = (handle) => ({
+  leave: (value) => {
+    try {
+      return handle.leave(value);
+    } catch {
+      return value;
+    }
+  },
+  fail: (error, liveArgs) => {
+    try {
+      handle.fail(error, liveArgs);
+    } catch {
+    }
+  },
+  end: () => {
+    try {
+      handle.end();
+    } catch {
+    }
+  },
+  run: (callback) => {
+    let outcome;
+    const wrapped = () => {
+      try {
+        const value = callback();
+        outcome = { kind: "value", value };
+        return value;
+      } catch (error) {
+        outcome = { kind: "throw", error };
+        throw error;
+      }
+    };
+    try {
+      handle.run(wrapped);
+    } catch {
+    }
+    if (outcome?.kind === "throw") throw outcome.error;
+    if (outcome?.kind === "value") return outcome.value;
+    return callback();
+  },
+  suspend: (value) => {
+    try {
+      return handle.suspend(value);
+    } catch {
+      return value;
+    }
+  },
+  // Rest args, not `arguments`: isolateHandle is an arrow and ESM has no arguments object.
+  resume: (...restored) => {
+    try {
+      return restored.length === 0 ? handle.resume() : handle.resume(restored[0]);
+    } catch {
+      return restored[0];
+    }
+  }
+});
+
+// ../recorder/src/run-exactly-once.ts
+var runExactlyOnce = function __rasputinHandleRun__(invoke, callback) {
+  let outcome;
+  const wrapped = function __rasputinHandleRun__2() {
+    try {
+      const value = callback();
+      outcome = { kind: "value", value };
+      return value;
+    } catch (caught) {
+      outcome = { kind: "throw", error: caught };
+      throw caught;
+    }
+  };
+  try {
+    invoke(wrapped);
+  } catch {
+  }
+  if (outcome?.kind === "throw") throw outcome.error;
+  if (outcome?.kind === "value") return outcome.value;
+  return callback();
+};
+
+// ../recorder/src/call-handle.ts
+var passthroughHandle = () => ({
+  leave: (value) => value,
+  fail: () => {
+  },
+  end: () => {
+  },
+  run: function __rasputinHandleRun__2(callback) {
+    return runExactlyOnce((invoke) => invoke(), callback);
+  },
+  suspend: (value) => value,
+  resume: (value) => value
+});
+
+// ../recorder/src/runtime-symbol.ts
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v3";
+
+// ../recorder/src/registry.ts
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+var passthroughRun = (_planIndex, _args, callback) => callback();
+var passthroughEnter = () => passthroughHandle();
+var attachRunner = (cell) => {
+  const run = ((planIndex, args, callback, omitValues) => cell.run(planIndex, args, callback, omitValues));
+  run.enter = (planIndex, args, omitValues, callee) => cell.enter(planIndex, args, omitValues, callee);
+  return run;
+};
+var isCompatibleRegistry = (value) => typeof Reflect.get(value, "register") === "function" && Array.isArray(Reflect.get(value, "runtimes")) && Array.isArray(Reflect.get(value, "modules"));
+var registerModule = (registry, plans, moduleIndex) => {
+  const cell = { run: passthroughRun, enter: passthroughEnter };
+  const module = {
+    plans,
+    cell,
+    ...moduleIndex === void 0 ? {} : { moduleIndex }
+  };
+  registry.modules.push(module);
+  registry.runtimes.at(-1)?.bind(module);
+  return attachRunner(cell);
+};
+var createRegistry = () => {
+  const registry = {
+    runtimes: [],
+    modules: [],
+    register(plans, moduleIndex) {
+      return registerModule(registry, plans, moduleIndex);
+    }
+  };
+  return registry;
+};
+var getAutomaticRuntimeRegistry = () => {
+  const existing = Reflect.get(globalThis, runtimeSymbol);
+  if (existing && typeof existing === "object" && isCompatibleRegistry(existing)) {
+    return existing;
+  }
+  if (existing != null) {
+    return createRegistry();
+  }
+  const registry = createRegistry();
+  Reflect.set(globalThis, runtimeSymbol, registry);
+  return registry;
+};
+
+// src/install-browser-runtime.ts
+var installBrowserExecutionRuntime = (enter) => {
+  const registry = getAutomaticRuntimeRegistry();
+  const runtime = {
+    bind(module) {
+      module.cell.enter = (planIndex, args, omitValues, callee) => {
+        return enter(
+          module.moduleIndex ?? 0,
+          planIndex,
+          args,
+          omitValues,
+          module.plans[planIndex],
+          callee
+        );
+      };
+      module.cell.run = (planIndex, args, callback, omitValues) => {
+        const handle = module.cell.enter(planIndex, args, omitValues);
+        try {
+          const result = handle.run(callback);
+          handle.leave(result);
+          return result;
+        } catch (error) {
+          handle.fail(error, args);
+          throw error;
+        } finally {
+          handle.end();
+        }
+      };
+    }
+  };
+  registry.runtimes.push(runtime);
+  for (const module of registry.modules) runtime.bind(module);
+  return () => {
+    const index = registry.runtimes.lastIndexOf(runtime);
+    if (index >= 0) registry.runtimes.splice(index, 1);
+    const current = registry.runtimes.at(-1);
+    for (const module of registry.modules) {
+      if (current) current.bind(module);
+      else {
+        module.cell.enter = () => passthroughHandle();
+        module.cell.run = (_planIndex, _args, callback) => callback();
+      }
+    }
+  };
+};
+
+// src/browser-runtime.ts
+var installed;
+var pendingIdentities = [];
+var OBSERVE_SYMBOL = Symbol.for("rasputin.observe.v1");
+var OBSERVE_NAME = "__rasputinO";
+var STRUCT_NAME = "__rasputinK";
+var JSON_METHOD_NAME = "__rasputinM";
+var JSON_AWAIT_NAME = "__rasputinA";
+var JSON_ADOPT_NAME = "__rasputinP";
+var PROVENANCE_HANDLE_NAME = "__rasputinN";
+var REACTIVE_HIT = "__rasputinR";
+var REACTIVE_LEAVE = "__rasputinL";
+var REACTIVE_THROW = "__rasputinT";
+var REACTIVE_DONE = "__rasputinD";
+var REACTIVE_REG = "__rasputinReg";
+var identityObserve = (_siteId, value) => value;
+var passthroughHit = () => 1;
+var passthroughLeave = (_id, value) => value;
+var passthroughThrow = () => {
+};
+var passthroughDone = () => {
+};
+var passthroughReg = () => {
+};
+var installObserve = (observe) => {
+  const guarded = (siteId, value) => {
+    if (typeof siteId !== "string" && typeof siteId !== "number") return value;
+    try {
+      return observe(siteId, value);
+    } catch {
+      return value;
+    }
+  };
+  Reflect.set(globalThis, OBSERVE_SYMBOL, guarded);
+  Reflect.set(globalThis, OBSERVE_NAME, guarded);
+};
+var installLiteralRemember = (remember) => {
+  const guarded = (object, keys, values) => {
+    try {
+      return remember(object, keys, values);
+    } catch {
+      return object;
+    }
+  };
+  Reflect.set(globalThis, STRUCT_NAME, guarded);
+};
+var installReactive = (recorder) => {
+  Reflect.set(globalThis, REACTIVE_HIT, (id) => {
+    if (typeof id !== "number") return 1;
+    try {
+      return recorder.reactiveHit(id) ? 1 : 0;
+    } catch {
+      return 1;
+    }
+  });
+  Reflect.set(globalThis, REACTIVE_LEAVE, (id, value) => {
+    if (typeof id !== "number") return value;
+    try {
+      return recorder.reactiveLeave(id, value);
+    } catch {
+      return value;
+    }
+  });
+  Reflect.set(globalThis, REACTIVE_THROW, (id, error) => {
+    if (typeof id !== "number") return;
+    try {
+      recorder.reactiveThrow(id, error);
+    } catch {
+    }
+  });
+  Reflect.set(globalThis, REACTIVE_DONE, () => {
+    try {
+      recorder.reactiveDone();
+    } catch {
+    }
+  });
+  Reflect.set(globalThis, REACTIVE_REG, (entries) => {
+    try {
+      recorder.reactiveRegister(entries);
+    } catch {
+    }
+  });
+};
+var uninstallReactive = () => {
+  Reflect.set(globalThis, REACTIVE_HIT, passthroughHit);
+  Reflect.set(globalThis, REACTIVE_LEAVE, passthroughLeave);
+  Reflect.set(globalThis, REACTIVE_THROW, passthroughThrow);
+  Reflect.set(globalThis, REACTIVE_DONE, passthroughDone);
+  Reflect.set(globalThis, REACTIVE_REG, passthroughReg);
+};
+var RasputinBrowserInit = (options = {}) => {
+  installed?.uninstall();
+  const recorder = createBrowserRecorder(options);
+  if (pendingIdentities.length > 0) {
+    recorder.registerIdentities(pendingIdentities);
+    pendingIdentities.length = 0;
+  }
+  const fromBuild = Reflect.get(globalThis, "__RASPUTIN_BUILD_IDENTITIES__");
+  if (Array.isArray(fromBuild)) recorder.registerIdentities(fromBuild);
+  if (Array.isArray(options.identities)) recorder.registerIdentities(options.identities);
+  const uninstall = installBrowserExecutionRuntime(recorder.enter);
+  installObserve(recorder.observe);
+  installLiteralRemember(rememberKnownLiteral);
+  installReactive(recorder);
+  Reflect.set(globalThis, JSON_METHOD_NAME, invokeNativeJsonMethod);
+  Reflect.set(globalThis, JSON_AWAIT_NAME, tagJsonAwaitResult);
+  Reflect.set(globalThis, JSON_ADOPT_NAME, adoptAsyncJsonPromise);
+  Reflect.set(globalThis, PROVENANCE_HANDLE_NAME, createProvenanceHandle);
+  installed = {
+    getState: recorder.getState,
+    getErrorState: recorder.getErrorState,
+    getHistory: recorder.getHistory,
+    noteStateWrite: recorder.noteStateWrite,
+    noteStateRead: recorder.noteStateRead,
+    registerIdentities: recorder.registerIdentities,
+    reset: recorder.reset,
+    uninstall: () => {
+      uninstall();
+      Reflect.set(globalThis, OBSERVE_SYMBOL, identityObserve);
+      Reflect.set(globalThis, OBSERVE_NAME, identityObserve);
+      Reflect.set(globalThis, STRUCT_NAME, passthroughKnownLiteral);
+      Reflect.set(globalThis, JSON_METHOD_NAME, passthroughNativeJsonMethod);
+      Reflect.set(globalThis, JSON_AWAIT_NAME, passthroughJsonAwait);
+      Reflect.set(globalThis, JSON_ADOPT_NAME, passthroughAdopt);
+      Reflect.set(globalThis, PROVENANCE_HANDLE_NAME, passthroughProvenanceHandle);
+      uninstallReactive();
+      recorder.reset();
+    }
+  };
+  const publicApi = {
+    getState: recorder.getState,
+    getErrorState: recorder.getErrorState,
+    getHistory: recorder.getHistory,
+    noteStateWrite: recorder.noteStateWrite,
+    noteStateRead: recorder.noteStateRead
+  };
+  Reflect.set(globalThis, "__rasputinRuntime", publicApi);
+  const browserWindow = Reflect.get(globalThis, "window");
+  if (browserWindow && typeof browserWindow === "object") {
+    Reflect.set(browserWindow, "__rasputinRuntime", publicApi);
+  }
+  return {
+    getState: recorder.getState,
+    getErrorState: recorder.getErrorState,
+    getHistory: recorder.getHistory
+  };
+};
+var getBrowserRuntimeState = () => installed?.getState() ?? {
+  open: [],
+  recent: [],
+  snapshots: [],
+  history: [],
+  stats: {
+    functionCallsObserved: 0,
+    functionCallsCaptured: 0,
+    successfulExecutionsDiscarded: 0,
+    errorSnapshots: 0,
+    activeExecutions: 0,
+    peakActiveExecutions: 0,
+    activeEstimatedBytes: 0,
+    peakActiveEstimatedBytes: 0,
+    attributionInferred: 0,
+    attributionInferredAmbiguous: 0,
+    attributionUnlinked: 0,
+    truncatedEvents: 0,
+    truncatedStructural: 0,
+    omittedValueObservations: 0,
+    expressionObservations: 0,
+    repeatedCallsSuppressed: 0,
+    executionsDroppedUnderPressure: 0,
+    reactiveCallbackInvocations: 0,
+    reactiveRecordedEntries: 0,
+    reactiveSparseCounted: 0,
+    reactiveThrows: 0
+  }
+};
+var getBrowserErrorState = (error) => installed?.getErrorState(error);
+var registerBrowserIdentities = (items) => {
+  if (installed) installed.registerIdentities(items);
+  else pendingIdentities.push(...items);
+};
+Reflect.set(globalThis, "__rasputinRegisterIdentities", registerBrowserIdentities);
+var uninstallBrowserRuntime = () => {
+  installed?.uninstall();
+  installed = void 0;
+  Reflect.deleteProperty(globalThis, "__rasputinRuntime");
+  const browserWindow = Reflect.get(globalThis, "window");
+  if (browserWindow && typeof browserWindow === "object") {
+    Reflect.deleteProperty(browserWindow, "__rasputinRuntime");
+  }
+};
+
+// src/browser-transport.ts
+var KEEPALIVE_MAX_BYTES = 60 * 1024;
+var DEFAULTS2 = {
+  maxQueueSize: 40,
+  maxQueueBytes: 256 * 1024,
+  batchSize: 8,
+  flushIntervalMs: 8e3,
+  maxRetries: 3
+};
+var utf82 = new TextEncoder();
+var encodedBytes = (value) => {
+  try {
+    return utf82.encode(JSON.stringify(value)).byteLength;
+  } catch {
+    return 256;
+  }
+};
+var isOnline = () => {
+  const nav = Reflect.get(globalThis, "navigator");
+  if (!nav || typeof nav !== "object" || !("onLine" in nav)) return true;
+  return Reflect.get(nav, "onLine") !== false;
+};
+var defaultFetch = async (input, init) => {
+  const response = await fetch(input, init);
+  return { status: response.status, ok: response.ok };
+};
+var backoffMs = (attempt) => Math.min(8e3, 400 * 2 ** attempt);
+var sleep = (ms, signal) => new Promise((resolve) => {
+  if (ms <= 0 || signal?.aborted) {
+    resolve();
+    return;
+  }
+  const timer = setTimeout(resolve, ms);
+  signal?.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(timer);
+      resolve();
+    },
+    { once: true }
+  );
+});
+var createBrowserTransport = (options) => {
+  const enabled = options.enabled;
+  const maxQueueSize = options.maxQueueSize ?? DEFAULTS2.maxQueueSize;
+  const maxQueueBytes = options.maxQueueBytes ?? DEFAULTS2.maxQueueBytes;
+  const batchSize = options.batchSize ?? DEFAULTS2.batchSize;
+  const flushIntervalMs = options.flushIntervalMs ?? DEFAULTS2.flushIntervalMs;
+  const maxRetries = options.maxRetries ?? DEFAULTS2.maxRetries;
+  const fetchFn = options.fetch ?? defaultFetch;
+  const queue = [];
+  let queuedBytes = 0;
+  let timer;
+  let flushing;
+  let closed = false;
+  let enqueued = 0;
+  let droppedIncoming = 0;
+  let droppedQueued = 0;
+  let droppedKeepalive = 0;
+  let deliverySeq = 0;
+  let flushesStarted = 0;
+  let sendAttempts = 0;
+  let sendRetries = 0;
+  let batchesSucceeded = 0;
+  let batchesDropped = 0;
+  let batchesFailed = 0;
+  let networkErrors = 0;
+  let rateLimitedResponses = 0;
+  let serverErrorResponses = 0;
+  let lastFailureKind = null;
+  let lastFailureStatusCode = null;
+  let uninstallLifecycle = () => {
+  };
+  const dropOldest = () => {
+    const removed = queue.shift();
+    if (!removed) return;
+    queuedBytes = Math.max(0, queuedBytes - removed.bytes);
+    droppedQueued += 1;
+  };
+  const push = (item) => {
+    if (!enabled || closed) return;
+    if (item.bytes > maxQueueBytes) {
+      droppedIncoming += 1;
+      return;
+    }
+    while (queue.length >= maxQueueSize || queuedBytes + item.bytes > maxQueueBytes) {
+      if (queue.length === 0) {
+        droppedIncoming += 1;
+        return;
+      }
+      dropOldest();
+    }
+    queue.push(item);
+    queuedBytes += item.bytes;
+    enqueued += 1;
+  };
+  const enqueue = (event) => {
+    push({ kind: "event", event, bytes: encodedBytes(event) });
+  };
+  const enqueueSummary = (summary) => {
+    push({ kind: "summary", summary, bytes: encodedBytes(summary) });
+  };
+  const authHeaders = {
+    authorization: `Bearer ${options.publicKey}`,
+    "content-type": "application/json"
+  };
+  const nextDeliveryKey = () => `b_${(++deliverySeq).toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+  const takeDelivery = (mode) => {
+    const first = queue[0];
+    if (!first) return [];
+    if (first.deliveryKey) {
+      const key2 = first.deliveryKey;
+      const taken2 = [];
+      while (queue[0]?.deliveryKey === key2) {
+        const item = queue.shift();
+        if (item) taken2.push(item);
+      }
+      return taken2;
+    }
+    const taken = queue.splice(0, mode === "unload" ? queue.length : batchSize);
+    const key = nextDeliveryKey();
+    for (const item of taken) item.deliveryKey = key;
+    return taken;
+  };
+  const encodeBatch = (events, summaries, idempotencyKey) => JSON.stringify({
+    events,
+    ...summaries.length > 0 ? { summaries } : {},
+    sdk_version: options.sdkVersion,
+    sdk_name: options.sdkName,
+    idempotency_key: idempotencyKey
+  });
+  const shrinkUnloadBody = (events, summaries, idempotencyKey) => {
+    const total = events.length + summaries.length;
+    const candidates = [
+      { events, summaries },
+      { events, summaries: [] },
+      { events: events.slice(0, 1), summaries: [] }
+    ];
+    for (const candidate of candidates) {
+      const body = encodeBatch(candidate.events, candidate.summaries, idempotencyKey);
+      if (utf82.encode(body).byteLength <= KEEPALIVE_MAX_BYTES) {
+        return {
+          body,
+          events: candidate.events,
+          summaries: candidate.summaries,
+          omitted: total - candidate.events.length - candidate.summaries.length
+        };
+      }
+    }
+    return { tooLarge: true, omitted: total };
+  };
+  const sendBatch = async (events, summaries, mode, idempotencyKey) => {
+    if (mode === "unload") {
+      const shrunk = shrinkUnloadBody(events, summaries, idempotencyKey);
+      if ("tooLarge" in shrunk) {
+        droppedKeepalive += shrunk.omitted;
+        droppedQueued += shrunk.omitted;
+        batchesDropped += 1;
+        lastFailureKind = "too_large";
+        return "dropped";
+      }
+      if (shrunk.omitted > 0) {
+        droppedKeepalive += shrunk.omitted;
+        droppedQueued += shrunk.omitted;
+      }
+      try {
+        sendAttempts += 1;
+        const response = await fetchFn(options.ingestUrl, {
+          method: "POST",
+          headers: authHeaders,
+          body: shrunk.body,
+          keepalive: true
+        });
+        if (response.ok) {
+          batchesSucceeded += 1;
+          return "ok";
+        }
+        droppedKeepalive += shrunk.events.length + shrunk.summaries.length;
+        droppedQueued += shrunk.events.length + shrunk.summaries.length;
+        batchesDropped += 1;
+        lastFailureKind = "non_retryable_http";
+        lastFailureStatusCode = response.status;
+        return "dropped";
+      } catch {
+        droppedKeepalive += shrunk.events.length + shrunk.summaries.length;
+        droppedQueued += shrunk.events.length + shrunk.summaries.length;
+        batchesDropped += 1;
+        lastFailureKind = "network_error";
+        return "dropped";
+      }
+    }
+    const body = encodeBatch(events, summaries, idempotencyKey);
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+      if (attempt > 0) {
+        if (!isOnline()) return "failed";
+        sendRetries += 1;
+        await sleep(backoffMs(attempt - 1));
+      }
+      try {
+        sendAttempts += 1;
+        const response = await fetchFn(options.ingestUrl, {
+          method: "POST",
+          headers: authHeaders,
+          body
+        });
+        if (response.ok) {
+          batchesSucceeded += 1;
+          return "ok";
+        }
+        lastFailureStatusCode = response.status;
+        if (response.status === 429) {
+          rateLimitedResponses += 1;
+          lastFailureKind = "rate_limited";
+          continue;
+        }
+        if (response.status >= 500) {
+          serverErrorResponses += 1;
+          lastFailureKind = "server_error";
+          continue;
+        }
+        batchesDropped += 1;
+        lastFailureKind = "non_retryable_http";
+        return "dropped";
+      } catch {
+        networkErrors += 1;
+        lastFailureKind = "network_error";
+      }
+    }
+    batchesFailed += 1;
+    return "failed";
+  };
+  const flush = async (mode = "normal") => {
+    options.beforeFlush?.();
+    if (!enabled || queue.length === 0) return;
+    if (flushing) {
+      if (mode === "unload") return;
+      await flushing;
+      return;
+    }
+    flushing = (async () => {
+      flushesStarted += 1;
+      while (queue.length > 0) {
+        if (mode === "normal" && !isOnline()) return;
+        const take = takeDelivery(mode);
+        queuedBytes = queue.reduce((sum, item) => sum + item.bytes, 0);
+        const events = take.flatMap((item) => item.kind === "event" ? [item.event] : []);
+        const summaries = take.flatMap((item) => item.kind === "summary" ? [item.summary] : []);
+        const idempotencyKey = take[0]?.deliveryKey ?? nextDeliveryKey();
+        const outcome = await sendBatch(events, summaries, mode, idempotencyKey);
+        if (outcome === "failed" && mode === "normal") {
+          queue.unshift(...take);
+          queuedBytes = queue.reduce((sum, item) => sum + item.bytes, 0);
+          return;
+        }
+        if (mode === "unload") {
+          if (outcome !== "ok" && queue.length > 0) {
+            droppedKeepalive += queue.length;
+            droppedQueued += queue.length;
+            queue.length = 0;
+            queuedBytes = 0;
+          }
+          if (outcome !== "ok") return;
+        }
+      }
+    })();
+    try {
+      await flushing;
+    } finally {
+      flushing = void 0;
+    }
+  };
+  const startTimer = () => {
+    if (timer || !enabled) return;
+    timer = setInterval(() => {
+      void flush("normal");
+    }, flushIntervalMs);
+  };
+  const installLifecycle = () => {
+    const target = Reflect.get(globalThis, "window");
+    if (!target || typeof target !== "object" || !("addEventListener" in target)) return;
+    const onHide = () => {
+      void flush("unload");
+    };
+    const onOnline = () => {
+      void flush("normal");
+    };
+    try {
+      target.addEventListener("pagehide", onHide);
+      target.addEventListener("online", onOnline);
+    } catch {
+      return;
+    }
+    uninstallLifecycle = () => {
+      try {
+        target.removeEventListener("pagehide", onHide);
+        target.removeEventListener("online", onOnline);
+      } catch {
+      }
+    };
+  };
+  if (enabled) {
+    startTimer();
+    installLifecycle();
+  }
+  return {
+    enqueue,
+    enqueueSummary,
+    flush: async (_timeoutMs) => {
+      try {
+        await flush("normal");
+      } catch {
+      }
+    },
+    close: async () => {
+      closed = true;
+      if (timer) clearInterval(timer);
+      timer = void 0;
+      uninstallLifecycle();
+      try {
+        await flush("unload");
+      } catch {
+      }
+      queue.length = 0;
+      queuedBytes = 0;
+    },
+    getStats: () => ({
+      queued: queue.length,
+      enqueued,
+      droppedIncoming,
+      droppedQueued,
+      droppedKeepalive,
+      droppedTotal: droppedIncoming + droppedQueued,
+      flushesStarted,
+      sendAttempts,
+      sendRetries,
+      batchesSucceeded,
+      batchesDropped,
+      batchesFailed,
+      networkErrors,
+      rateLimitedResponses,
+      serverErrorResponses,
+      lastFailureKind,
+      lastFailureStatusCode
+    })
+  };
+};
+
+// src/install-browser-handlers.ts
+var RASPUTIN_WINDOW_LISTENER = Symbol.for("rasputin.browser.listener.v1");
+var registered = [];
+var uninstallShared;
+var seenObjects = /* @__PURE__ */ new WeakSet();
+var seenPrimitives = /* @__PURE__ */ new Map();
+var PRIMITIVE_DEDUP_MS = 2e3;
+var tagListener = (listener) => {
+  Object.defineProperty(listener, RASPUTIN_WINDOW_LISTENER, { value: true });
+  return listener;
+};
+var primitiveKey = (value) => {
+  if (typeof value === "string") return `s:${value}`;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return `${typeof value}:${String(value)}`;
+  }
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  return `other:${String(value)}`;
+};
+var shouldCaptureBrowserError = (error) => {
+  if (error && typeof error === "object") {
+    if (seenObjects.has(error)) return false;
+    seenObjects.add(error);
+    return true;
+  }
+  const key = primitiveKey(error);
+  const now = Date.now();
+  const previous = seenPrimitives.get(key);
+  if (previous !== void 0 && now - previous < PRIMITIVE_DEDUP_MS) return false;
+  seenPrimitives.set(key, now);
+  if (seenPrimitives.size > 64) {
+    for (const [item, at] of seenPrimitives) {
+      if (now - at >= PRIMITIVE_DEDUP_MS) seenPrimitives.delete(item);
+    }
+  }
+  return true;
+};
+var captureOnAll = (error) => {
+  for (const entry of registered) {
+    try {
+      entry.client.captureException(error);
+    } catch {
+    }
+  }
+};
+var installSharedListeners = () => {
+  if (uninstallShared) return;
+  const target = Reflect.get(globalThis, "window");
+  if (!target || typeof target !== "object" || !("addEventListener" in target)) return;
+  const onError = tagListener((event) => {
+    if (!event || typeof event !== "object") return;
+    const error = "error" in event ? Reflect.get(event, "error") : void 0;
+    if (error !== void 0 && error !== null) {
+      captureOnAll(error);
+      return;
+    }
+    const message = "message" in event ? Reflect.get(event, "message") : void 0;
+    captureOnAll(typeof message === "string" ? message : "Script error.");
+  });
+  const onRejection = tagListener((event) => {
+    if (!event || typeof event !== "object") return;
+    const reason = "reason" in event ? Reflect.get(event, "reason") : void 0;
+    captureOnAll(reason);
+  });
+  try {
+    target.addEventListener("error", onError);
+    target.addEventListener("unhandledrejection", onRejection);
+  } catch {
+    return;
+  }
+  uninstallShared = () => {
+    try {
+      target.removeEventListener("error", onError);
+      target.removeEventListener("unhandledrejection", onRejection);
+    } catch {
+    }
+    uninstallShared = void 0;
+  };
+};
+var installBrowserHandlers = (client) => {
+  const entry = { client };
+  registered.push(entry);
+  installSharedListeners();
+  return () => {
+    const index = registered.indexOf(entry);
+    if (index >= 0) registered.splice(index, 1);
+    if (registered.length === 0) uninstallShared?.();
+  };
+};
+
+// src/map-runtime-state.ts
+var compactName = (moduleIndex, planIndex) => {
+  if (moduleIndex === void 0 || planIndex === void 0) return void 0;
+  return `${moduleIndex}.${planIndex}`;
+};
+var mapFunction = (fn) => {
+  const compact = compactName(fn.moduleIndex, fn.planIndex);
+  const definition = {
+    functionId: compact ?? fn.functionId,
+    name: fn.name || compact || fn.functionId
+  };
+  if (fn.packageRelativePath) {
+    definition.source = {
+      packageRelativePath: fn.packageRelativePath,
+      ...fn.packageName ? { packageName: fn.packageName } : {},
+      ...fn.line ? { line: fn.line } : {},
+      ...fn.column ? { column: fn.column } : {}
+    };
+  }
+  if (fn.moduleIndex !== void 0) definition.moduleIndex = fn.moduleIndex;
+  if (fn.planIndex !== void 0) definition.planIndex = fn.planIndex;
+  return definition;
+};
+var measuredDurationMs = (startedAt, endedAt) => startedAt !== void 0 && endedAt > startedAt ? endedAt - startedAt : void 0;
+var mapEvents = (events) => {
+  const enteredAt = /* @__PURE__ */ new Map();
+  const mapped = [];
+  for (const event of events) {
+    if (event.type === "function_enter") {
+      enteredAt.set(event.callId, event.timestampMs);
+      mapped.push({
+        type: "function_enter",
+        callId: event.callId,
+        functionId: event.functionId,
+        timestampMs: event.timestampMs,
+        ...event.args !== void 0 ? { args: event.args } : {},
+        ...event.argsOmitted ? { argsOmitted: true } : {},
+        ...event.parentCallId === void 0 ? {} : { parentCallId: event.parentCallId },
+        ...event.materialized === "throw-time" ? { capturedAt: "throw" } : {},
+        provenance: event.provenance
+      });
+      continue;
+    }
+    if (event.type === "function_exit") {
+      const durationMs = measuredDurationMs(enteredAt.get(event.callId), event.timestampMs);
+      mapped.push({
+        type: "function_exit",
+        callId: event.callId,
+        timestampMs: event.timestampMs,
+        ...durationMs === void 0 ? {} : { durationMs },
+        ...event.returnValue === void 0 ? {} : { returnValue: event.returnValue }
+      });
+      continue;
+    }
+    if (event.type === "function_throw") {
+      const durationMs = measuredDurationMs(enteredAt.get(event.callId), event.timestampMs);
+      mapped.push({
+        type: "function_throw",
+        callId: event.callId,
+        timestampMs: event.timestampMs,
+        ...durationMs === void 0 ? {} : { durationMs },
+        ...mapThrowError(event)
+      });
+      continue;
+    }
+    if (event.type === "function_calls_suppressed") {
+      mapped.push({
+        type: "function_calls_suppressed",
+        functionId: event.functionId,
+        timestampMs: event.timestampMs,
+        suppressedCallCount: event.suppressedCallCount,
+        ...event.parentCallId === void 0 ? {} : { parentCallId: event.parentCallId }
+      });
+      continue;
+    }
+    if (event.type === "awaited") {
+      mapped.push({
+        type: "awaited",
+        callId: event.callId,
+        timestampMs: event.timestampMs,
+        ...event.value === void 0 ? {} : { value: event.value },
+        ...event.omitted ? { omitted: true } : {}
+      });
+      continue;
+    }
+    mapped.push({
+      type: "expression_observed",
+      siteId: event.siteId,
+      timestampMs: event.timestampMs,
+      value: event.value,
+      ...event.callId === void 0 ? {} : { callId: event.callId }
+    });
+  }
+  return mapped;
+};
+var mapThrowError = (event) => {
+  if (event.error) return { error: event.error };
+  const error = {};
+  if (event.errorName !== void 0) error.name = event.errorName;
+  if (event.errorMessage !== void 0) error.message = event.errorMessage;
+  if (error.name === void 0 && error.message === void 0) return {};
+  return { error };
+};
+var mapBrowserRuntimeState = (snapshot, buildId) => {
+  const valuesOff = snapshot.captureProfile === "values-off";
+  const helpersSparse = snapshot.captureProfile === "helpers-sparse";
+  const notes = snapshot.provenanceNotes;
+  const valuesOmitted = notes.includes("value observations omitted");
+  const structuralTruncated = notes.includes("structural events truncated");
+  const holdClosed = notes.includes("closed by hold budget");
+  const openCapped = notes.includes("maximum open executions reached");
+  const boundariesPartial = structuralTruncated || holdClosed || openCapped || helpersSparse;
+  const valuesPartial = valuesOmitted || valuesOff;
+  const state = {
+    version: 4,
+    captureProfile: {
+      source: "automatic",
+      functionBoundaries: boundariesPartial ? "partial" : "full",
+      functionValues: snapshot.captureMode === "values" && !valuesOff ? valuesOmitted ? "selective" : "full" : "none",
+      timings: "partial"
+    },
+    executionId: snapshot.executionId,
+    execution: {
+      kind: snapshot.kind,
+      ...snapshot.eventType ? { name: snapshot.eventType, eventType: snapshot.eventType } : {}
+    },
+    functions: snapshot.functions.map(mapFunction),
+    events: mapEvents(snapshot.events),
+    browser: {
+      degradation: snapshot.captureProfile ?? "normal"
+    }
+  };
+  if (snapshot.startedAtIso) state.startedAt = snapshot.startedAtIso;
+  if (snapshot.durationMs > 0) state.durationMs = snapshot.durationMs;
+  if (buildId) {
+    state.buildId = buildId;
+    state.browser = {
+      ...state.browser,
+      buildId
+    };
+  }
+  if (valuesOff || helpersSparse || valuesPartial || boundariesPartial) {
+    state.capture = {
+      completeness: "partial",
+      reason: valuesOff ? "values_off" : helpersSparse ? "helpers_sparse" : holdClosed ? "long_lived_execution_budget" : openCapped ? "open_execution_budget" : valuesOmitted ? "value_observations_omitted" : "structural_events_truncated"
+    };
+  }
+  if (snapshot.historyLinks.length > 0) {
+    state.historyLinks = snapshot.historyLinks.map((link) => ({
+      executionId: link.executionId,
+      relationship: link.relationship,
+      ...link.key === void 0 ? {} : { key: link.key }
+    }));
+  }
+  if (snapshot.provenanceNotes.length > 0) state.notes = snapshot.provenanceNotes;
+  return state;
+};
+
+// src/sdk-meta.ts
+var SDK_NAME = "@rasputin-ai/browser";
+var SDK_VERSION = "0.6.0";
+
+// src/rasputin-init.ts
+var DEFAULT_API_URL = "https://api.rasputinai.dev";
+var SLOT = Symbol.for("rasputin.browser.client.v1");
+var emptyTransport = () => ({
+  queued: 0,
+  enqueued: 0,
+  droppedIncoming: 0,
+  droppedQueued: 0,
+  droppedKeepalive: 0,
+  droppedTotal: 0,
+  flushesStarted: 0,
+  sendAttempts: 0,
+  sendRetries: 0,
+  batchesSucceeded: 0,
+  batchesDropped: 0,
+  batchesFailed: 0,
+  networkErrors: 0,
+  rateLimitedResponses: 0,
+  serverErrorResponses: 0,
+  lastFailureKind: null,
+  lastFailureStatusCode: null
+});
+var emptyRecorder = (active) => ({
+  active,
+  functionCallsObserved: 0,
+  functionCallsCaptured: 0,
+  successfulExecutionsDiscarded: 0,
+  errorSnapshots: 0,
+  capturedExecutions: 0,
+  degradedExecutions: 0
+});
+var emptyInstrumentation = () => ({
+  functions: 0,
+  full: 0,
+  structure: 0,
+  skip: 0,
+  reactiveSparse: 0,
+  verificationFailed: 0
+});
+var readBuildStats = () => {
+  const value = Reflect.get(globalThis, "__RASPUTIN_BUILD_STATS__");
+  if (!value || typeof value !== "object") return emptyInstrumentation();
+  const numberAt = (key) => {
+    const item = Reflect.get(value, key);
+    return typeof item === "number" && Number.isFinite(item) ? item : 0;
+  };
+  return {
+    functions: numberAt("functions"),
+    full: numberAt("full"),
+    structure: numberAt("structure"),
+    skip: numberAt("skip"),
+    reactiveSparse: numberAt("reactiveSparse"),
+    verificationFailed: numberAt("verificationFailed")
+  };
+};
+var readGlobalString = (key) => {
+  const value = Reflect.get(globalThis, key);
+  return typeof value === "string" ? value.trim() : "";
+};
+var resolveDsn = (options) => {
+  const explicit = typeof options.dsn === "string" ? options.dsn.trim() : "";
+  if (explicit) return explicit;
+  return readGlobalString("__RASPUTIN_DSN__");
+};
+var resolveBuildId = (options) => {
+  const explicit = typeof options.buildId === "string" ? options.buildId.trim() : "";
+  if (explicit) return explicit;
+  return readGlobalString("__RASPUTIN_BUILD_ID__");
+};
+var resolveRelease = (options) => {
+  const explicit = typeof options.release === "string" ? options.release.trim() : "";
+  if (explicit) return explicit;
+  return readGlobalString("__RASPUTIN_RELEASE__");
+};
+var resolveEnvironment = (options) => {
+  const explicit = typeof options.environment === "string" ? options.environment.trim() : "";
+  if (explicit) return explicit;
+  return readGlobalString("__RASPUTIN_ENVIRONMENT__");
+};
+var activationReason = (options, dsn, release, environment) => {
+  if (options.enabled === false) return "disabled";
+  if (!dsn) return "missing_dsn";
+  if (!parseDsn(dsn)) return "invalid_dsn";
+  if (!release) return "missing_release";
+  if (!environment) return "missing_environment";
+  const windowRef = Reflect.get(globalThis, "window");
+  const fetchRef = Reflect.get(globalThis, "fetch");
+  if (typeof fetchRef !== "function" && !(windowRef && typeof windowRef === "object")) {
+    if (!options.fetch) return "unsupported_environment";
+  }
+  return "ok";
+};
+var inertClient = (configuration) => ({
+  captureException: () => {
+  },
+  flush: async () => {
+  },
+  close: async () => {
+  },
+  getStats: () => ({
+    enabled: false,
+    release: configuration.release,
+    buildId: configuration.buildId,
+    transport: emptyTransport(),
+    recorder: emptyRecorder(false),
+    instrumentation: emptyInstrumentation()
+  }),
+  verifyConfiguration: () => configuration
+});
+var recorderStats = () => {
+  const state = getBrowserRuntimeState();
+  return {
+    active: true,
+    functionCallsObserved: state.stats.functionCallsObserved,
+    functionCallsCaptured: state.stats.functionCallsCaptured,
+    successfulExecutionsDiscarded: state.stats.successfulExecutionsDiscarded,
+    errorSnapshots: state.stats.errorSnapshots,
+    capturedExecutions: state.stats.errorSnapshots,
+    degradedExecutions: state.snapshots.filter(
+      (snapshot) => snapshot.captureProfile === "values-off" || snapshot.captureProfile === "helpers-sparse"
+    ).length
+  };
+};
+var getSlot = () => {
+  const value = Reflect.get(globalThis, SLOT);
+  if (!value || typeof value !== "object") return void 0;
+  if (!("refs" in value) || !("client" in value)) return void 0;
+  return value;
+};
+var setSlot = (slot) => {
+  if (slot) Reflect.set(globalThis, SLOT, slot);
+  else Reflect.deleteProperty(globalThis, SLOT);
+};
+var RasputinInit = (options) => {
+  try {
+    const existing = getSlot();
+    if (existing) {
+      existing.refs += 1;
+      return existing.client;
+    }
+    const internal = options ?? {};
+    const dsn = resolveDsn(internal);
+    const parsed = parseDsn(dsn);
+    const buildId = resolveBuildId(internal);
+    const release = resolveRelease(internal);
+    const environment = resolveEnvironment(internal);
+    const reason = activationReason(internal, dsn, release, environment);
+    const configuration = {
+      enabled: reason === "ok",
+      reason,
+      recorder: reason === "ok" ? "active" : "inert",
+      handlersInstalled: false,
+      ingestEnabled: false,
+      release: release || null,
+      buildId: buildId || null,
+      buildIdentity: buildId ? "injected" : "missing",
+      environment: environment || null
+    };
+    if (reason !== "ok" || !parsed) {
+      return inertClient(configuration);
+    }
+    const ingestEnabled = internal.ingest !== false && !isLocalDsnPublicKey(parsed.publicKey);
+    const apiUrl = (internal.apiUrl ?? parsed.apiUrl ?? DEFAULT_API_URL).replace(/\/+$/, "");
+    RasputinBrowserInit({
+      settlingMs: 80,
+      holdMs: 3e4,
+      maxStructuralEvents: 240,
+      maxValueEvents: 80,
+      maxCapturedCallsPerFunction: 3,
+      maxOpenExecutions: 32,
+      ...internal.identities ? { identities: internal.identities } : {}
+    });
+    const suppression = createSuppression({ capPerWindow: 1 });
+    let enqueuePendingSummaries = () => {
+    };
+    const transport = createBrowserTransport({
+      ingestUrl: `${apiUrl}/ingest`,
+      publicKey: parsed.publicKey,
+      sdkName: SDK_NAME,
+      sdkVersion: SDK_VERSION,
+      enabled: ingestEnabled,
+      fetch: internal.fetch,
+      beforeFlush: () => enqueuePendingSummaries()
+    });
+    enqueuePendingSummaries = () => {
+      for (const { summary } of suppression.drainSummaries()) {
+        transport.enqueueSummary(summary);
+      }
+    };
+    const captureException = (error) => {
+      try {
+        if (!shouldCaptureBrowserError(error)) return;
+        const frames = framesFromError(error);
+        const event = createBrowserIngestEvent({
+          error,
+          frames,
+          environment,
+          release
+        });
+        const decision = suppression.decide({
+          errorType: event.type,
+          message: event.message,
+          frames,
+          origin: "client",
+          code: event.code,
+          environment,
+          release
+        });
+        if (decision.action !== "send") return;
+        const snapshot = getBrowserErrorState(error);
+        if (snapshot) {
+          event.runtime_state = mapBrowserRuntimeState(snapshot, buildId || void 0);
+        }
+        if (ingestEnabled) transport.enqueue(event);
+      } catch {
+      }
+    };
+    let uninstallHandlers = () => {
+    };
+    if (internal.installGlobalHandlers !== false) {
+      uninstallHandlers = installBrowserHandlers({ captureException });
+      configuration.handlersInstalled = true;
+    }
+    configuration.ingestEnabled = ingestEnabled;
+    const client = {
+      captureException,
+      flush: async (timeoutMs) => {
+        await transport.flush(timeoutMs);
+      },
+      close: async () => {
+        const slot = getSlot();
+        if (slot && slot.client === client) {
+          slot.refs -= 1;
+          if (slot.refs > 0) return;
+          setSlot(void 0);
+        }
+        uninstallHandlers();
+        uninstallBrowserRuntime();
+        await transport.close();
+      },
+      getStats: () => ({
+        enabled: true,
+        release: release || null,
+        buildId: buildId || null,
+        transport: transport.getStats(),
+        recorder: recorderStats(),
+        instrumentation: readBuildStats()
+      }),
+      verifyConfiguration: () => configuration
+    };
+    setSlot({ refs: 1, client });
+    if (internal.logSuccess !== false) {
+      console.info("[rasputin] browser SDK ready", {
+        environment,
+        release: release || null,
+        buildId: buildId || null,
+        ingest: ingestEnabled
+      });
+    }
+    return client;
+  } catch {
+    return inertClient({
+      enabled: false,
+      reason: "unsupported_environment",
+      recorder: "inert",
+      handlersInstalled: false,
+      ingestEnabled: false,
+      release: null,
+      buildId: null,
+      buildIdentity: "missing",
+      environment: null
+    });
+  }
+};
+export {
+  RasputinInit
+};