@lucern/graph-primitives 1.0.29 → 1.0.31

package/dist/epistemicContracts.metrics.d.ts

@@ -1,5 +1,7 @@
 import { Id } from './convex.js';
 import { ContractReadCtx, ContradictionStatusCounts, EvidenceFreshness, EpistemicEvaluatorContext, EpistemicEvaluatorResult } from './epistemicContracts.types.js';
+import '@lucern/access-control/convex';
+import '@lucern/contracts/convex/unsafeAnyApi';
 import 'convex/values';
 import '@lucern/confidence';
 

package/dist/epistemicContracts.metrics.js

@@ -1,4 +1,4 @@
-import { parseEvidentialEvaluatorConfig, compareMetricValue, buildEvidentialRationale, parseMetricCheckerConfig, getEvaluatorInputRecord, pickFiniteNumber, resolveComparisonResult, buildComparisonRationale, parseReferenceCheckCounterConfig, parseTemporalDeadlineConfig, parseMarketIndexComparatorConfig } from '@lucern/confidence';
+import { parseEvidentialEvaluatorConfig, compareMetricValue, resolveComparisonResult, buildEvidentialRationale, parseMetricCheckerConfig, getEvaluatorInputRecord, pickFiniteNumber, buildComparisonRationale, parseReferenceCheckCounterConfig, parseTemporalDeadlineConfig, parseMarketIndexComparatorConfig } from '@lucern/confidence';
 
 // src/epistemicContractHelpers.ts
 
@@ -8,9 +8,7 @@ var ACTIVE_CONTRADICTION_STATUSES = /* @__PURE__ */ new Set([
   "investigating",
   "accepted_as_permanent"
 ]);
