@rasputin-ai/core 0.5.0-alpha.6 → 0.5.0-alpha.8

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.6";
+var SDK_VERSION = "0.5.0-alpha.8";
 
 // src/suppression/identity-needs-message-template.ts
 var identityNeedsMessageTemplate = (type, code) => {
@@ -1530,8 +1530,938 @@ 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 nested of Object.values(value)) {
+    if (capturedValueCompleteness(nested) === "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/evaluate-derivation-plan.ts
+var MAX_INSTRUCTIONS = 1e4;
+var MAX_DEPTH = 64;
+var MAX_OUTPUT_BYTES = 256 * 1024;
+var MAX_WALL_MS = 50;
+var isRecord2 = (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, nested] of Object.entries(value)) {
+        total += key.length + estimateBytes(nested, depth + 1);
+      }
+      return total;
+    }
+    default:
+      return 8;
+  }
+};
+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 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;
+        }
+        const completeness = capturedValueCompleteness(value);
+        result = { origin: "captured", completeness, 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 completeness = mergeCompleteness([left, right]);
+        if (completeness === "unavailable") {
+          result = { origin: "unavailable", reason: "partial_dependency" };
+          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,
+          value,
+          dependencies: [expression.left, expression.right]
+        };
+        break;
+      }
+      case "unary": {
+        const operand = evalChild(expression.operand);
+        if (operand.origin === "unavailable") {
+          result = 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: operand.completeness,
+            value: typeof raw,
+            dependencies: [expression.operand]
+          };
+          break;
+        }
+        if (expression.op === "not") {
+          result = {
+            origin: "derived",
+            completeness: operand.completeness,
+            value: !raw,
+            dependencies: [expression.operand]
+          };
+          break;
+        }
+        if (!isNumericPrimitive(raw)) {
+          result = { origin: "unavailable", reason: "numeric_guard_failed" };
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness: operand.completeness,
+          value: expression.op === "minus" ? -raw : +raw,
+          dependencies: [expression.operand]
+        };
+        break;
+      }
+      case "logical": {
+        const left = evalChild(expression.left);
+        if (left.origin === "unavailable") {
+          result = 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: left.completeness,
+            value: left.value,
+            dependencies: [expression.left]
+          };
+          break;
+        }
+        const right = evalChild(expression.right);
+        const completeness = mergeCompleteness([left, right]);
+        if (completeness === "unavailable" || right.origin === "unavailable") {
+          result = { origin: "unavailable", reason: "partial_dependency" };
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness,
+          value: right.value,
+          dependencies: [expression.left, expression.right]
+        };
+        break;
+      }
+      case "cond": {
+        const test = evalChild(expression.test);
+        if (test.origin === "unavailable") {
+          result = 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 completeness = mergeCompleteness([test, branch]);
+        if (completeness === "unavailable" || branch.origin === "unavailable") {
+          result = { origin: "unavailable", reason: "partial_dependency" };
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness,
+          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 (!isRecord2(object.value) || rasputinTagKind(object.value)) {
+          result = { origin: "unavailable", reason: "prop_on_non_object" };
+          break;
+        }
+        if (!(expression.key in object.value)) {
+          result = { origin: "unavailable", reason: "missing_property" };
+          break;
+        }
+        const value = object.value[expression.key];
+        const completeness = object.completeness === "partial" || capturedValueCompleteness(value) === "partial" ? "partial" : "exact";
+        result = {
+          origin: "derived",
+          completeness,
+          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 callee = calleeReturns.get(expression.calleeFunctionId);
+        if (!callee || callee.fallbackReason || callee.returnExpressionId == null) {
+          result = { origin: "unavailable", reason: "unproven_callee" };
+          break;
+        }
+        const callArgs = [];
+        const parts = [];
+        let failed;
+        for (const argId of expression.args) {
+          const nested = evalChild(argId);
+          parts.push(nested);
+          if (nested.origin === "unavailable") {
+            failed = nested;
+            break;
+          }
+          callArgs.push(nested.value);
+        }
+        if (failed) {
+          result = failed;
+          break;
+        }
+        const completeness = mergeCompleteness(parts);
+        if (completeness === "unavailable") {
+          result = { origin: "unavailable", reason: "partial_dependency" };
+          break;
+        }
+        if (state.recordingCallId != null) {
+          recordReconstructedCallArgs(
+            state.omittedCallArgs,
+            state.recordingCallId,
+            expression.calleeFunctionId,
+            callArgs
+          );
+        }
+        const returned = evaluateCallee(callee, callArgs);
+        if (returned.origin === "unavailable") {
+          result = returned;
+          break;
+        }
+        result = {
+          origin: "derived",
+          completeness: completeness === "partial" || returned.completeness === "partial" ? "partial" : "exact",
+          value: returned.value,
+          dependencies: expression.args
+        };
+        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) => {
+  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"
+      }
+    }));
+    return {
+      functionId: plan.functionId,
+      callId: roots[0]?.callId ?? facts[0]?.callId ?? 0,
+      values,
+      variables,
+      returnValue: plan.returnExpressionId == null ? void 0 : values[plan.returnExpressionId] ?? {
+        origin: "unavailable",
+        reason: "missing_return"
+      }
+    };
+  } 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 state = {
+    instructions: 0,
+    depth: 0,
+    outputBytes: 0,
+    startedAt: Date.now(),
+    recordingCallId: null,
+    omittedCallArgs: /* @__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 || plan.fallbackReason) 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
+    );
+    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) => {
@@ -1558,15 +2488,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,