@rasputin-ai/core 0.5.0-alpha.1 → 0.5.0-alpha.11

package/dist/index.js

@@ -659,7 +659,7 @@ var resolveSourceMaps = async (frames) => {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/core";
-var SDK_VERSION = "0.5.0-alpha.1";
+var SDK_VERSION = "0.5.0-alpha.11";
 
 // src/suppression/identity-needs-message-template.ts
 var identityNeedsMessageTemplate = (type, code) => {
@@ -979,6 +979,21 @@ var sendBatch = async (options) => {
   if (options.sdkVersion) payload.sdk_version = options.sdkVersion;
   if (options.sdkName) payload.sdk_name = options.sdkName;
   if (options.idempotencyKey) payload.idempotency_key = options.idempotencyKey;
+  let attempts = 0;
+  let networkErrors = 0;
+  let rateLimitedResponses = 0;
+  let serverErrorResponses = 0;
+  const result = (outcome, failureKind = null, statusCode = null) => ({
+    outcome,
+    attempts,
+    retries: Math.max(0, attempts - 1),
+    networkErrors,
+    rateLimitedResponses,
+    serverErrorResponses,
+    aborted: failureKind === "aborted",
+    failureKind,
+    statusCode
+  });
   const json = JSON.stringify(payload);
   const headers = {
     Authorization: `Bearer ${options.projectApiKey}`,
@@ -994,31 +1009,38 @@ var sendBatch = async (options) => {
     headers["Content-Encoding"] = "gzip";
   }
   for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
-    if (options.signal?.aborted) return "failed";
+    if (options.signal?.aborted) return result("failed", "aborted");
     try {
+      attempts++;
       const response = await options.fetch(options.ingestUrl, {
         method: "POST",
         headers,
         body,
         signal: options.signal
       });
-      if (response.ok) return "ok";
+      if (response.ok) return result("ok");
       if (response.status === 429) {
-        if (attempt === options.maxRetries) return "failed";
+        rateLimitedResponses++;
+        if (attempt === options.maxRetries)
+          return result("failed", "rate_limited", response.status);
         const wait = retryAfterMs(response) ?? backoffMs(attempt);
         await sleep(wait, options.signal);
         continue;
       }
-      if (response.status >= 400 && response.status < 500) return "dropped";
-      if (attempt === options.maxRetries) return "failed";
+      if (response.status >= 400 && response.status < 500) {
+        return result("dropped", "non_retryable_http", response.status);
+      }
+      serverErrorResponses++;
+      if (attempt === options.maxRetries) return result("failed", "server_error", response.status);
       await sleep(backoffMs(attempt), options.signal);
     } catch {
-      if (options.signal?.aborted) return "failed";
-      if (attempt === options.maxRetries) return "failed";
+      if (options.signal?.aborted) return result("failed", "aborted");
+      networkErrors++;
+      if (attempt === options.maxRetries) return result("failed", "network_error");
       await sleep(backoffMs(attempt), options.signal);
     }
   }
-  return "failed";
+  return result("failed", options.signal?.aborted ? "aborted" : "network_error");
 };
 
 // src/transport/transport-queue.ts
@@ -1112,6 +1134,20 @@ var createTransport = (options) => {
   let closed = false;
   let shuttingDown = false;
   let retryBatch = null;
+  let flushesStarted = 0;
+  let flushesJoined = 0;
+  let sendAttempts = 0;
+  let sendRetries = 0;
+  let batchReplays = 0;
+  let batchesSucceeded = 0;
+  let batchesDropped = 0;
+  let batchesFailed = 0;
+  let flushTimeouts = 0;
+  let networkErrors = 0;
+  let rateLimitedResponses = 0;
+  let serverErrorResponses = 0;
+  let lastFailureKind = null;
+  let lastFailureStatusCode = null;
   const schedule = () => {
     if (timer || !enabled || closed) return;
     timer = setInterval(() => {
@@ -1133,70 +1169,94 @@ var createTransport = (options) => {
       return item.summary;
     }
   };
+  const performFlush = async (timeoutMs) => {
+    const controller = new AbortController();
+    const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
+    try {
+      while (queue.size() > 0 || retryBatch) {
+        if (controller.signal.aborted) break;
+        const replaying = retryBatch !== null;
+        const batch = retryBatch?.items ?? queue.drain(batchSize);
+        const idempotencyKey = retryBatch?.idempotencyKey ?? crypto.randomUUID();
+        retryBatch = null;
+        if (batch.length === 0) break;
+        if (replaying) batchReplays++;
+        const events = [];
+        const summaries = [];
+        for (const item of batch) {
+          if (item.kind === "summary") {
+            summaries.push(await prepareSummary(item));
+            continue;
+          }
+          if (options.prepareEvent && item.rawFrames.length > 0) {
+            try {
+              events.push(
+                await options.prepareEvent({
+                  event: item.event,
+                  rawFrames: item.rawFrames
+                })
+              );
+            } catch {
+              events.push(item.event);
+            }
+          } else {
+            events.push(item.event);
+          }
+        }
+        const result = await sendBatch({
+          ingestUrl: options.ingestUrl,
+          projectApiKey: options.projectApiKey,
+          events,
+          summaries,
+          idempotencyKey,
+          sdkVersion: options.sdkVersion,
+          sdkName: options.sdkName,
+          gzipThresholdBytes,
+          maxRetries,
+          fetch: fetchFn,
+          signal: controller.signal
+        });
+        sendAttempts += result.attempts;
+        sendRetries += result.retries;
+        networkErrors += result.networkErrors;
+        rateLimitedResponses += result.rateLimitedResponses;
+        serverErrorResponses += result.serverErrorResponses;
+        if (result.aborted) flushTimeouts++;
+        if (result.outcome === "ok") batchesSucceeded++;
+        else {
+          lastFailureKind = result.failureKind;
+          lastFailureStatusCode = result.statusCode;
+          if (result.outcome === "dropped") batchesDropped++;
+          else batchesFailed++;
+        }
+        if (result.outcome === "failed") {
+          retryBatch = { items: batch, idempotencyKey };
+          break;
+        }
+      }
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      if (queue.size() === 0 && !retryBatch) stopTimer();
+    }
+  };
   const flush = async (timeoutMs = 1e4) => {
     if (!enabled || closed) {
       queue.clear();
       retryBatch = null;
       return;
     }
-    if (flushing) return flushing;
-    flushing = (async () => {
-      const controller = new AbortController();
-      const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
-      try {
-        while (queue.size() > 0 || retryBatch) {
-          if (controller.signal.aborted) break;
-          const batch = retryBatch?.items ?? queue.drain(batchSize);
-          const idempotencyKey = retryBatch?.idempotencyKey ?? crypto.randomUUID();
-          retryBatch = null;
-          if (batch.length === 0) break;
-          const events = [];
-          const summaries = [];
-          for (const item of batch) {
-            if (item.kind === "summary") {
-              summaries.push(await prepareSummary(item));
-              continue;
-            }
-            if (options.prepareEvent && item.rawFrames.length > 0) {
-              try {
-                events.push(
-                  await options.prepareEvent({
-                    event: item.event,
-                    rawFrames: item.rawFrames
-                  })
-                );
-              } catch {
-                events.push(item.event);
-              }
-            } else {
-              events.push(item.event);
-            }
-          }
-          const result = await sendBatch({
-            ingestUrl: options.ingestUrl,
-            projectApiKey: options.projectApiKey,
-            events,
-            summaries,
-            idempotencyKey,
-            sdkVersion: options.sdkVersion,
-            sdkName: options.sdkName,
-            gzipThresholdBytes,
-            maxRetries,
-            fetch: fetchFn,
-            signal: controller.signal
-          });
-          if (result === "failed") {
-            retryBatch = { items: batch, idempotencyKey };
-            break;
-          }
-        }
-      } finally {
-        if (timeout) clearTimeout(timeout);
-        if (queue.size() === 0 && !retryBatch) stopTimer();
-        flushing = void 0;
-      }
-    })();
-    return flushing;
+    if (flushing) {
+      flushesJoined++;
+      return flushing;
+    }
+    flushesStarted++;
+    const activeFlush = performFlush(timeoutMs);
+    flushing = activeFlush;
+    try {
+      await activeFlush;
+    } finally {
+      if (flushing === activeFlush) flushing = void 0;
+    }
   };
   const enqueue = (event, priority = "first", rawFrames = []) => {
     if (!enabled || closed) return;
@@ -1248,7 +1308,21 @@ var createTransport = (options) => {
       const queueStats = queue.getStats();
       return {
         ...queueStats,
-        queued: queueStats.queued + (retryBatch?.items.length ?? 0)
+        queued: queueStats.queued + (retryBatch?.items.length ?? 0),
+        flushesStarted,
+        flushesJoined,
+        sendAttempts,
+        sendRetries,
+        batchReplays,
+        batchesSucceeded,
+        batchesDropped,
+        batchesFailed,
+        flushTimeouts,
+        networkErrors,
+        rateLimitedResponses,
+        serverErrorResponses,
+        lastFailureKind,
+        lastFailureStatusCode
       };
     }
   };
@@ -1269,7 +1343,21 @@ var noopClient = () => ({
       enqueued: 0,
       droppedIncoming: 0,
       droppedQueued: 0,
-      droppedTotal: 0
+      droppedTotal: 0,
+      flushesStarted: 0,
+      flushesJoined: 0,
+      sendAttempts: 0,
+      sendRetries: 0,
+      batchReplays: 0,
+      batchesSucceeded: 0,
+      batchesDropped: 0,
+      batchesFailed: 0,
+      flushTimeouts: 0,
+      networkErrors: 0,
+      rateLimitedResponses: 0,
+      serverErrorResponses: 0,
+      lastFailureKind: null,
+      lastFailureStatusCode: null
     }
   })
 });
@@ -1442,8 +1530,1063 @@ var createClient = (options, hooks = {}) => {
   }
 };
 
+// src/derivation/rasputin-wire-tag.ts
+var RASPUTIN_WIRE_TAG = "\0rasputin";
+var rasputinUnknown = () => [RASPUTIN_WIRE_TAG, "unknown"];
+var rasputinUnavailable = (reason) => [
+  RASPUTIN_WIRE_TAG,
+  "unavailable",
+  reason
+];
+var rasputinOmitted = () => [RASPUTIN_WIRE_TAG, "omitted"];
+var rasputinRedacted = () => [RASPUTIN_WIRE_TAG, "redacted"];
+var rasputinTruncated = (payload) => [
+  RASPUTIN_WIRE_TAG,
+  "truncated",
+  payload
+];
+var isRasputinTaggedValue = (value) => {
+  if (!Array.isArray(value) || value.length < 2 || value[0] !== RASPUTIN_WIRE_TAG) return false;
+  const kind = value[1];
+  return kind === "unknown" || kind === "unavailable" || kind === "omitted" || kind === "redacted" || kind === "truncated";
+};
+var rasputinTagKind = (value) => isRasputinTaggedValue(value) ? value[1] : void 0;
+
+// src/derivation/captured-value-markers.ts
+var REDACTED = "[RASPUTIN_REDACTED]";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var capturedValueCompleteness = (value) => {
+  if (value === REDACTED) return "partial";
+  const tagged = rasputinTagKind(value);
+  if (tagged === "unknown" || tagged === "truncated" || tagged === "unavailable" || tagged === "omitted") {
+    return "partial";
+  }
+  if (tagged === "redacted") return "partial";
+  if (isRasputinTaggedValue(value)) return "partial";
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (capturedValueCompleteness(item) === "partial") return "partial";
+    }
+    return "exact";
+  }
+  if (!isRecord(value)) return "exact";
+  if (value.__rasputin_truncated === true) return "partial";
+  if (value.__rasputin_type === "omitted" || value.__rasputin_type === "accessor") return "partial";
+  if (value.__rasputin_type === "unserializable") return "partial";
+  for (const key of Object.keys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || descriptor.get || descriptor.set) return "partial";
+    if (capturedValueCompleteness(descriptor.value) === "partial") return "partial";
+  }
+  return "exact";
+};
+var isRedactedCapturedValue = (value) => {
+  if (value === REDACTED) return true;
+  if (rasputinTagKind(value) === "redacted") return true;
+  if (isRecord(value) && value.__rasputin_type === "omitted") return true;
+  return false;
+};
+var isSerializerMarker = (value) => {
+  if (isRasputinTaggedValue(value)) return true;
+  if (!isRecord(value)) return false;
+  return value.__rasputin_truncated === true || typeof value.__rasputin_type === "string";
+};
+
+// src/derivation/canonical-json.ts
+var sortedKeys = (value) => Object.keys(value).sort();
+var canonicalJson = (value) => {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (!Number.isFinite(value)) return "null";
+      if (Object.is(value, -0)) return "0";
+      return String(value);
+    case "string":
+      return JSON.stringify(value);
+    case "undefined":
+      return "null";
+    default:
+      break;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const record = value;
+    const fields = sortedKeys(record).filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`);
+    return `{${fields.join(",")}}`;
+  }
+  return "null";
+};
+
+// src/derivation/sha256.ts
+var K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+var rotr = (value, bits) => value >>> bits | value << 32 - bits;
+var sha256Hex = (input) => {
+  const encoded = new TextEncoder().encode(input);
+  const bitLen = encoded.length * 8;
+  const paddedLen = encoded.length + 9 + 63 >> 6 << 6 >>> 0;
+  const bytes = new Uint8Array(paddedLen);
+  bytes.set(encoded);
+  bytes[encoded.length] = 128;
+  const view = new DataView(bytes.buffer);
+  view.setUint32(paddedLen - 4, bitLen, false);
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLen; offset += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4, false);
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + S1 + ch + K[i] + w[i] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((word) => word.toString(16).padStart(8, "0")).join("");
+};
+
+// src/derivation/hash-instrumentation-manifest.ts
+var hashableSource = (source) => {
+  const { repositoryPath: _repositoryPath, ...rest } = source;
+  return rest;
+};
+var hashableLocated = (items) => items.map((item) => ({ ...item, source: hashableSource(item.source) }));
+var hashInstrumentationManifest = (manifest) => {
+  return sha256Hex(
+    canonicalJson({
+      schema_version: manifest.schema_version,
+      functions: hashableLocated(manifest.functions),
+      callSites: hashableLocated(manifest.callSites),
+      destructures: hashableLocated(manifest.destructures),
+      derivationPlans: manifest.derivationPlans ?? []
+    })
+  );
+};
+
+// src/derivation/wire-values-equal.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var arraysEqual = (left, right) => {
+  if (left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index++) {
+    if (Object.hasOwn(left, index) !== Object.hasOwn(right, index)) return false;
+    if (!wireValuesEqual(left[index], right[index])) return false;
+  }
+  return true;
+};
+var wireValuesEqual = (left, right) => {
+  if (Object.is(left, right)) return true;
+  if (typeof left === "bigint" && typeof right === "bigint") return left === right;
+  if (isRasputinTaggedValue(left) || isRasputinTaggedValue(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) return false;
+    return arraysEqual(left, right);
+  }
+  if (Array.isArray(left) && Array.isArray(right)) return arraysEqual(left, right);
+  if (!isRecord2(left) || !isRecord2(right)) return false;
+  const leftKeys = Object.keys(left).sort();
+  const rightKeys = Object.keys(right).sort();
+  if (leftKeys.length !== rightKeys.length) return false;
+  return leftKeys.every((key, index) => {
+    if (key !== rightKeys[index]) return false;
+    const leftDesc = Object.getOwnPropertyDescriptor(left, key);
+    const rightDesc = Object.getOwnPropertyDescriptor(right, key);
+    if (!leftDesc || !rightDesc) return false;
+    if (leftDesc.get || leftDesc.set || rightDesc.get || rightDesc.set) return false;
+    return wireValuesEqual(leftDesc.value, rightDesc.value);
+  });
+};
+
+// src/derivation/evaluate-derivation-plan.ts
+var MAX_INSTRUCTIONS = 1e4;
+var MAX_DEPTH = 64;
+var MAX_OUTPUT_BYTES = 256 * 1024;
+var MAX_WALL_MS = 50;
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var primitiveFromConst = (value) => {
+  switch (value.type) {
+    case "null":
+      return null;
+    case "undefined":
+      return void 0;
+    case "boolean":
+      return value.value;
+    case "number":
+      return value.negativeZero ? -0 : value.value;
+    case "string":
+      return value.value;
+    case "bigint":
+      try {
+        return BigInt(value.value);
+      } catch {
+        return rasputinUnavailable("invalid_bigint_const");
+      }
+  }
+};
+var estimateBytes = (value, depth = 0) => {
+  if (value === null || value === void 0) return 4;
+  switch (typeof value) {
+    case "boolean":
+      return 4;
+    case "number":
+      return 8;
+    case "string":
+      return value.length;
+    case "bigint":
+      return value.toString().length;
+    case "object": {
+      if (depth > 8) return 8;
+      if (Array.isArray(value)) {
+        let total2 = 2;
+        for (const item of value) total2 += estimateBytes(item, depth + 1);
+        return total2;
+      }
+      let total = 2;
+      for (const key of Object.keys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || descriptor.get || descriptor.set) {
+          total += key.length + 8;
+          continue;
+        }
+        total += key.length + estimateBytes(descriptor.value, depth + 1);
+      }
+      return total;
+    }
+    default:
+      return 8;
+  }
+};
+var capturedFromWire = (value) => {
+  if (rasputinTagKind(value) === "omitted") {
+    return { origin: "unavailable", reason: "omitted_value" };
+  }
+  if (isRedactedCapturedValue(value)) {
+    return { origin: "captured", completeness: "partial", value: rasputinRedacted() };
+  }
+  return { origin: "captured", completeness: capturedValueCompleteness(value), value };
+};
+var checkpointRank = (value) => {
+  if (!value || value.origin === "unavailable") return 5;
+  if (value.origin === "captured" && value.completeness === "exact") return 1;
+  if (value.origin === "derived" && value.completeness === "exact") return 2;
+  if (value.origin === "captured") return 3;
+  return 4;
+};
+var resolveCheckpoint = (captured, derived, expressionId) => {
+  const capturedRank = checkpointRank(captured);
+  const derivedRank = checkpointRank(derived);
+  if (capturedRank === 1 && derivedRank === 2 && captured?.origin === "captured" && derived?.origin === "derived") {
+    if (!wireValuesEqual(captured.value, derived.value)) {
+      return {
+        origin: "captured",
+        completeness: "exact",
+        value: captured.value,
+        derivationValidation: {
+          status: "mismatch",
+          derivedValue: derived.value,
+          expressionId,
+          dependencies: derived.dependencies
+        }
+      };
+    }
+    return {
+      origin: "captured",
+      completeness: "exact",
+      value: captured.value,
+      derivationValidation: { status: "verified" }
+    };
+  }
+  if (capturedRank <= derivedRank) {
+    return captured ?? derived ?? { origin: "unavailable", reason: "no_checkpoint" };
+  }
+  return derived ?? { origin: "unavailable", reason: "no_checkpoint" };
+};
+var exactOperandsOrUnavailable = (parts) => {
+  const completeness = mergeCompleteness(parts);
+  if (completeness === "unavailable")
+    return { origin: "unavailable", reason: "partial_dependency" };
+  if (completeness === "partial") return { origin: "unavailable", reason: "partial_operand" };
+  return void 0;
+};
+var capturedResult = (root) => {
+  if (isRedactedCapturedValue(root.value)) {
+    return { origin: "captured", completeness: "partial", value: rasputinRedacted() };
+  }
+  const completeness = root.completeness === "partial" ? "partial" : capturedValueCompleteness(root.value);
+  return { origin: "captured", completeness, value: root.value };
+};
+var mergeCompleteness = (parts) => {
+  let partial = false;
+  for (const part of parts) {
+    if (part.origin === "unavailable") return "unavailable";
+    if (part.completeness === "partial") partial = true;
+  }
+  return partial ? "partial" : "exact";
+};
+var unwrapExactPrimitive = (result) => {
+  if (result.origin === "unavailable") return rasputinUnavailable(result.reason);
+  return result.value;
+};
+var isNumericPrimitive = (value) => typeof value === "number" && !isRasputinTaggedValue(value);
+var isPrimitiveOperand = (value) => {
+  if (isRasputinTaggedValue(value)) return false;
+  return value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string" || typeof value === "bigint" || typeof value === "undefined";
+};
+var omittedCallKey = (parentCallId, functionId) => `${parentCallId}\0${functionId}`;
+var argsIncludeOmitted = (args) => args.some((arg) => rasputinTagKind(arg) === "omitted");
+var recordReconstructedCallArgs = (queue, parentCallId, functionId, args) => {
+  const key = omittedCallKey(parentCallId, functionId);
+  const pending = queue.get(key);
+  if (pending) pending.push(args);
+  else queue.set(key, [args]);
+};
+var takeReconstructedCallArgs = (queue, parentCallId, functionId) => {
+  if (parentCallId == null) return void 0;
+  const pending = queue.get(omittedCallKey(parentCallId, functionId));
+  if (!pending || pending.length === 0) return void 0;
+  return pending.shift();
+};
+var resolveEnterArgs = (enter, queue) => {
+  if (!argsIncludeOmitted(enter.args)) return enter.args;
+  return takeReconstructedCallArgs(queue, enter.parentCallId, enter.functionId) ?? enter.args;
+};
+var takeChildCapturedReturn = (state, calleeFunctionId) => {
+  if (state.recordingCallId == null) return void 0;
+  const children = (state.childrenByParent.get(state.recordingCallId) ?? []).filter(
+    (child2) => child2.functionId === calleeFunctionId
+  );
+  const key = omittedCallKey(state.recordingCallId, calleeFunctionId);
+  const index = state.childCursor.get(key) ?? 0;
+  state.childCursor.set(key, index + 1);
+  const child = children[index];
+  if (!child) return void 0;
+  if (state.throwCallIds.has(child.callId)) return { threw: true };
+  return state.exitByCallId.get(child.callId);
+};
+var readOwnDataProperty = (object, key) => {
+  const descriptor = Object.getOwnPropertyDescriptor(object, key);
+  if (!descriptor) return { ok: false, reason: "missing_property" };
+  if (descriptor.get !== void 0 || descriptor.set !== void 0) {
+    return { ok: false, reason: "accessor_property" };
+  }
+  return { ok: true, value: descriptor.value };
+};
+var budgetExceeded = (state) => {
+  if (state.instructions > MAX_INSTRUCTIONS) return "instruction_budget";
+  if (state.depth > MAX_DEPTH) return "depth_budget";
+  if (state.outputBytes > MAX_OUTPUT_BYTES) return "output_size_budget";
+  if (Date.now() - state.startedAt > MAX_WALL_MS) return "wall_time_budget";
+  return void 0;
+};
+var evaluateExpression = (expressionId, plan, byId, cells, args, rootsById, factsById, calleeReturns, state, evaluateCallee) => {
+  const over = budgetExceeded(state);
+  if (over) return { origin: "unavailable", reason: over };
+  state.instructions++;
+  state.depth++;
+  try {
+    const existing = cells.get(expressionId);
+    if (existing?.status === "done") return existing.result;
+    if (existing?.status === "pending") {
+      return { origin: "unavailable", reason: "cyclic_expression" };
+    }
+    const expression = byId.get(expressionId);
+    if (!expression) return { origin: "unavailable", reason: "missing_expression" };
+    cells.set(expressionId, { status: "pending" });
+    const evalChild = (id) => evaluateExpression(
+      id,
+      plan,
+      byId,
+      cells,
+      args,
+      rootsById,
+      factsById,
+      calleeReturns,
+      state,
+      evaluateCallee
+    );
+    let result;
+    switch (expression.kind) {
+      case "const": {
+        const value = primitiveFromConst(expression.value);
+        result = { origin: "derived", completeness: "exact", value, dependencies: [] };
+        break;
+      }
+      case "param": {
+        if (expression.index < 0 || expression.index >= args.length) {
+          result = { origin: "unavailable", reason: "missing_argument" };
+          break;
+        }
+        const value = args[expression.index];
+        if (rasputinTagKind(value) === "omitted") {
+          result = { origin: "unavailable", reason: "omitted_argument" };
+          break;
+        }
+        result = capturedFromWire(value);
+        break;
+      }
+      case "root": {
+        const root = rootsById.get(expression.rootId);
+        if (!root) {
+          result = { origin: "unavailable", reason: "missing_root" };
+          break;
+        }
+        result = capturedResult(root);
+        break;
+      }
+      case "alias":
+        result = evalChild(expression.from);
+        break;
+      case "binary": {
+        const left = evalChild(expression.left);
+        const right = evalChild(expression.right);
+        const blocked = exactOperandsOrUnavailable([left, right]);
+        if (blocked) {
+          result = blocked;
+          break;
+        }
+        const leftValue = unwrapExactPrimitive(left);
+        const rightValue = unwrapExactPrimitive(right);
+        if (rasputinTagKind(leftValue) || rasputinTagKind(rightValue)) {
+          result = { origin: "unavailable", reason: "tagged_operand" };
+          break;
+        }
+        if (isRedactedCapturedValue(leftValue) || isRedactedCapturedValue(rightValue)) {
+          result = { origin: "unavailable", reason: "redacted_operand" };
+          break;
+        }
+        if (expression.guard === "numeric") {
+          if (!isNumericPrimitive(leftValue) || !isNumericPrimitive(rightValue)) {
+            result = { origin: "unavailable", reason: "numeric_guard_failed" };
+            break;
+          }
+        } else if (expression.guard === "primitive") {
+          if (!isPrimitiveOperand(leftValue) || !isPrimitiveOperand(rightValue)) {
+            result = { origin: "unavailable", reason: "primitive_guard_failed" };
+            break;
+          }
+        }
+        const value = applyBinary(expression.op, leftValue, rightValue);
+        if (value === void 0) {
+          result = { origin: "unavailable", reason: "unsupported_binary" };
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness: "exact",
+          value,
+          dependencies: [expression.left, expression.right]
+        };
+        break;
+      }
+      case "unary": {
+        const operand = evalChild(expression.operand);
+        const blocked = exactOperandsOrUnavailable([operand]);
+        if (blocked || operand.origin === "unavailable") {
+          result = blocked ?? operand;
+          break;
+        }
+        const raw = operand.value;
+        if (isRedactedCapturedValue(raw) || rasputinTagKind(raw)) {
+          result = { origin: "unavailable", reason: "tagged_operand" };
+          break;
+        }
+        if (expression.op === "typeof") {
+          result = {
+            origin: "derived",
+            completeness: "exact",
+            value: typeof raw,
+            dependencies: [expression.operand]
+          };
+          break;
+        }
+        if (expression.op === "not") {
+          result = {
+            origin: "derived",
+            completeness: "exact",
+            value: !raw,
+            dependencies: [expression.operand]
+          };
+          break;
+        }
+        if (!isNumericPrimitive(raw)) {
+          result = { origin: "unavailable", reason: "numeric_guard_failed" };
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness: "exact",
+          value: expression.op === "minus" ? -raw : +raw,
+          dependencies: [expression.operand]
+        };
+        break;
+      }
+      case "logical": {
+        const left = evalChild(expression.left);
+        const leftBlocked = exactOperandsOrUnavailable([left]);
+        if (leftBlocked || left.origin === "unavailable") {
+          result = leftBlocked ?? left;
+          break;
+        }
+        const takeRight = expression.op === "and" ? Boolean(left.value) : expression.op === "or" ? !left.value : left.value == null;
+        if (!takeRight) {
+          result = left.origin === "derived" ? left : {
+            origin: "derived",
+            completeness: "exact",
+            value: left.value,
+            dependencies: [expression.left]
+          };
+          break;
+        }
+        const right = evalChild(expression.right);
+        const blocked = exactOperandsOrUnavailable([left, right]);
+        if (blocked || right.origin === "unavailable") {
+          result = blocked ?? right;
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness: "exact",
+          value: right.value,
+          dependencies: [expression.left, expression.right]
+        };
+        break;
+      }
+      case "cond": {
+        const test = evalChild(expression.test);
+        const testBlocked = exactOperandsOrUnavailable([test]);
+        if (testBlocked || test.origin === "unavailable") {
+          result = testBlocked ?? test;
+          break;
+        }
+        const fact = [...factsById.values()].find(
+          (entry) => plan.controlFacts.some((definition) => definition.id === entry.factId)
+        );
+        const takeConsequent = fact ? fact.value : Boolean(test.value);
+        const branch = evalChild(takeConsequent ? expression.consequent : expression.alternate);
+        const blocked = exactOperandsOrUnavailable([test, branch]);
+        if (blocked || branch.origin === "unavailable") {
+          result = blocked ?? branch;
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness: "exact",
+          value: branch.value,
+          dependencies: [
+            expression.test,
+            takeConsequent ? expression.consequent : expression.alternate
+          ]
+        };
+        break;
+      }
+      case "template": {
+        const parts = [];
+        let text = "";
+        let failed;
+        for (const part of expression.parts) {
+          if (part.kind === "lit") {
+            text += part.value;
+            continue;
+          }
+          const nested = evalChild(part.expressionId);
+          parts.push(nested);
+          if (nested.origin === "unavailable") {
+            failed = nested;
+            break;
+          }
+          if (!isPrimitiveOperand(nested.value) || isRasputinTaggedValue(nested.value)) {
+            failed = { origin: "unavailable", reason: "template_non_primitive" };
+            break;
+          }
+          text += String(nested.value);
+        }
+        if (failed) {
+          result = failed;
+          break;
+        }
+        const completeness = parts.length === 0 ? "exact" : mergeCompleteness(parts);
+        if (completeness === "unavailable") {
+          result = { origin: "unavailable", reason: "partial_dependency" };
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness,
+          value: text,
+          dependencies: expression.parts.flatMap(
+            (part) => part.kind === "expr" ? [part.expressionId] : []
+          )
+        };
+        break;
+      }
+      case "object": {
+        const record = {};
+        const parts = [];
+        let failed;
+        for (const property of expression.properties) {
+          const nested = evalChild(property.value);
+          parts.push(nested);
+          if (nested.origin === "unavailable") {
+            failed = nested;
+            break;
+          }
+          record[property.key] = nested.value;
+        }
+        if (failed) {
+          result = failed;
+          break;
+        }
+        const completeness = mergeCompleteness(parts);
+        if (completeness === "unavailable") {
+          result = { origin: "unavailable", reason: "partial_dependency" };
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness,
+          value: record,
+          dependencies: expression.properties.map((property) => property.value)
+        };
+        break;
+      }
+      case "array": {
+        const items = [];
+        const parts = [];
+        let failed;
+        let unknownCount = 0;
+        for (const element of expression.elements) {
+          if (typeof element !== "number") {
+            items.push(rasputinUnknown());
+            unknownCount++;
+            continue;
+          }
+          const nested = evalChild(element);
+          parts.push(nested);
+          if (nested.origin === "unavailable") {
+            failed = nested;
+            break;
+          }
+          items.push(nested.value);
+        }
+        if (failed) {
+          result = failed;
+          break;
+        }
+        const completeness = unknownCount > 0 ? "partial" : parts.length === 0 ? "exact" : mergeCompleteness(parts);
+        if (completeness === "unavailable") {
+          result = { origin: "unavailable", reason: "partial_dependency" };
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness,
+          value: items,
+          dependencies: expression.elements.flatMap(
+            (element) => typeof element === "number" ? [element] : []
+          )
+        };
+        break;
+      }
+      case "prop": {
+        const object = evalChild(expression.object);
+        if (object.origin === "unavailable") {
+          result = object;
+          break;
+        }
+        if (isRedactedCapturedValue(object.value)) {
+          result = { origin: "unavailable", reason: "redacted_operand" };
+          break;
+        }
+        if (!isRecord3(object.value) || rasputinTagKind(object.value)) {
+          result = { origin: "unavailable", reason: "prop_on_non_object" };
+          break;
+        }
+        const owned = readOwnDataProperty(object.value, expression.key);
+        if (!owned.ok) {
+          result = { origin: "unavailable", reason: owned.reason };
+          break;
+        }
+        const completeness = object.completeness === "partial" || capturedValueCompleteness(owned.value) === "partial" ? "partial" : "exact";
+        result = {
+          origin: "derived",
+          completeness,
+          value: owned.value,
+          dependencies: [expression.object]
+        };
+        break;
+      }
+      case "index": {
+        const array = evalChild(expression.array);
+        if (array.origin === "unavailable") {
+          result = array;
+          break;
+        }
+        if (!Array.isArray(array.value)) {
+          result = { origin: "unavailable", reason: "index_on_non_array" };
+          break;
+        }
+        if (expression.index < 0 || expression.index >= array.value.length) {
+          result = { origin: "unavailable", reason: "index_out_of_range" };
+          break;
+        }
+        const value = array.value[expression.index];
+        if (rasputinTagKind(value) === "unknown") {
+          result = { origin: "unavailable", reason: "array_hole" };
+          break;
+        }
+        const completeness = array.completeness === "partial" || capturedValueCompleteness(value) === "partial" ? "partial" : "exact";
+        result = {
+          origin: "derived",
+          completeness,
+          value,
+          dependencies: [expression.array]
+        };
+        break;
+      }
+      case "pure_call": {
+        const childReturn = takeChildCapturedReturn(state, expression.calleeFunctionId);
+        if (childReturn && "threw" in childReturn) {
+          result = { origin: "unavailable", reason: "callee_threw" };
+          break;
+        }
+        const capturedReturn = childReturn && "present" in childReturn ? capturedFromWire(childReturn.value) : void 0;
+        const callee = calleeReturns.get(expression.calleeFunctionId);
+        const callArgs = [];
+        let argsExact = true;
+        for (const argId of expression.args) {
+          const nested = evalChild(argId);
+          if (nested.origin === "unavailable" || nested.completeness === "partial") {
+            argsExact = false;
+            continue;
+          }
+          callArgs.push(nested.value);
+        }
+        if (argsExact && state.recordingCallId != null) {
+          recordReconstructedCallArgs(
+            state.omittedCallArgs,
+            state.recordingCallId,
+            expression.calleeFunctionId,
+            callArgs
+          );
+        }
+        const canDeriveCallee = Boolean(
+          argsExact && callee && !callee.fallbackReason && callee.returnExpressionId != null
+        );
+        const derivedReturn = canDeriveCallee && callee ? evaluateCallee(callee, callArgs) : void 0;
+        result = resolveCheckpoint(capturedReturn, derivedReturn, expression.id);
+        break;
+      }
+    }
+    if (result.origin !== "unavailable") {
+      state.outputBytes += estimateBytes(result.value);
+      const sizeOver = budgetExceeded(state);
+      if (sizeOver) result = { origin: "unavailable", reason: sizeOver };
+    }
+    if (result.origin === "derived" && result.completeness === "exact") {
+      for (const dep of result.dependencies) {
+        const child = cells.get(dep);
+        if (child?.status === "done" && child.result.origin !== "unavailable") {
+          if (child.result.completeness === "partial") {
+            result = { ...result, completeness: "partial" };
+            break;
+          }
+        }
+      }
+    }
+    cells.set(expressionId, { status: "done", result });
+    return result;
+  } finally {
+    state.depth--;
+  }
+};
+var isJsPrimitive = (value) => {
+  const type = typeof value;
+  return value === null || type !== "object" && type !== "function";
+};
+var abstractEquals = (left, right) => {
+  if (!isJsPrimitive(left) || !isJsPrimitive(right)) return void 0;
+  return left == right;
+};
+var applyBinary = (op, left, right) => {
+  if (op === "add" && typeof left === "number" && typeof right === "number") return left + right;
+  if (op === "add" && typeof left === "string" && typeof right === "string") return left + right;
+  if (typeof left !== "number" || typeof right !== "number") {
+    if (op === "eq") return abstractEquals(left, right);
+    if (op === "neq") {
+      const equal = abstractEquals(left, right);
+      return equal === void 0 ? void 0 : !equal;
+    }
+    if (op === "seq") return left === right;
+    if (op === "sneq") return left !== right;
+    return void 0;
+  }
+  switch (op) {
+    case "add":
+      return left + right;
+    case "sub":
+      return left - right;
+    case "mul":
+      return left * right;
+    case "div":
+      return left / right;
+    case "mod":
+      return left % right;
+    case "eq":
+      return left === right;
+    case "neq":
+      return left !== right;
+    case "seq":
+      return left === right;
+    case "sneq":
+      return left !== right;
+    case "lt":
+      return left < right;
+    case "lte":
+      return left <= right;
+    case "gt":
+      return left > right;
+    case "gte":
+      return left >= right;
+  }
+};
+var evaluatePlan = (plan, args, roots, facts, plansByFunctionId, state, recordingCallId, capturedExit, threw = false) => {
+  const previousRecordingCallId = state.recordingCallId;
+  state.recordingCallId = recordingCallId;
+  try {
+    const byId = new Map(plan.expressions.map((expression) => [expression.id, expression]));
+    const cells = /* @__PURE__ */ new Map();
+    const rootsById = new Map(roots.map((root) => [root.rootId, root]));
+    const factsById = new Map(facts.map((fact) => [fact.factId, fact]));
+    const evaluateCallee = (callee, callArgs) => {
+      if (callee.returnExpressionId == null) {
+        return { origin: "unavailable", reason: "callee_without_return" };
+      }
+      const nested = evaluatePlan(callee, callArgs, [], [], plansByFunctionId, state, null);
+      return nested.returnValue ?? { origin: "unavailable", reason: "callee_without_return" };
+    };
+    const values = {};
+    for (const expression of plan.expressions) {
+      values[expression.id] = evaluateExpression(
+        expression.id,
+        plan,
+        byId,
+        cells,
+        args,
+        rootsById,
+        factsById,
+        plansByFunctionId,
+        state,
+        evaluateCallee
+      );
+    }
+    const variables = plan.variables.map((variable) => ({
+      variableId: variable.id,
+      name: variable.name,
+      availableAtLine: variable.availableAtLine,
+      availableAtColumn: variable.availableAtColumn,
+      result: values[variable.expressionId] ?? {
+        origin: "unavailable",
+        reason: "missing_expression"
+      }
+    }));
+    const derivedReturn = plan.returnExpressionId == null ? void 0 : values[plan.returnExpressionId] ?? {
+      origin: "unavailable",
+      reason: "missing_return"
+    };
+    return {
+      functionId: plan.functionId,
+      callId: roots[0]?.callId ?? facts[0]?.callId ?? 0,
+      values,
+      variables,
+      returnValue: threw ? void 0 : resolveCheckpoint(
+        capturedExit ? capturedFromWire(capturedExit.value) : void 0,
+        derivedReturn,
+        plan.returnExpressionId
+      )
+    };
+  } finally {
+    state.recordingCallId = previousRecordingCallId;
+  }
+};
+var evaluateRuntimeDerivation = (input) => {
+  if (!input.manifest) {
+    return { unavailableReason: "missing_manifest", functions: [] };
+  }
+  if (input.manifest.schema_version !== 3) {
+    return { unavailableReason: "manifest_version_mismatch", functions: [] };
+  }
+  const expectedHash = input.state.derivation?.manifestHash;
+  if (!expectedHash) {
+    return { unavailableReason: "missing_manifest_hash", functions: [] };
+  }
+  if (hashInstrumentationManifest(input.manifest) !== expectedHash) {
+    return { unavailableReason: "manifest_hash_mismatch", functions: [] };
+  }
+  const plansByFunctionId = new Map(
+    (input.manifest.derivationPlans ?? []).map((plan) => [plan.functionId, plan])
+  );
+  const roots = input.state.derivation?.roots ?? [];
+  const facts = input.state.derivation?.controlFacts ?? [];
+  const exitByCallId = /* @__PURE__ */ new Map();
+  const throwCallIds = /* @__PURE__ */ new Set();
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const event of input.state.events) {
+    if (event.type === "function_enter" && event.parentCallId != null) {
+      const child = { callId: event.callId, functionId: event.functionId };
+      const siblings = childrenByParent.get(event.parentCallId);
+      if (siblings) siblings.push(child);
+      else childrenByParent.set(event.parentCallId, [child]);
+    }
+    if (event.type === "function_exit") {
+      exitByCallId.set(event.callId, { present: true, value: event.returnValue });
+    }
+    if (event.type === "function_throw") throwCallIds.add(event.callId);
+  }
+  const state = {
+    instructions: 0,
+    depth: 0,
+    outputBytes: 0,
+    startedAt: Date.now(),
+    recordingCallId: null,
+    omittedCallArgs: /* @__PURE__ */ new Map(),
+    exitByCallId,
+    throwCallIds,
+    childrenByParent,
+    childCursor: /* @__PURE__ */ new Map()
+  };
+  const enterEvents = input.state.events.filter((event) => event.type === "function_enter");
+  const functions = [];
+  for (const enter of enterEvents) {
+    const plan = plansByFunctionId.get(enter.functionId);
+    if (!plan) continue;
+    const callRoots = roots.filter((root) => root.callId === enter.callId);
+    const callFacts = facts.filter((fact) => fact.callId === enter.callId);
+    const evaluated = evaluatePlan(
+      plan,
+      resolveEnterArgs(enter, state.omittedCallArgs),
+      callRoots,
+      callFacts,
+      plansByFunctionId,
+      state,
+      enter.callId,
+      exitByCallId.get(enter.callId),
+      throwCallIds.has(enter.callId)
+    );
+    evaluated.callId = enter.callId;
+    functions.push(evaluated);
+  }
+  return { functions };
+};
+var evaluatedValueAtLine = (evaluated, line) => {
+  if (!evaluated) return [];
+  return evaluated.variables.filter((variable) => line == null || variable.availableAtLine <= line).map((variable) => ({ name: variable.name, result: variable.result }));
+};
+
 // src/instrumentation-manifest/instrumentation-manifest-types.ts
-var INSTRUMENTATION_MANIFEST_SCHEMA_VERSION = 2;
+var INSTRUMENTATION_MANIFEST_SCHEMA_VERSION = 3;
 
 // src/instrumentation-manifest/upload-instrumentation-manifest.ts
 var uploadInstrumentationManifest = async (options) => {
@@ -1470,15 +2613,29 @@ var uploadInstrumentationManifest = async (options) => {
 };
 export {
   INSTRUMENTATION_MANIFEST_SCHEMA_VERSION,
+  RASPUTIN_WIRE_TAG,
   announceDeploy,
+  capturedValueCompleteness,
   createClient,
   createIngestEvent,
   createSuppression,
   createTransport,
   detectRelease,
+  evaluateRuntimeDerivation,
+  evaluatedValueAtLine,
+  hashInstrumentationManifest,
   isClientEnabled,
+  isRasputinTaggedValue,
+  isRedactedCapturedValue,
+  isSerializerMarker,
   normalizeFrames,
   parseStack,
+  rasputinOmitted,
+  rasputinRedacted,
+  rasputinTagKind,
+  rasputinTruncated,
+  rasputinUnavailable,
+  rasputinUnknown,
   repoRootFrom,
   resetSourceIdentityCache,
   resolveEndpointUrls,