-var DEPENDENT_EDGE_TYPES = /* @__PURE__ */ new Set([
-  "depends_on"
-]);
+var DEPENDENT_EDGE_TYPES = /* @__PURE__ */ new Set(["depends_on"]);
 function classifyContradictionStatus(status) {
   if (typeof status !== "string") {
     return "active";
@@ -23,6 +21,99 @@ function classifyContradictionStatus(status) {
   }
   return "resolved";
 }
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readConvexId(value) {
+  const normalized = readOptionalString(value);
+  return normalized;
+}
+function readMetricNodeDoc(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  const nodeType = readOptionalString(value.nodeType);
+  if (!(id && nodeType)) {
+    return null;
+  }
+  const node = { _id: id, nodeType };
+  const globalId = readOptionalString(value.globalId);
+  if (globalId !== void 0) {
+    node.globalId = globalId;
+  }
+  if ("metadata" in value) {
+    node.metadata = value.metadata;
+  }
+  const status = readOptionalString(value.status);
+  if (status !== void 0) {
+    node.status = status;
+  }
+  return node;
+}
+function readIncomingEdgeRow(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const fromNodeId = readOptionalString(value.fromNodeId);
+  if (!fromNodeId) {
+    return null;
+  }
+  const edge = { fromNodeId };
+  const id = readConvexId(value._id);
+  if (id !== void 0) {
+    edge._id = id;
+  }
+  const edgeType = readOptionalString(value.edgeType);
+  if (edgeType !== void 0) {
+    edge.edgeType = edgeType;
+  }
+  const fromGlobalId = readOptionalString(value.fromGlobalId);
+  if (fromGlobalId !== void 0) {
+    edge.fromGlobalId = fromGlobalId;
+  }
+  const fromUuid = readOptionalString(value.fromUuid);
+  if (fromUuid !== void 0) {
+    edge.fromUuid = fromUuid;
+  }
+  const sourceGlobalId = readOptionalString(value.sourceGlobalId);
+  if (sourceGlobalId !== void 0) {
+    edge.sourceGlobalId = sourceGlobalId;
+  }
+  const targetGlobalId = readOptionalString(value.targetGlobalId);
+  if (targetGlobalId !== void 0) {
+    edge.targetGlobalId = targetGlobalId;
+  }
+  const toGlobalId = readOptionalString(value.toGlobalId);
+  if (toGlobalId !== void 0) {
+    edge.toGlobalId = toGlobalId;
+  }
+  const toNodeId = readOptionalString(value.toNodeId);
+  if (toNodeId !== void 0) {
+    edge.toNodeId = toNodeId;
+  }
+  const toUuid = readOptionalString(value.toUuid);
+  if (toUuid !== void 0) {
+    edge.toUuid = toUuid;
+  }
+  const weight = readOptionalNumber(value.weight);
+  if (weight !== void 0) {
+    edge.weight = weight;
+  }
+  for (const timestampField of ["_creationTime", "createdAt", "updatedAt"]) {
+    const timestamp = readOptionalNumber(value[timestampField]);
+    if (timestamp !== void 0) {
+      edge[timestampField] = timestamp;
+    }
+  }
+  return edge;
+}
 function getEdgeTimestamp(edge) {
   if (typeof edge.updatedAt === "number") {
     return edge.updatedAt;
@@ -35,22 +126,86 @@ function getEdgeTimestamp(edge) {
   }
   return null;
 }
+async function collectNodeEndpointRefs(ctx, nodeId) {
+  const refs = /* @__PURE__ */ new Set([String(nodeId)]);
+  const node = readMetricNodeDoc(await ctx.db.get(nodeId));
+  if (node?.globalId) {
+    refs.add(node.globalId);
+  }
+  return [...refs];
+}
+async function collectIncomingEdgeRows(ctx, nodeId, edgeType) {
+  const refs = await collectNodeEndpointRefs(ctx, nodeId);
+  const seen = /* @__PURE__ */ new Set();
+  const edges = [];
+  for (const ref of refs) {
+    const rows = edgeType === void 0 ? await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", ref)).collect() : await ctx.db.query("epistemicEdges").withIndex(
+      "by_to_type",
+      (q) => q.eq("toNodeId", ref).eq("edgeType", edgeType)
+    ).collect();
+    for (const row of rows) {
+      const edge = readIncomingEdgeRow(row);
+      if (!edge) {
+        continue;
+      }
+      if (edgeType !== void 0 && edge.edgeType !== edgeType) {
+        continue;
+      }
+      const key = edge._id === void 0 ? `${edge.fromNodeId}->${edge.toNodeId ?? ref}:${edge.edgeType ?? ""}` : String(edge._id);
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      edges.push(edge);
+    }
+  }
+  return edges;
+}
+function sourceEndpointRefs(edge) {
+  return [
+    edge.fromNodeId,
+    edge.sourceGlobalId,
+    edge.fromGlobalId,
+    edge.fromUuid
+  ].filter((value) => value !== void 0);
+}
+async function resolveEndpointNode(ctx, refs) {
+  const candidates = refs.map((value) => value.trim()).filter(
+    (value, index, values) => value.length > 0 && values.indexOf(value) === index
+  );
+  for (const candidate of candidates) {
+    try {
+      const direct = readMetricNodeDoc(
+        await ctx.db.get(candidate)
+      );
+      if (direct) {
+        return direct;
+      }
+    } catch {
+    }
+    const byGlobalId = readMetricNodeDoc(
+      await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", candidate)).first()
+    );
+    if (byGlobalId) {
+      return byGlobalId;
+    }
+  }
+  return null;
+}
 async function getEvidenceLinks(ctx, beliefNodeId) {
-  const edges = await ctx.db.query("epistemicEdges").withIndex(
-    "by_to_type",
-    (q) => q.eq("toNodeId", beliefNodeId).eq("edgeType", "informs")
-  ).collect();
+  const edges = await collectIncomingEdgeRows(ctx, beliefNodeId, "informs");
   if (edges.length === 0) {
     return [];
   }
-  const nodes = await Promise.all(edges.map((edge) => ctx.db.get(edge.fromNodeId)));
-  return edges.flatMap((edge, index) => {
-    const node = nodes[index];
-    if (!node || node.nodeType !== "evidence" || node.status === "archived") {
-      return [];
+  const links = [];
+  for (const edge of edges) {
+    const node = await resolveEndpointNode(ctx, sourceEndpointRefs(edge));
+    if (node?.nodeType !== "evidence" || node.status === "archived") {
+      continue;
     }
-    return [{ edge, node }];
-  });
+    links.push({ edge, node });
+  }
+  return links;
 }
 function getEvidenceTags(node) {
   const metadata = node.metadata && typeof node.metadata === "object" ? node.metadata : null;
@@ -76,7 +231,8 @@ async function computeTaggedEvidenceCount(args) {
   };
 }
 async function computeContradictionCounts(ctx, beliefNodeId) {
-  const contradictions = await ctx.db.query("contradictions").withIndex("by_beliefId", (q) => q.eq("beliefId", beliefNodeId)).collect();
+  const contradictionDb = ctx.db;
+  const contradictions = await contradictionDb.query("contradictions").withIndex("by_beliefId", (q) => q.eq("beliefId", beliefNodeId)).collect();
   return contradictions.reduce(
     (counts, contradiction) => {
       const status = contradiction.resolutionStatus ?? contradiction.status ?? "unresolved";
@@ -112,18 +268,16 @@ async function computeEvidenceFreshness(ctx, beliefNodeId, now = Date.now()) {
   };
 }
 async function computeDependentBeliefCount(ctx, beliefNodeId) {
-  const incomingEdges = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", beliefNodeId)).collect();
+  const incomingEdges = await collectIncomingEdgeRows(ctx, beliefNodeId);
   const dependencyEdges = incomingEdges.filter(
-    (edge) => DEPENDENT_EDGE_TYPES.has(edge.edgeType)
+    (edge) => edge.edgeType ? DEPENDENT_EDGE_TYPES.has(edge.edgeType) : false
   );
   if (dependencyEdges.length === 0) {
     return 0;
   }
-  const dependentBeliefs = await Promise.all(
-    dependencyEdges.map((edge) => ctx.db.get(edge.fromNodeId))
-  );
   const uniqueBeliefIds = /* @__PURE__ */ new Set();
-  for (const node of dependentBeliefs) {
+  for (const edge of dependencyEdges) {
+    const node = await resolveEndpointNode(ctx, sourceEndpointRefs(edge));
     if (node && node.nodeType === "belief" && node.status !== "archived" && node.status !== "deleted") {
       uniqueBeliefIds.add(String(node._id));
     }
@@ -133,7 +287,10 @@ async function computeDependentBeliefCount(ctx, beliefNodeId) {
 async function snapshotEvidentialMetric(args) {
   switch (args.metric) {
     case "evidence_count": {
-      const count = await computeEvidenceCountMetric(args.ctx, args.beliefNodeId);
+      const count = await computeEvidenceCountMetric(
+        args.ctx,
+        args.beliefNodeId
+      );
       return {
         metric: args.metric,
         value: count,
@@ -141,7 +298,10 @@ async function snapshotEvidentialMetric(args) {
       };
     }
     case "contradiction_status": {
-      const counts = await computeContradictionCounts(args.ctx, args.beliefNodeId);
+      const counts = await computeContradictionCounts(
+        args.ctx,
+        args.beliefNodeId
+      );
       return {
         metric: args.metric,
         value: counts.activeCount,
@@ -161,7 +321,10 @@ async function snapshotEvidentialMetric(args) {
       };
     }
     case "dependent_count": {
-      const count = await computeDependentBeliefCount(args.ctx, args.beliefNodeId);
+      const count = await computeDependentBeliefCount(
+        args.ctx,
+        args.beliefNodeId
+      );
       return {
         metric: args.metric,
         value: count,
@@ -177,7 +340,9 @@ async function snapshotEvidentialMetric(args) {
   }
 }
 async function evaluateBuiltInEvidentialContract(args) {
-  const config = parseEvidentialEvaluatorConfig(args.contract.condition.evaluatorConfig);
+  const config = parseEvidentialEvaluatorConfig(
+    args.contract.condition.evaluatorConfig
+  );
   const snapshot = await snapshotEvidentialMetric({
     ctx: args.ctx,
     beliefNodeId: args.belief._id,
@@ -185,7 +350,10 @@ async function evaluateBuiltInEvidentialContract(args) {
     now: args.now
   });
   const comparisonSatisfied = snapshot.value !== null && compareMetricValue(config.operator, snapshot.value, config.threshold);
-  const result = args.contract.direction === "falsifies" ? comparisonSatisfied ? "disconfirmed" : "confirmed" : comparisonSatisfied ? "confirmed" : "disconfirmed";
+  const result = resolveComparisonResult(
+    args.contract.direction,
+    comparisonSatisfied
+  );
   return {
     result,
     rationale: buildEvidentialRationale({
@@ -205,57 +373,66 @@ async function evaluateBuiltInEvidentialContract(args) {
     }
   };
 }
-async function evaluateMetricCheckerContract(args) {
-  const config = parseMetricCheckerConfig(args.contract.condition.evaluatorConfig);
-  const input = getEvaluatorInputRecord(args.inputData, "metricData");
-  const metric = typeof input.metric === "string" && input.metric.length > 0 ? input.metric : config.metric;
-  const observedValue = pickFiniteNumber(input, [
-    "observedValue",
-    "currentValue",
-    "metricValue",
-    "value"
-  ]) ?? config.observedValue ?? config.currentValue ?? config.metricValue ?? null;
-  if (observedValue === null) {
+function evaluateMetricCheckerContract(args) {
+  return Promise.resolve().then(() => {
+    const config = parseMetricCheckerConfig(
+      args.contract.condition.evaluatorConfig
+    );
+    const input = getEvaluatorInputRecord(args.inputData, "metricData");
+    const metric = typeof input.metric === "string" && input.metric.length > 0 ? input.metric : config.metric;
+    const observedValue = pickFiniteNumber(input, [
+      "observedValue",
+      "currentValue",
+      "metricValue",
+      "value"
+    ]) ?? config.observedValue ?? config.currentValue ?? config.metricValue ?? null;
+    if (observedValue === null) {
+      return {
+        result: "inconclusive",
+        rationale: `metric_checker is awaiting data for ${metric ?? args.contract.condition.expression}.`,
+        data: {
+          metric,
+          observedValue: null,
+          operator: config.operator,
+          threshold: config.threshold,
+          unit: config.unit
+        }
+      };
+    }
+    const comparisonSatisfied = compareMetricValue(
+      config.operator,
+      observedValue,
+      config.threshold
+    );
+    const result = resolveComparisonResult(
+      args.contract.direction,
+      comparisonSatisfied
+    );
     return {
-      result: "inconclusive",
-      rationale: `metric_checker is awaiting data for ${metric ?? args.contract.condition.expression}.`,
+      result,
+      rationale: buildComparisonRationale({
+        label: metric ?? "metric",
+        observedValue,
+        operator: config.operator,
+        threshold: config.threshold,
+        comparisonSatisfied,
+        result,
+        unit: config.unit
+      }),
       data: {
         metric,
-        observedValue: null,
+        observedValue,
         operator: config.operator,
         threshold: config.threshold,
         unit: config.unit
       }
     };
-  }
-  const comparisonSatisfied = compareMetricValue(
-    config.operator,
-    observedValue,
-    config.threshold
-  );
-  const result = resolveComparisonResult(args.contract.direction, comparisonSatisfied);
-  return {
-    result,
-    rationale: buildComparisonRationale({
-      label: metric ?? "metric",
-      observedValue,
-      operator: config.operator,
-      threshold: config.threshold,
-      comparisonSatisfied,
-      result,
-      unit: config.unit
-    }),
-    data: {
-      metric,
-      observedValue,
-      operator: config.operator,
-      threshold: config.threshold,
-      unit: config.unit
-    }
-  };
+  });
 }
 async function evaluateReferenceCheckCounterContract(args) {
-  const config = parseReferenceCheckCounterConfig(args.contract.condition.evaluatorConfig);
+  const config = parseReferenceCheckCounterConfig(
+    args.contract.condition.evaluatorConfig
+  );
   const input = getEvaluatorInputRecord(args.inputData, "referenceCheckData");
   const tag = typeof input.tag === "string" && input.tag.trim().length > 0 ? input.tag.trim() : config.tag;
   const snapshot = await computeTaggedEvidenceCount({
@@ -269,7 +446,10 @@ async function evaluateReferenceCheckCounterContract(args) {
     snapshot.count,
     config.threshold
   );
-  const result = resolveComparisonResult(args.contract.direction, comparisonSatisfied);
+  const result = resolveComparisonResult(
+    args.contract.direction,
+    comparisonSatisfied
+  );
   return {
     result,
     rationale: buildComparisonRationale({
@@ -291,131 +471,168 @@ async function evaluateReferenceCheckCounterContract(args) {
     }
   };
 }
-async function evaluateTemporalDeadlineContract(args) {
-  if (typeof args.contract.deadline !== "number" || !Number.isFinite(args.contract.deadline)) {
-    throw new Error(
-      "temporal_deadline requires contract.deadline to be set to a finite timestamp."
-    );
-  }
-  const config = parseTemporalDeadlineConfig(args.contract.condition.evaluatorConfig);
-  const input = getEvaluatorInputRecord(args.inputData, "temporalData");
-  const label = (typeof input.label === "string" && input.label.length > 0 ? input.label : config.label) ?? args.contract.title ?? args.contract.condition.expression;
-  const completedAt = pickFiniteNumber(input, [
-    "completedAt",
-    "observedAt",
-    "satisfiedAt",
-    "achievedAt"
-  ]) ?? config.completedAt ?? config.observedAt ?? config.satisfiedAt ?? config.achievedAt;
-  const completed = input.completed === true || config.completed === true || completedAt !== void 0;
-  if (completed) {
-    if (completedAt !== void 0 && completedAt > args.contract.deadline) {
-      return {
-        result: "expired",
-        rationale: `${label} completed at ${completedAt}, after deadline ${args.contract.deadline}.`,
-        data: {
-          label,
-          deadline: args.contract.deadline,
-          completed: true,
-          completedAt,
-          missedDeadline: true,
-          overdueByMs: completedAt - args.contract.deadline
-        }
-      };
-    }
-    const result = args.contract.direction === "falsifies" ? "disconfirmed" : "confirmed";
+function resolveCompletedTemporalDeadlineResult(args) {
+  const { completedAt, context, deadline, label } = args;
+  if (completedAt !== void 0 && completedAt > deadline) {
     return {
-      result,
-      rationale: `${label} completed before deadline ${args.contract.deadline}.`,
+      result: "expired",
+      rationale: `${label} completed at ${completedAt}, after deadline ${deadline}.`,
       data: {
         label,
-        deadline: args.contract.deadline,
+        deadline,
         completed: true,
-        completedAt: completedAt ?? null,
-        missedDeadline: false
+        completedAt,
+        missedDeadline: true,
+        overdueByMs: completedAt - deadline
       }
     };
   }
-  if (args.now > args.contract.deadline) {
+  const result = context.contract.direction === "falsifies" ? "disconfirmed" : "confirmed";
+  return {
+    result,
+    rationale: `${label} completed before deadline ${deadline}.`,
+    data: {
+      label,
+      deadline,
+      completed: true,
+      completedAt: completedAt ?? null,
+      missedDeadline: false
+    }
+  };
+}
+function resolveOpenTemporalDeadlineResult(args) {
+  const { context, deadline, label } = args;
+  if (context.now > deadline) {
     return {
       result: "expired",
-      rationale: `${label} missed deadline ${args.contract.deadline}; temporal contract expired.`,
+      rationale: `${label} missed deadline ${deadline}; temporal contract expired.`,
       data: {
         label,
-        deadline: args.contract.deadline,
+        deadline,
         completed: false,
-        overdueByMs: args.now - args.contract.deadline
+        overdueByMs: context.now - deadline
       }
     };
   }
   return {
     result: "inconclusive",
-    rationale: `${label} is still before deadline ${args.contract.deadline}; awaiting outcome.`,
+    rationale: `${label} is still before deadline ${deadline}; awaiting outcome.`,
     data: {
       label,
-      deadline: args.contract.deadline,
+      deadline,
       completed: false,
-      timeRemainingMs: args.contract.deadline - args.now
+      timeRemainingMs: deadline - context.now
     }
   };
 }
-async function evaluateMarketIndexComparatorContract(args) {
-  const config = parseMarketIndexComparatorConfig(args.contract.condition.evaluatorConfig);
-  const input = getEvaluatorInputRecord(args.inputData, "marketIndexData");
-  const subject = typeof input.subject === "string" && input.subject.length > 0 ? input.subject : config.subject;
-  const benchmark = typeof input.benchmark === "string" && input.benchmark.length > 0 ? input.benchmark : config.benchmark;
-  const subjectValue = pickFiniteNumber(input, ["subjectValue", "primaryValue", "leftValue"]) ?? config.subjectValue ?? config.primaryValue ?? null;
-  const benchmarkValue = pickFiniteNumber(input, ["benchmarkValue", "comparisonValue", "rightValue"]) ?? config.benchmarkValue ?? config.comparisonValue ?? null;
-  if (subjectValue === null || benchmarkValue === null) {
+function evaluateTemporalDeadlineContract(args) {
+  return Promise.resolve().then(() => {
+    if (typeof args.contract.deadline !== "number" || !Number.isFinite(args.contract.deadline)) {
+      throw new Error(
+        "temporal_deadline requires contract.deadline to be set to a finite timestamp."
+      );
+    }
+    const deadline = args.contract.deadline;
+    const config = parseTemporalDeadlineConfig(
+      args.contract.condition.evaluatorConfig
+    );
+    const input = getEvaluatorInputRecord(args.inputData, "temporalData");
+    const label = (typeof input.label === "string" && input.label.length > 0 ? input.label : config.label) ?? args.contract.title ?? args.contract.condition.expression;
+    const completedAt = pickFiniteNumber(input, [
+      "completedAt",
+      "observedAt",
+      "satisfiedAt",
+      "achievedAt"
+    ]) ?? config.completedAt ?? config.observedAt ?? config.satisfiedAt ?? config.achievedAt;
+    const completed = input.completed === true || config.completed === true || completedAt !== void 0;
+    if (completed) {
+      return resolveCompletedTemporalDeadlineResult({
+        completedAt,
+        context: args,
+        deadline,
+        label
+      });
+    }
+    return resolveOpenTemporalDeadlineResult({
+      context: args,
+      deadline,
+      label
+    });
+  });
+}
+function evaluateMarketIndexComparatorContract(args) {
+  return Promise.resolve().then(() => {
+    const config = parseMarketIndexComparatorConfig(
+      args.contract.condition.evaluatorConfig
+    );
+    const input = getEvaluatorInputRecord(args.inputData, "marketIndexData");
+    const subject = typeof input.subject === "string" && input.subject.length > 0 ? input.subject : config.subject;
+    const benchmark = typeof input.benchmark === "string" && input.benchmark.length > 0 ? input.benchmark : config.benchmark;
+    const subjectValue = pickFiniteNumber(input, ["subjectValue", "primaryValue", "leftValue"]) ?? config.subjectValue ?? config.primaryValue ?? null;
+    const benchmarkValue = pickFiniteNumber(input, [
+      "benchmarkValue",
+      "comparisonValue",
+      "rightValue"
+    ]) ?? config.benchmarkValue ?? config.comparisonValue ?? null;
+    if (subjectValue === null || benchmarkValue === null) {
+      return {
+        result: "inconclusive",
+        rationale: "market_index_comparator is awaiting both subject and benchmark values.",
+        data: {
+          subject,
+          subjectValue,
+          benchmark,
+          benchmarkValue,
+          operator: config.operator,
+          threshold: config.threshold
+        }
+      };
+    }
+    if (benchmarkValue === 0) {
+      throw new Error(
+        "market_index_comparator cannot compare against a zero benchmark value."
+      );
+    }
+    const differentialPercent = (subjectValue - benchmarkValue) / Math.abs(benchmarkValue) * 100;
+    const comparisonSatisfied = compareMetricValue(
+      config.operator,
+      differentialPercent,
+      config.threshold
+    );
+    const result = resolveComparisonResult(
+      args.contract.direction,
+      comparisonSatisfied
+    );
     return {
-      result: "inconclusive",
-      rationale: "market_index_comparator is awaiting both subject and benchmark values.",
+      result,
+      rationale: buildComparisonRationale({
+        label: `${subject ?? "subject"} vs ${benchmark ?? "benchmark"} differential`,
+        observedValue: differentialPercent,
+        operator: config.operator,
+        threshold: config.threshold,
+        comparisonSatisfied,
+        result,
+        unit: "%"
+      }),
       data: {
         subject,
         subjectValue,
         benchmark,
         benchmarkValue,
+        differentialPercent,
         operator: config.operator,
         threshold: config.threshold
       }
     };
-  }
-  if (benchmarkValue === 0) {
-    throw new Error(
-      "market_index_comparator cannot compare against a zero benchmark value."
-    );
-  }
-  const differentialPercent = (subjectValue - benchmarkValue) / Math.abs(benchmarkValue) * 100;
-  const comparisonSatisfied = compareMetricValue(
-    config.operator,
-    differentialPercent,
-    config.threshold
-  );
-  const result = resolveComparisonResult(args.contract.direction, comparisonSatisfied);
-  return {
-    result,
-    rationale: buildComparisonRationale({
-      label: `${subject ?? "subject"} vs ${benchmark ?? "benchmark"} differential`,
-      observedValue: differentialPercent,
-      operator: config.operator,
-      threshold: config.threshold,
-      comparisonSatisfied,
-      result,
-      unit: "%"
-    }),
-    data: {
-      subject,
-      subjectValue,
-      benchmark,
-      benchmarkValue,
-      differentialPercent,
-      operator: config.operator,
-      threshold: config.threshold
-    }
-  };
+  });
 }
 var METRIC_COMPARATOR_EVALUATOR_NAMES = {
   evidential: "evidential",
-  evidentialAliases: /* @__PURE__ */ new Set(["evidential", "built_in_evidential", "builtin_evidential"]),
+  evidentialAliases: /* @__PURE__ */ new Set([
+    "evidential",
+    "built_in_evidential",
+    "builtin_evidential"
+  ]),
   metricChecker: "metric_checker",
   referenceCheckCounter: "reference_check_counter",
   temporalDeadline: "temporal_deadline",