@lucern/confidence 0.1.0-alpha.2

package/dist/v1/operations/lucern.js

@@ -0,0 +1,1280 @@
+// src/v1/operations/subjectiveLogic/index.ts
+function opinion(belief, disbelief, uncertainty, baseRate = 0.5) {
+  const b = Math.max(0, Math.min(1, belief));
+  const d = Math.max(0, Math.min(1, disbelief));
+  const u = Math.max(0, Math.min(1, uncertainty));
+  const a = Math.max(0, Math.min(1, baseRate));
+  const sum = b + d + u;
+  if (sum === 0) {
+    return { b: 0, d: 0, u: 1, a };
+  }
+  return {
+    b: b / sum,
+    d: d / sum,
+    u: u / sum,
+    a
+  };
+}
+function vacuous(baseRate = 0.5) {
+  return { b: 0, d: 0, u: 1, a: baseRate };
+}
+function project(o) {
+  return o.b + o.a * o.u;
+}
+function confidenceLevel(o) {
+  const projected = project(o);
+  if (o.u > 0.5) {
+    return "low";
+  }
+  if (projected >= 0.8 && o.u < 0.2) {
+    return "high";
+  }
+  if (projected >= 0.6) {
+    return "medium";
+  }
+  return "low";
+}
+function cumulativeFusion(left, right) {
+  if (left.u === 0 && right.u === 0) {
+    return opinion(
+      (left.b + right.b) / 2,
+      (left.d + right.d) / 2,
+      0,
+      (left.a + right.a) / 2
+    );
+  }
+  const k = left.u + right.u - left.u * right.u;
+  if (k === 0) {
+    return vacuous((left.a + right.a) / 2);
+  }
+  return opinion(
+    (left.b * right.u + right.b * left.u) / k,
+    (left.d * right.u + right.d * left.u) / k,
+    left.u * right.u / k,
+    (left.a + right.a) / 2
+  );
+}
+function trustDiscount(sourceOpinion, trust) {
+  const weight = Math.max(0, Math.min(1, Math.abs(trust)));
+  return opinion(
+    weight * sourceOpinion.b,
+    weight * sourceOpinion.d,
+    1 - weight * (sourceOpinion.b + sourceOpinion.d),
+    sourceOpinion.a
+  );
+}
+var EPSILON = 1e-9;
+function childBaseRateFallback(ifTrue, ifFalse, fallbackBaseRate) {
+  if (fallbackBaseRate !== void 0) {
+    return Math.max(0, Math.min(1, fallbackBaseRate));
+  }
+  if (Math.abs(ifTrue.a - ifFalse.a) <= EPSILON) {
+    return ifTrue.a;
+  }
+  return (ifTrue.a + ifFalse.a) / 2;
+}
+function computeConditionalDeductionBaseRate(opinionA, ifTrue, ifFalse, fallbackBaseRate) {
+  const denominator = 1 - opinionA.a * ifTrue.u - (1 - opinionA.a) * ifFalse.u;
+  if (ifTrue.u + ifFalse.u < 2 - EPSILON && Math.abs(denominator) > EPSILON) {
+    const baseRate = (opinionA.a * ifTrue.b + (1 - opinionA.a) * ifFalse.b) / denominator;
+    if (baseRate >= -EPSILON && baseRate <= 1 + EPSILON) {
+      return Math.max(0, Math.min(1, baseRate));
+    }
+  }
+  return fallbackBaseRate;
+}
+function safeCorrectionTerm(numerator, denominator) {
+  if (Math.abs(denominator) <= EPSILON) {
+    return void 0;
+  }
+  const value = numerator / denominator;
+  if (!Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.max(0, value);
+}
+function conditionalDeduction(opinionA, ifTrue, ifFalse, fallbackBaseRate) {
+  const fallbackChildBaseRate = childBaseRateFallback(
+    ifTrue,
+    ifFalse,
+    fallbackBaseRate
+  );
+  const childBaseRate = computeConditionalDeductionBaseRate(
+    opinionA,
+    ifTrue,
+    ifFalse,
+    fallbackChildBaseRate
+  );
+  const projectedAntecedent = project(opinionA);
+  const projectedAntecedentComplement = 1 - projectedAntecedent;
+  const intermediateBelief = opinionA.b * ifTrue.b + opinionA.d * ifFalse.b + opinionA.u * (ifTrue.b * opinionA.a + ifFalse.b * (1 - opinionA.a));
+  const intermediateDisbelief = opinionA.b * ifTrue.d + opinionA.d * ifFalse.d + opinionA.u * (ifTrue.d * opinionA.a + ifFalse.d * (1 - opinionA.a));
+  const intermediateUncertainty = opinionA.b * ifTrue.u + opinionA.d * ifFalse.u + opinionA.u * (ifTrue.u * opinionA.a + ifFalse.u * (1 - opinionA.a));
+  const projectedVacuousDeduction = ifTrue.b * opinionA.a + ifFalse.b * (1 - opinionA.a) + childBaseRate * (ifTrue.u * opinionA.a + ifFalse.u * (1 - opinionA.a));
+  const projectedConditionalA = ifTrue.b + childBaseRate * (1 - ifTrue.b - ifTrue.d);
+  let correction = 0;
+  if (ifTrue.b > ifFalse.b && ifTrue.d > ifFalse.d || ifTrue.b <= ifFalse.b && ifTrue.d <= ifFalse.d) {
+    correction = 0;
+  } else if (ifTrue.b > ifFalse.b && ifTrue.d <= ifFalse.d) {
+    const beliefGap = ifTrue.b - ifFalse.b;
+    const disbeliefGap = ifFalse.d - ifTrue.d;
+    if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent <= opinionA.a) {
+      correction = safeCorrectionTerm(
+        opinionA.a * opinionA.u * (intermediateBelief - ifTrue.b),
+        projectedAntecedent * childBaseRate
+      ) ?? 0;
+    } else if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent > opinionA.a) {
+      correction = safeCorrectionTerm(
+        opinionA.a * opinionA.u * (intermediateDisbelief - ifTrue.d) * beliefGap,
+        projectedAntecedentComplement * childBaseRate * disbeliefGap
+      ) ?? 0;
+    } else if (projectedVacuousDeduction > projectedConditionalA && projectedAntecedent <= opinionA.a) {
+      correction = safeCorrectionTerm(
+        (1 - opinionA.a) * opinionA.u * (intermediateBelief - ifTrue.b) * disbeliefGap,
+        projectedAntecedent * (1 - childBaseRate) * beliefGap
+      ) ?? 0;
+    } else {
+      correction = safeCorrectionTerm(
+        (1 - opinionA.a) * opinionA.u * (intermediateDisbelief - ifTrue.d),
+        projectedAntecedentComplement * (1 - childBaseRate)
+      ) ?? 0;
+    }
+  } else {
+    const beliefGap = ifFalse.b - ifTrue.b;
+    const disbeliefGap = ifTrue.d - ifFalse.d;
+    if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent <= opinionA.a) {
+      correction = safeCorrectionTerm(
+        (1 - opinionA.a) * opinionA.u * (intermediateDisbelief - ifTrue.d) * beliefGap,
+        projectedAntecedent * childBaseRate * disbeliefGap
+      ) ?? 0;
+    } else if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent > opinionA.a) {
+      correction = safeCorrectionTerm(
+        (1 - opinionA.a) * opinionA.u * (intermediateBelief - ifTrue.b),
+        projectedAntecedentComplement * childBaseRate
+      ) ?? 0;
+    } else if (projectedVacuousDeduction > projectedConditionalA && projectedAntecedent <= opinionA.a) {
+      correction = safeCorrectionTerm(
+        opinionA.a * opinionA.u * (intermediateDisbelief - ifTrue.d),
+        projectedAntecedent * (1 - childBaseRate)
+      ) ?? 0;
+    } else {
+      correction = safeCorrectionTerm(
+        opinionA.a * opinionA.u * (intermediateBelief - ifTrue.b) * disbeliefGap,
+        projectedAntecedentComplement * (1 - childBaseRate) * beliefGap
+      ) ?? 0;
+    }
+  }
+  return opinion(
+    intermediateBelief - childBaseRate * correction,
+    intermediateDisbelief - (1 - childBaseRate) * correction,
+    intermediateUncertainty + correction,
+    childBaseRate
+  );
+}
+function negate(o) {
+  return { b: o.d, d: o.b, u: o.u, a: 1 - o.a };
+}
+function constraintFusion(left, right, mode = "pressure") {
+  if (mode === "redistribute") {
+    const leftProjected = project(left);
+    const rightProjected = project(right);
+    const total = leftProjected + rightProjected;
+    if (total <= 1) {
+      return { o1: left, o2: right };
+    }
+    const scale = 1 / total;
+    return {
+      o1: opinion(
+        left.b * scale,
+        left.d + left.b * (1 - scale),
+        left.u,
+        left.a
+      ),
+      o2: opinion(
+        right.b * scale,
+        right.d + right.b * (1 - scale),
+        right.u,
+        right.a
+      )
+    };
+  }
+  const pressureLeft = right.b * 0.5;
+  const pressureRight = left.b * 0.5;
+  return {
+    o1: opinion(
+      left.b - pressureLeft * 0.3,
+      left.d + pressureLeft * 0.3,
+      left.u,
+      left.a
+    ),
+    o2: opinion(
+      right.b - pressureRight * 0.3,
+      right.d + pressureRight * 0.3,
+      right.u,
+      right.a
+    )
+  };
+}
+function evidenceBalance(o) {
+  const total = o.b + o.d;
+  if (total === 0) {
+    return 0;
+  }
+  return (o.b - o.d) / total;
+}
+function areTensioned(left, right) {
+  return project(left) > 0.5 && project(right) > 0.5 && (left.d > 0.2 || right.d > 0.2);
+}
+function informationGain(o) {
+  if (o.u === 0) {
+    return 0;
+  }
+  if (o.u === 1) {
+    return 1;
+  }
+  return o.u * (1 - Math.abs(o.b - o.d));
+}
+
+// src/v1/operations/scoring.ts
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function confidenceFromOpinion(opinion2) {
+  return clamp01(opinion2.b + opinion2.a * opinion2.u);
+}
+function toStoredOpinionFields(opinion2) {
+  return {
+    belief: opinion2.b,
+    disbelief: opinion2.d,
+    uncertainty: opinion2.u,
+    baseRate: opinion2.a
+  };
+}
+function readOpinionFromRecord(source, fallback = {}) {
+  const record = source && typeof source === "object" ? source : {};
+  return {
+    b: finiteNumber(record.b) ?? finiteNumber(record.belief) ?? finiteNumber(record.slBelief) ?? finiteNumber(record.opinion_b) ?? fallback.b ?? 0,
+    d: finiteNumber(record.d) ?? finiteNumber(record.disbelief) ?? finiteNumber(record.slDisbelief) ?? finiteNumber(record.opinion_d) ?? fallback.d ?? 0,
+    u: finiteNumber(record.u) ?? finiteNumber(record.uncertainty) ?? finiteNumber(record.slUncertainty) ?? finiteNumber(record.opinion_u) ?? fallback.u ?? 1,
+    a: finiteNumber(record.a) ?? finiteNumber(record.baseRate) ?? finiteNumber(record.slBaseRate) ?? finiteNumber(record.opinion_a) ?? fallback.a ?? 0.5
+  };
+}
+function opinionFromScalar(value, mode, options) {
+  const clampedValue = clamp01(value);
+  const baseRate = clamp01(options?.baseRate ?? 0.5);
+  switch (mode) {
+    case "base_rate":
+      return {
+        b: 0,
+        d: 0,
+        u: 1,
+        a: clampedValue
+      };
+    case "dogmatic":
+      return {
+        b: clampedValue,
+        d: 1 - clampedValue,
+        u: 0,
+        a: baseRate
+      };
+    case "projected_with_u": {
+      const uncertainty = options?.uncertainty;
+      if (uncertainty === void 0) {
+        throw new Error(
+          'opinionFromScalar(value, "projected_with_u") requires options.uncertainty.'
+        );
+      }
+      const clampedUncertainty = clamp01(uncertainty);
+      const evidenceWeight = 1 - clampedUncertainty;
+      return {
+        b: clampedValue * evidenceWeight,
+        d: (1 - clampedValue) * evidenceWeight,
+        u: clampedUncertainty,
+        a: baseRate
+      };
+    }
+  }
+  throw new Error(`Unsupported opinionFromScalar mode: ${mode}`);
+}
+function toDogmaticOpinion(confidence, baseRate = 0.5) {
+  return opinionFromScalar(confidence, "dogmatic", { baseRate });
+}
+function hasProjectedOpinionChanged(current, next, tolerance = 0.01) {
+  return Math.abs(confidenceFromOpinion(next) - confidenceFromOpinion(current)) >= tolerance;
+}
+function toEpochMs(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (value instanceof Date) {
+    const epochMs = value.getTime();
+    return Number.isFinite(epochMs) ? epochMs : void 0;
+  }
+  return void 0;
+}
+function normalizeHalfLifeMs(halfLifeMs) {
+  if (halfLifeMs === void 0 || !Number.isFinite(halfLifeMs)) {
+    return 0;
+  }
+  return Math.max(0, halfLifeMs);
+}
+function temporalDecay(sourceOpinion, now, decayParams) {
+  const halfLifeMs = normalizeHalfLifeMs(decayParams.halfLifeMs);
+  if (halfLifeMs === 0) {
+    return { ...sourceOpinion };
+  }
+  const nowMs = toEpochMs(now);
+  const referenceTimeMs = toEpochMs(decayParams.referenceTime);
+  if (nowMs === void 0 || referenceTimeMs === void 0) {
+    return { ...sourceOpinion };
+  }
+  const ageMs = Math.max(0, nowMs - referenceTimeMs);
+  if (ageMs === 0) {
+    return { ...sourceOpinion };
+  }
+  const retainedEvidenceWeight = Math.pow(0.5, ageMs / halfLifeMs);
+  return trustDiscount(sourceOpinion, retainedEvidenceWeight);
+}
+
+// src/v1/operations/contradiction/detectTupleContradiction.ts
+var DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD = 0.7;
+var DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD = 0.7;
+function normalizeTupleContradictionPolicy(policy = {}) {
+  return {
+    beliefThreshold: clamp01(
+      policy.beliefThreshold ?? DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD
+    ),
+    disbeliefThreshold: clamp01(
+      policy.disbeliefThreshold ?? DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD
+    )
+  };
+}
+function detectTupleContradiction(opinion2, tauB = DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD, tauD = DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD) {
+  return opinion2.b > tauB && opinion2.d > tauD;
+}
+function evaluateTupleContradictionTransition(args) {
+  const policy = normalizeTupleContradictionPolicy(args.policy);
+  const tupleContradicted = detectTupleContradiction(
+    args.opinion,
+    policy.beliefThreshold,
+    policy.disbeliefThreshold
+  );
+  const previousTupleContradicted = Boolean(args.previousTupleContradicted);
+  return {
+    tupleContradicted,
+    crossedIntoTupleContradiction: !previousTupleContradicted && tupleContradicted,
+    crossedOutOfTupleContradiction: previousTupleContradicted && !tupleContradicted,
+    policy
+  };
+}
+
+// src/v1/operations/dynamics/cascade.ts
+function dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode = "continuous", threshold = 0.3) {
+  const dependencyProjection = project(dependencyOpinion);
+  if (mode === "threshold") {
+    if (dependencyProjection < threshold) {
+      return opinion(
+        0,
+        beliefOpinion.d + beliefOpinion.b * 0.5,
+        0.5,
+        beliefOpinion.a
+      );
+    }
+    return beliefOpinion;
+  }
+  const dampingFactor = Math.pow(dependencyProjection, 0.5);
+  return opinion(
+    beliefOpinion.b * dampingFactor,
+    beliefOpinion.d + beliefOpinion.b * (1 - dampingFactor) * 0.3,
+    beliefOpinion.u + beliefOpinion.b * (1 - dampingFactor) * 0.7,
+    beliefOpinion.a
+  );
+}
+function dampedDependencyCascade(dependencyOpinion, beliefOpinion, mode = "continuous") {
+  return {
+    opinion: dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode),
+    operator: "dependency_cascade",
+    rationale: `Damped dependency cascade (${mode}): prerequisite at ${project(
+      dependencyOpinion
+    ).toFixed(2)}`
+  };
+}
+
+// src/v1/operations/dynamics/defeat.ts
+function applyNegativeSupport(source, target, weight, metadata = {}) {
+  if (metadata.constraint === "xor") {
+    const result = constraintFusion(
+      source,
+      target,
+      metadata.normalization ?? "pressure"
+    );
+    return {
+      opinion: result.o2,
+      operator: "constraint_fusion",
+      rationale: `XOR constraint: source belief at ${project(source).toFixed(
+        2
+      )} pressures target`
+    };
+  }
+  const discounted = trustDiscount(negate(source), Math.abs(weight));
+  return {
+    opinion: cumulativeFusion(target, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Contradicting evidence (weight=${weight.toFixed(
+      2
+    )}) from source at ${project(source).toFixed(2)}`
+  };
+}
+function applyNegativeEvidence(source, target, weight) {
+  const discounted = trustDiscount(negate(source), Math.abs(weight));
+  return {
+    opinion: cumulativeFusion(target, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Contradicting evidence (weight=${weight.toFixed(2)})`
+  };
+}
+
+// src/v1/operations/dynamics/propagation.ts
+var EDGE_PROPAGATION_RULES = {
+  supports: {
+    direction: "outgoing",
+    handler: (source, target, weight, metadata) => {
+      if (weight < 0) {
+        return applyNegativeSupport(source, target, weight, metadata);
+      }
+      const discounted = trustDiscount(source, weight);
+      return {
+        opinion: cumulativeFusion(target, discounted),
+        operator: "cumulative_fusion",
+        rationale: `Supporting evidence (weight=${weight.toFixed(
+          2
+        )}) from source at ${project(source).toFixed(2)}`
+      };
+    }
+  },
+  informs: {
+    direction: "outgoing",
+    handler: (source, target, weight) => {
+      if (weight < 0) {
+        return applyNegativeEvidence(source, target, weight);
+      }
+      const discounted = trustDiscount(source, Math.abs(weight));
+      return {
+        opinion: cumulativeFusion(target, discounted),
+        operator: "cumulative_fusion",
+        rationale: `Supporting evidence (weight=${weight.toFixed(2)})`
+      };
+    }
+  },
+  depends_on: {
+    direction: "incoming",
+    handler: (source, target, _weight, metadata) => {
+      if (metadata.conditionalA && metadata.conditionalNotA) {
+        return {
+          opinion: conditionalDeduction(
+            source,
+            metadata.conditionalA,
+            metadata.conditionalNotA,
+            target.a
+          ),
+          operator: "conditional_deduction",
+          rationale: `Conditional deduction: prerequisite at ${project(
+            source
+          ).toFixed(2)}`
+        };
+      }
+      return dampedDependencyCascade(
+        source,
+        target,
+        metadata.propagation ?? "continuous"
+      );
+    }
+  },
+  derived_from: {
+    direction: "incoming",
+    handler: (_source, target) => ({
+      opinion: target,
+      operator: "trust_discount",
+      rationale: "Provenance edge \u2014 no confidence propagation"
+    })
+  },
+  contains: {
+    direction: "outgoing",
+    handler: (_source, target) => ({
+      opinion: target,
+      operator: "trust_discount",
+      rationale: "Containment edge \u2014 no confidence propagation"
+    })
+  },
+  tests: {
+    direction: "outgoing",
+    handler: (_source, target) => ({
+      opinion: target,
+      operator: "trust_discount",
+      rationale: "Testing edge \u2014 no confidence propagation"
+    })
+  }
+};
+var PROPAGATION_TRAVERSAL_SPECS = Object.entries(EDGE_PROPAGATION_RULES).map(([edgeType, rule]) => ({
+  edgeType,
+  direction: rule.direction
+}));
+function isPropagationEdgeType(edgeType) {
+  return edgeType in EDGE_PROPAGATION_RULES;
+}
+function getPropagationTraversalSpecs() {
+  return PROPAGATION_TRAVERSAL_SPECS;
+}
+function propagateThroughEdge(sourceOpinion, targetOpinion, edgeType, weight = 1, metadata = {}) {
+  const handler = isPropagationEdgeType(edgeType) ? EDGE_PROPAGATION_RULES[edgeType].handler : void 0;
+  if (!handler) {
+    return {
+      opinion: targetOpinion,
+      operator: "manual_assessment",
+      rationale: `Unknown edge type: ${edgeType} \u2014 no propagation`
+    };
+  }
+  return handler(sourceOpinion, targetOpinion, weight, metadata);
+}
+function propagateAllEdges(currentOpinion, incomingEdges) {
+  let result = currentOpinion;
+  const rationales = [];
+  for (const edgeType of ["depends_on", "informs", "supports"]) {
+    for (const incoming of incomingEdges.filter((edge) => edge.edgeType === edgeType)) {
+      const propagated = propagateThroughEdge(
+        incoming.sourceOpinion,
+        result,
+        incoming.edgeType,
+        incoming.weight,
+        incoming.metadata
+      );
+      result = propagated.opinion;
+      rationales.push(propagated.rationale);
+    }
+  }
+  return {
+    opinion: result,
+    operator: "cumulative_fusion",
+    rationale: rationales.join("; ")
+  };
+}
+
+// src/v1/operations/bridge/index.ts
+var DEFAULT_NON_INFORMATIVE_WEIGHT = 2;
+function clamp012(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function clampNonNegative(value) {
+  return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function normalizeNonInformativeWeight(weight) {
+  if (weight === void 0) {
+    return DEFAULT_NON_INFORMATIVE_WEIGHT;
+  }
+  return Number.isFinite(weight) ? Math.max(0, weight) : DEFAULT_NON_INFORMATIVE_WEIGHT;
+}
+function normalizeBaseRateVector(baseRate, size) {
+  if (size === 0) {
+    return [];
+  }
+  const fallback = Array.from({ length: size }, () => 1 / size);
+  if (!baseRate) {
+    return fallback;
+  }
+  if (baseRate.length !== size) {
+    throw new Error(
+      `Base-rate vector length ${baseRate.length} must match evidence vector length ${size}.`
+    );
+  }
+  const normalized = baseRate.map((value) => clampNonNegative(value));
+  const total = normalized.reduce((sum, value) => sum + value, 0);
+  if (total === 0) {
+    return fallback;
+  }
+  return normalized.map((value) => value / total);
+}
+function opinionFromDirichlet(alpha, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT, baseRate) {
+  const evidence = alpha.map((value) => clampNonNegative(value));
+  const safeWeight = normalizeNonInformativeWeight(nonInformativeWeight);
+  const normalizedBaseRate = normalizeBaseRateVector(baseRate, evidence.length);
+  const totalEvidence = evidence.reduce((sum, value) => sum + value, 0);
+  const denominator = totalEvidence + safeWeight;
+  if (denominator === 0) {
+    return {
+      b: evidence.map(() => 0),
+      u: 1,
+      a: normalizedBaseRate
+    };
+  }
+  return {
+    b: evidence.map((value) => value / denominator),
+    u: safeWeight / denominator,
+    a: normalizedBaseRate
+  };
+}
+function opinionFromBeta(alpha, beta, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT, baseRate = 0.5) {
+  const dirichlet = opinionFromDirichlet(
+    [alpha, beta],
+    nonInformativeWeight,
+    [clamp012(baseRate), 1 - clamp012(baseRate)]
+  );
+  return {
+    b: dirichlet.b[0] ?? 0,
+    d: dirichlet.b[1] ?? 0,
+    u: dirichlet.u,
+    a: dirichlet.a[0] ?? clamp012(baseRate)
+  };
+}
+
+// src/v1/operations/dynamics/revision.ts
+function clamp013(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function toEvidence(probability, weight) {
+  const safeProbability = clamp013(probability);
+  const safeWeight = Number.isFinite(weight) ? Math.max(0, weight) : 0;
+  return {
+    alpha: safeProbability * safeWeight,
+    beta: (1 - safeProbability) * safeWeight
+  };
+}
+function bayesianUpdate(priorConfidence, priorWeight, newAssessment, newWeight, options) {
+  return reviseConfidence({
+    priorConfidence,
+    priorWeight,
+    newAssessment,
+    newWeight,
+    baseRate: options?.baseRate,
+    nonInformativeWeight: options?.nonInformativeWeight
+  });
+}
+function reviseConfidence(args) {
+  return project(reviseConfidenceOpinion(args));
+}
+function reviseConfidenceOpinion(args) {
+  const priorEvidence = toEvidence(args.priorConfidence, args.priorWeight);
+  const newEvidence = toEvidence(args.newAssessment, args.newWeight ?? 1);
+  return opinionFromBeta(
+    priorEvidence.alpha + newEvidence.alpha,
+    priorEvidence.beta + newEvidence.beta,
+    args.nonInformativeWeight ?? DEFAULT_NON_INFORMATIVE_WEIGHT,
+    args.baseRate ?? 0.5
+  );
+}
+
+// src/v1/operations/dynamics/decay.ts
+var DECAY_TIERS = {
+  FRESH: {
+    maxAgeDays: 30,
+    weight: 1,
+    label: "fresh",
+    action: "Full confidence \u2014 recently validated",
+    rescoreInDays: 30
+  },
+  AGING: {
+    maxAgeDays: 90,
+    weight: 0.8,
+    label: "aging",
+    action: "Evidence refresh recommended",
+    rescoreInDays: 14
+  },
+  STALE: {
+    maxAgeDays: 180,
+    weight: 0.5,
+    label: "stale",
+    action: "Evidence update required before trusting",
+    rescoreInDays: 7
+  },
+  EXPIRED: {
+    maxAgeDays: Number.POSITIVE_INFINITY,
+    weight: 0.2,
+    label: "expired",
+    action: "Full re-evaluation needed",
+    rescoreInDays: 0
+  }
+};
+var DEADLINE_URGENCY = {
+  DISTANT: {
+    minDaysToDeadline: 365,
+    urgencyMultiplier: 1,
+    label: "distant",
+    rescoreIntervalDays: 90,
+    action: "Quarterly confidence check"
+  },
+  APPROACHING: {
+    minDaysToDeadline: 180,
+    urgencyMultiplier: 0.9,
+    label: "approaching",
+    rescoreIntervalDays: 30,
+    action: "Monthly confidence check \u2014 conditions may be shifting"
+  },
+  NEAR: {
+    minDaysToDeadline: 90,
+    urgencyMultiplier: 0.75,
+    label: "near",
+    rescoreIntervalDays: 14,
+    action: "Biweekly rescore \u2014 deadline within 3 months"
+  },
+  IMMINENT: {
+    minDaysToDeadline: 30,
+    urgencyMultiplier: 0.6,
+    label: "imminent",
+    rescoreIntervalDays: 7,
+    action: "Weekly rescore \u2014 deadline within 1 month"
+  },
+  CRITICAL: {
+    minDaysToDeadline: 7,
+    urgencyMultiplier: 0.4,
+    label: "critical",
+    rescoreIntervalDays: 1,
+    action: "Daily rescore \u2014 deadline THIS WEEK"
+  },
+  OVERDUE: {
+    minDaysToDeadline: Number.NEGATIVE_INFINITY,
+    urgencyMultiplier: 0.2,
+    label: "overdue",
+    rescoreIntervalDays: 0,
+    action: "OVERDUE \u2014 must validate or archive immediately"
+  }
+};
+function normalizeBeliefConfidence(confidence) {
+  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+    return null;
+  }
+  if (confidence >= 0 && confidence <= 1) {
+    return confidence;
+  }
+  if (confidence > 1 && confidence <= 100) {
+    return confidence / 100;
+  }
+  return null;
+}
+function hasResolvedPredictionOutcome(predictionMeta) {
+  if (!predictionMeta || typeof predictionMeta !== "object") {
+    return false;
+  }
+  const outcome = predictionMeta.outcome;
+  return outcome === "confirmed" || outcome === "disconfirmed" || outcome === "partial" || outcome === "expired";
+}
+function resolveLifecycleBucket(args) {
+  if (normalizeBeliefConfidence(args.confidence) === 0 || normalizeBeliefConfidence(args.confidence) === 1 || hasResolvedPredictionOutcome(args.predictionMeta)) {
+    return "fact";
+  }
+  if (args.beliefStatus === "assumption" || args.beliefStatus === "hypothesis" || args.beliefStatus === "belief" || args.beliefStatus === "fact") {
+    if (normalizeBeliefConfidence(args.confidence) !== null && (args.beliefStatus === "assumption" || args.beliefStatus === "hypothesis")) {
+      return "belief";
+    }
+    return args.beliefStatus;
+  }
+  return "assumption";
+}
+function lifecycleMultiplier(status) {
+  if (status === "assumption") {
+    return 0.65;
+  }
+  if (status === "hypothesis") {
+    return 0.8;
+  }
+  return 1;
+}
+function computeBaseDecay(lastScoredAt) {
+  const ageDays = (Date.now() - lastScoredAt) / (1e3 * 60 * 60 * 24);
+  let tier = DECAY_TIERS.EXPIRED;
+  if (ageDays <= DECAY_TIERS.FRESH.maxAgeDays) {
+    tier = DECAY_TIERS.FRESH;
+  } else if (ageDays <= DECAY_TIERS.AGING.maxAgeDays) {
+    tier = DECAY_TIERS.AGING;
+  } else if (ageDays <= DECAY_TIERS.STALE.maxAgeDays) {
+    tier = DECAY_TIERS.STALE;
+  }
+  return { ageDays, tier, weight: tier.weight };
+}
+function computeDeadlineUrgency(expectedBy) {
+  if (!expectedBy) {
+    return null;
+  }
+  const daysToDeadline = (expectedBy - Date.now()) / (1e3 * 60 * 60 * 24);
+  let urgencyTier = DEADLINE_URGENCY.DISTANT;
+  if (daysToDeadline < 0) {
+    urgencyTier = DEADLINE_URGENCY.OVERDUE;
+  } else if (daysToDeadline <= 7) {
+    urgencyTier = DEADLINE_URGENCY.CRITICAL;
+  } else if (daysToDeadline <= 30) {
+    urgencyTier = DEADLINE_URGENCY.IMMINENT;
+  } else if (daysToDeadline <= 90) {
+    urgencyTier = DEADLINE_URGENCY.NEAR;
+  } else if (daysToDeadline <= 180) {
+    urgencyTier = DEADLINE_URGENCY.APPROACHING;
+  }
+  return {
+    daysToDeadline: Math.round(daysToDeadline),
+    urgencyTier,
+    urgencyMultiplier: urgencyTier.urgencyMultiplier,
+    isOverdue: daysToDeadline < 0
+  };
+}
+function computeEffectiveDecay(lastScoredAt, expectedBy, beliefStatus) {
+  const base = computeBaseDecay(lastScoredAt);
+  const urgency = computeDeadlineUrgency(expectedBy);
+  const effectiveWeight = (urgency ? base.weight * urgency.urgencyMultiplier : base.weight) * lifecycleMultiplier(beliefStatus);
+  const urgencyRescoreDays = urgency?.urgencyTier.rescoreIntervalDays ?? Number.POSITIVE_INFINITY;
+  const rescoreInDays = Math.min(base.tier.rescoreInDays, urgencyRescoreDays);
+  const rescoreByDate = lastScoredAt + rescoreInDays * 24 * 60 * 60 * 1e3;
+  let action = base.tier.action;
+  if (urgency && urgency.urgencyTier.label !== "distant") {
+    action = `${urgency.urgencyTier.action}. ${base.tier.action}`;
+  }
+  return {
+    ageDays: base.ageDays,
+    baseTier: base.tier,
+    baseWeight: base.weight,
+    urgency,
+    effectiveWeight: Math.max(0, Math.min(1, effectiveWeight)),
+    rescoreByDate,
+    rescoreInDays,
+    action
+  };
+}
+function getRescoringSchedule(opts) {
+  const lifecycleStatus = resolveLifecycleBucket({
+    beliefStatus: opts.beliefStatus,
+    confidence: opts.confidence,
+    predictionMeta: opts.predictionMeta
+  });
+  const decayState = computeEffectiveDecay(
+    opts.lastScoredAt,
+    opts.expectedBy,
+    lifecycleStatus
+  );
+  const daysUntilRescore = (decayState.rescoreByDate - Date.now()) / (1e3 * 60 * 60 * 24);
+  const isOverdue = daysUntilRescore < 0;
+  let priority;
+  let reason;
+  if (isOverdue && lifecycleStatus === "assumption") {
+    priority = "critical";
+    reason = `Untested assumption is stale (${Math.round(decayState.ageDays)}d) \u2014 validate or supersede`;
+  } else if (isOverdue && lifecycleStatus === "hypothesis" || lifecycleStatus === "hypothesis" && daysUntilRescore < 7) {
+    priority = "high";
+    reason = `Hypothesis aging without validation (${Math.round(decayState.ageDays)}d) \u2014 run/finish sprint testing`;
+  } else if (decayState.urgency?.isOverdue) {
+    priority = "critical";
+    reason = `Prediction deadline passed ${Math.abs(decayState.urgency.daysToDeadline)}d ago \u2014 validate or archive`;
+  } else if (isOverdue && decayState.baseTier.label === "expired") {
+    priority = "critical";
+    reason = `Not scored in ${Math.round(decayState.ageDays)}d \u2014 confidence severely degraded`;
+  } else if (isOverdue && decayState.baseTier.label === "stale") {
+    priority = "high";
+    reason = `Stale (${Math.round(decayState.ageDays)}d since scoring) \u2014 evidence update required`;
+  } else if (decayState.urgency && decayState.urgency.urgencyTier.label === "critical") {
+    priority = "critical";
+    reason = `Deadline in ${decayState.urgency.daysToDeadline}d \u2014 needs immediate rescoring`;
+  } else if (decayState.urgency && decayState.urgency.urgencyTier.label === "imminent") {
+    priority = "high";
+    reason = `Deadline in ${decayState.urgency.daysToDeadline}d \u2014 weekly rescoring required`;
+  } else if (isOverdue) {
+    priority = "high";
+    reason = `Rescore overdue by ${Math.abs(Math.round(daysUntilRescore))}d`;
+  } else if (opts.temporalNature === "forecast" && daysUntilRescore < 7) {
+    priority = "medium";
+    reason = `Forecast belief \u2014 next rescore due in ${Math.round(daysUntilRescore)}d`;
+  } else if (daysUntilRescore < 14) {
+    priority = "medium";
+    reason = `Rescore due in ${Math.round(daysUntilRescore)}d`;
+  } else {
+    priority = "low";
+    reason = `On schedule \u2014 next rescore in ${Math.round(daysUntilRescore)}d`;
+  }
+  if ((opts.confidence ?? 0) >= 0.8 && decayState.baseTier.label !== "fresh" && priority === "medium") {
+    priority = "high";
+    reason = `High-confidence belief (${((opts.confidence ?? 0) * 100).toFixed(0)}%) aging without rescore \u2014 ${reason}`;
+  }
+  return {
+    nextRescoreBy: decayState.rescoreByDate,
+    daysUntilRescore: Math.round(daysUntilRescore),
+    isOverdue,
+    priority,
+    reason,
+    decay: decayState
+  };
+}
+function decay(current, daysSinceLastUpdate, halfLifeDays = 90) {
+  if (daysSinceLastUpdate <= 0) {
+    return current;
+  }
+  const decayFactor = Math.pow(0.5, daysSinceLastUpdate / halfLifeDays);
+  const certainty = current.b + current.d;
+  const lostCertainty = certainty - certainty * decayFactor;
+  return opinion(
+    current.b * decayFactor,
+    current.d * decayFactor,
+    current.u + lostCertainty,
+    current.a
+  );
+}
+
+// src/v1/operations/contracts/epistemicContract.ts
+var BUILT_IN_METRIC_CHECKER = "metric_checker";
+var BUILT_IN_REFERENCE_CHECK_COUNTER = "reference_check_counter";
+var BUILT_IN_MARKET_INDEX_COMPARATOR = "market_index_comparator";
+function clampConfidence(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function generateContractId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `contract-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function deriveContractStatus(result, currentStatus) {
+  if (currentStatus === "archived") {
+    return currentStatus;
+  }
+  switch (result) {
+    case "confirmed":
+      return "satisfied";
+    case "disconfirmed":
+      return "violated";
+    case "expired":
+      return "expired";
+    default:
+      return currentStatus === "satisfied" || currentStatus === "violated" || currentStatus === "expired" ? "active" : currentStatus;
+  }
+}
+function deriveVerificationTrigger(result) {
+  switch (result) {
+    case "confirmed":
+      return "verification_confirmed";
+    case "disconfirmed":
+      return "verification_disconfirmed";
+    case "expired":
+      return "verification_expired";
+    case "partial":
+      return "verification_partial";
+    default:
+      return null;
+  }
+}
+function deriveContractModulationPlan(args) {
+  const trigger = deriveVerificationTrigger(args.result);
+  if (!trigger) {
+    return null;
+  }
+  if (args.result === "confirmed") {
+    const rawNext = args.currentConfidence + args.modulation.onConfirmed.delta;
+    const confidenceAfter = clampConfidence(
+      Math.min(
+        args.modulation.onConfirmed.ceiling ?? Number.POSITIVE_INFINITY,
+        rawNext
+      )
+    );
+    return {
+      trigger,
+      confidenceBefore: args.currentConfidence,
+      confidenceAfter,
+      confidenceDelta: confidenceAfter - args.currentConfidence
+    };
+  }
+  if (args.result === "disconfirmed") {
+    const rawNext = args.currentConfidence + args.modulation.onDisconfirmed.delta;
+    const confidenceAfter = clampConfidence(
+      Math.max(args.modulation.onDisconfirmed.floor ?? 0, rawNext)
+    );
+    return {
+      trigger,
+      confidenceBefore: args.currentConfidence,
+      confidenceAfter,
+      confidenceDelta: confidenceAfter - args.currentConfidence
+    };
+  }
+  if (args.result === "expired" && args.modulation.onExpired) {
+    const confidenceAfter = clampConfidence(
+      args.currentConfidence + args.modulation.onExpired.delta
+    );
+    return {
+      trigger,
+      confidenceBefore: args.currentConfidence,
+      confidenceAfter,
+      confidenceDelta: confidenceAfter - args.currentConfidence
+    };
+  }
+  if (args.result === "partial" && args.modulation.onPartial) {
+    if ((args.resultConfidence ?? 0) < args.modulation.onPartial.threshold) {
+      return null;
+    }
+    const confidenceAfter = clampConfidence(
+      args.currentConfidence + args.modulation.onPartial.delta
+    );
+    return {
+      trigger,
+      confidenceBefore: args.currentConfidence,
+      confidenceAfter,
+      confidenceDelta: confidenceAfter - args.currentConfidence
+    };
+  }
+  return null;
+}
+function createInheritedContractRecord(contract, args) {
+  return {
+    beliefNodeId: args.beliefNodeId,
+    contractId: generateContractId(),
+    title: contract.title,
+    description: contract.description,
+    conditionType: contract.conditionType,
+    direction: contract.direction,
+    condition: contract.condition,
+    deadline: contract.deadline,
+    compositeOf: contract.compositeOf,
+    compositeOperator: contract.compositeOperator,
+    modulation: contract.modulation,
+    evaluationSchedule: contract.evaluationSchedule,
+    periodicIntervalMs: contract.periodicIntervalMs,
+    status: "active",
+    lineageSource: "inherited",
+    inheritedFromContractId: contract.contractId,
+    inheritedFromBeliefNodeId: contract.beliefNodeId,
+    inheritedAt: args.now,
+    topicId: args.topicId,
+    createdAt: args.now,
+    createdBy: args.createdBy,
+    updatedAt: args.now
+  };
+}
+function normalizeEvidentialAction(value) {
+  return value === "modulate_confidence" || value === "flag_review" || value === "archive" ? value : void 0;
+}
+function parseComparisonOperator(value, evaluatorName) {
+  if (value === "gte" || value === "lte" || value === "eq" || value === "gt" || value === "lt") {
+    return value;
+  }
+  throw new Error(
+    `${evaluatorName} requires operator to be one of gte, lte, eq, gt, or lt.`
+  );
+}
+function parseNumericThreshold(value, evaluatorName) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  throw new Error(`${evaluatorName} requires a finite numeric threshold.`);
+}
+function pickFiniteNumber(config, keys) {
+  for (const key of keys) {
+    const value = config[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function getEvaluatorInputRecord(inputData, nestedKey) {
+  if (!inputData || typeof inputData !== "object") {
+    return {};
+  }
+  const root = inputData;
+  const nested = root[nestedKey];
+  if (nested && typeof nested === "object") {
+    return nested;
+  }
+  return root;
+}
+function parseEvidentialEvaluatorConfig(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error(
+      "Evidential contracts require condition.evaluatorConfig with metric/operator/threshold."
+    );
+  }
+  const config = value;
+  const metric = config.metric;
+  const operator = config.operator;
+  const threshold = config.threshold;
+  if (metric !== "evidence_count" && metric !== "contradiction_status" && metric !== "edge_freshness" && metric !== "dependent_count") {
+    throw new Error(`Unsupported evidential metric: ${String(metric)}`);
+  }
+  if (operator !== "gte" && operator !== "lte" && operator !== "eq" && operator !== "gt" && operator !== "lt") {
+    throw new Error(`Unsupported evidential operator: ${String(operator)}`);
+  }
+  if (typeof threshold !== "number" || !Number.isFinite(threshold)) {
+    throw new Error("Evidential contracts require a numeric threshold.");
+  }
+  const actionParams = config.actionParams && typeof config.actionParams === "object" && config.actionParams !== null ? config.actionParams : void 0;
+  return {
+    metric,
+    operator,
+    threshold,
+    action: normalizeEvidentialAction(config.action),
+    actionParams: actionParams && (typeof actionParams.targetConfidence === "number" || typeof actionParams.rationale === "string") ? {
+      targetConfidence: typeof actionParams.targetConfidence === "number" ? actionParams.targetConfidence : void 0,
+      rationale: typeof actionParams.rationale === "string" ? actionParams.rationale : void 0
+    } : void 0
+  };
+}
+function compareMetricValue(operator, left, right) {
+  switch (operator) {
+    case "gte":
+      return left >= right;
+    case "lte":
+      return left <= right;
+    case "eq":
+      return left === right;
+    case "gt":
+      return left > right;
+    case "lt":
+      return left < right;
+    default:
+      return false;
+  }
+}
+function resolveComparisonResult(direction, comparisonSatisfied) {
+  return direction === "falsifies" ? comparisonSatisfied ? "disconfirmed" : "confirmed" : comparisonSatisfied ? "confirmed" : "disconfirmed";
+}
+function buildComparisonRationale(args) {
+  const renderedObserved = args.observedValue === null ? "no data" : `${args.observedValue}${args.unit ? ` ${args.unit}` : ""}`;
+  const renderedThreshold = `${args.threshold}${args.unit ? ` ${args.unit}` : ""}`;
+  const clause = `${args.label} observed ${renderedObserved} against ${args.operator} ${renderedThreshold}`;
+  if (args.observedValue === null) {
+    return `${clause}; evaluator returned ${args.result} because no current data was available.`;
+  }
+  return `${clause}; comparison ${args.comparisonSatisfied ? "passed" : "failed"}, resulting in ${args.result}.`;
+}
+function buildEvidentialRationale(args) {
+  const observed = args.snapshot.value === null ? "no data" : String(args.snapshot.value);
+  const clause = `${args.snapshot.metric} observed ${observed} against ${args.config.operator} ${args.config.threshold}`;
+  if (args.snapshot.value === null) {
+    return `${clause}; evidential evaluator treated the comparison as unmet, resulting in ${args.result}.`;
+  }
+  return `${clause}; comparison ${args.comparisonSatisfied ? "passed" : "failed"}, resulting in ${args.result}.`;
+}
+function parseMetricCheckerConfig(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error(
+      "metric_checker requires condition.evaluatorConfig with observedValue/operator/threshold."
+    );
+  }
+  const config = value;
+  return {
+    metric: typeof config.metric === "string" && config.metric.length > 0 ? config.metric : void 0,
+    operator: parseComparisonOperator(config.operator, BUILT_IN_METRIC_CHECKER),
+    threshold: parseNumericThreshold(config.threshold, BUILT_IN_METRIC_CHECKER),
+    observedValue: pickFiniteNumber(config, ["observedValue", "value"]),
+    currentValue: pickFiniteNumber(config, ["currentValue"]),
+    metricValue: pickFiniteNumber(config, ["metricValue"]),
+    unit: typeof config.unit === "string" && config.unit.length > 0 ? config.unit : void 0
+  };
+}
+function parseReferenceCheckCounterConfig(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error(
+      "reference_check_counter requires condition.evaluatorConfig with tag/operator/threshold."
+    );
+  }
+  const config = value;
+  if (typeof config.tag !== "string" || config.tag.trim().length === 0) {
+    throw new Error("reference_check_counter requires a non-empty tag.");
+  }
+  return {
+    tag: config.tag.trim(),
+    operator: parseComparisonOperator(
+      config.operator,
+      BUILT_IN_REFERENCE_CHECK_COUNTER
+    ),
+    threshold: parseNumericThreshold(
+      config.threshold,
+      BUILT_IN_REFERENCE_CHECK_COUNTER
+    ),
+    caseSensitive: config.caseSensitive === true
+  };
+}
+function parseTemporalDeadlineConfig(value) {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  const config = value;
+  return {
+    label: typeof config.label === "string" && config.label.length > 0 ? config.label : void 0,
+    completed: config.completed === true,
+    completedAt: pickFiniteNumber(config, ["completedAt"]),
+    observedAt: pickFiniteNumber(config, ["observedAt"]),
+    satisfiedAt: pickFiniteNumber(config, ["satisfiedAt"]),
+    achievedAt: pickFiniteNumber(config, ["achievedAt"])
+  };
+}
+function parseMarketIndexComparatorConfig(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error(
+      "market_index_comparator requires condition.evaluatorConfig with subjectValue/benchmarkValue/operator/threshold."
+    );
+  }
+  const config = value;
+  return {
+    subject: typeof config.subject === "string" && config.subject.length > 0 ? config.subject : void 0,
+    subjectValue: pickFiniteNumber(config, ["subjectValue", "leftValue"]),
+    primaryValue: pickFiniteNumber(config, ["primaryValue"]),
+    benchmark: typeof config.benchmark === "string" && config.benchmark.length > 0 ? config.benchmark : void 0,
+    benchmarkValue: pickFiniteNumber(config, ["benchmarkValue", "rightValue"]),
+    comparisonValue: pickFiniteNumber(config, ["comparisonValue"]),
+    operator: parseComparisonOperator(
+      config.operator,
+      BUILT_IN_MARKET_INDEX_COMPARATOR
+    ),
+    threshold: parseNumericThreshold(
+      config.threshold,
+      BUILT_IN_MARKET_INDEX_COMPARATOR
+    )
+  };
+}
+
+// src/v1/operations/lucern.ts
+var LUCERN_SPECIFIC_OPERATOR_NAMES = [
+  "clamp01",
+  "toStoredOpinionFields",
+  "readOpinionFromRecord",
+  "opinionFromScalar",
+  "temporalDecay",
+  "toDogmaticOpinion",
+  "hasProjectedOpinionChanged",
+  "normalizeTupleContradictionPolicy",
+  "detectTupleContradiction",
+  "evaluateTupleContradictionTransition",
+  "confidenceLevel",
+  "constraintFusion",
+  "evidenceBalance",
+  "areTensioned",
+  "informationGain",
+  "isPropagationEdgeType",
+  "getPropagationTraversalSpecs",
+  "propagateThroughEdge",
+  "propagateAllEdges",
+  "bayesianUpdate",
+  "reviseConfidence",
+  "computeBaseDecay",
+  "computeDeadlineUrgency",
+  "computeEffectiveDecay",
+  "getRescoringSchedule",
+  "decay",
+  "applyNegativeSupport",
+  "applyNegativeEvidence",
+  "deriveContractStatus",
+  "deriveVerificationTrigger",
+  "deriveContractModulationPlan",
+  "createInheritedContractRecord",
+  "normalizeEvidentialAction",
+  "parseComparisonOperator",
+  "parseNumericThreshold",
+  "pickFiniteNumber",
+  "getEvaluatorInputRecord",
+  "parseEvidentialEvaluatorConfig",
+  "compareMetricValue",
+  "resolveComparisonResult",
+  "buildComparisonRationale",
+  "buildEvidentialRationale",
+  "parseMetricCheckerConfig",
+  "parseReferenceCheckCounterConfig",
+  "parseTemporalDeadlineConfig",
+  "parseMarketIndexComparatorConfig"
+];
+
+export { LUCERN_SPECIFIC_OPERATOR_NAMES, applyNegativeEvidence, applyNegativeSupport, areTensioned, bayesianUpdate, buildComparisonRationale, buildEvidentialRationale, clamp01, compareMetricValue, computeBaseDecay, computeDeadlineUrgency, computeEffectiveDecay, confidenceLevel, constraintFusion, createInheritedContractRecord, decay, deriveContractModulationPlan, deriveContractStatus, deriveVerificationTrigger, detectTupleContradiction, evaluateTupleContradictionTransition, evidenceBalance, getEvaluatorInputRecord, getPropagationTraversalSpecs, getRescoringSchedule, hasProjectedOpinionChanged, informationGain, isPropagationEdgeType, normalizeEvidentialAction, normalizeTupleContradictionPolicy, opinionFromScalar, parseComparisonOperator, parseEvidentialEvaluatorConfig, parseMarketIndexComparatorConfig, parseMetricCheckerConfig, parseNumericThreshold, parseReferenceCheckCounterConfig, parseTemporalDeadlineConfig, pickFiniteNumber, propagateAllEdges, propagateThroughEdge, readOpinionFromRecord, resolveComparisonResult, reviseConfidence, temporalDecay, toDogmaticOpinion, toStoredOpinionFields };
+//# sourceMappingURL=lucern.js.map
+//# sourceMappingURL=lucern.js.map