@lucern/confidence 0.1.0-alpha.2

package/dist/index.js

@@ -0,0 +1,1833 @@
+// 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 dogmatic(probability, baseRate = 0.5) {
+  const p = Math.max(0, Math.min(1, probability));
+  return { b: p, d: 1 - p, u: 0, 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 averagingFusion(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;
+  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,
+    2 * 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 conditionalAbduction(opinionY, ifTrue, ifFalse, baseRateX) {
+  const priorX = Math.max(0, Math.min(1, baseRateX));
+  const probabilityY = project(opinionY);
+  const probabilityGivenTrue = project(ifTrue);
+  const probabilityGivenFalse = project(ifFalse);
+  const posteriorIfYDenominator = probabilityGivenTrue * priorX + probabilityGivenFalse * (1 - priorX);
+  const posteriorIfY = posteriorIfYDenominator === 0 ? priorX : probabilityGivenTrue * priorX / posteriorIfYDenominator;
+  const posteriorIfNotYDenominator = (1 - probabilityGivenTrue) * priorX + (1 - probabilityGivenFalse) * (1 - priorX);
+  const posteriorIfNotY = posteriorIfNotYDenominator === 0 ? priorX : (1 - probabilityGivenTrue) * priorX / posteriorIfNotYDenominator;
+  const projectedX = probabilityY * posteriorIfY + (1 - probabilityY) * posteriorIfNotY;
+  const uncertainty = Math.max(
+    opinionY.u * 0.5,
+    probabilityY * ifTrue.u + (1 - probabilityY) * ifFalse.u
+  );
+  return opinion(
+    projectedX * (1 - uncertainty),
+    (1 - projectedX) * (1 - uncertainty),
+    uncertainty,
+    priorX
+  );
+}
+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/temporalDecay.ts
+var DEFAULT_TEMPORAL_DECAY_HALF_LIFE_MS = 90 * 24 * 60 * 60 * 1e3;
+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/bridge/index.ts
+var DEFAULT_NON_INFORMATIVE_WEIGHT = 2;
+function clamp01(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 projectDirichletOpinion(opinion2) {
+  return opinion2.b.map(
+    (belief, index) => belief + (opinion2.a[index] ?? 0) * opinion2.u
+  );
+}
+function opinionFromBeta(alpha, beta, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT, baseRate = 0.5) {
+  const dirichlet = opinionFromDirichlet(
+    [alpha, beta],
+    nonInformativeWeight,
+    [clamp01(baseRate), 1 - clamp01(baseRate)]
+  );
+  return {
+    b: dirichlet.b[0] ?? 0,
+    d: dirichlet.b[1] ?? 0,
+    u: dirichlet.u,
+    a: dirichlet.a[0] ?? clamp01(baseRate)
+  };
+}
+function betaFromOpinion(opinion2, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT) {
+  if (opinion2.u === 0) {
+    return {
+      alpha: Number.POSITIVE_INFINITY,
+      beta: Number.POSITIVE_INFINITY
+    };
+  }
+  const safeWeight = normalizeNonInformativeWeight(nonInformativeWeight);
+  const scale = safeWeight / opinion2.u;
+  return {
+    alpha: opinion2.b * scale,
+    beta: opinion2.d * scale
+  };
+}
+
+// src/v1/operations/scoring.ts
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function clamp012(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function confidenceFromOpinion(opinion2) {
+  return clamp012(opinion2.b + opinion2.a * opinion2.u);
+}
+function confidenceFromSL(belief, _disbelief, uncertainty, baseRate = 0.5) {
+  return confidenceFromOpinion({
+    b: belief,
+    u: uncertainty,
+    a: baseRate
+  });
+}
+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 = clamp012(value);
+  const baseRate = clamp012(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 = clamp012(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 opinionFromBaseRate(probability) {
+  return vacuous(clamp012(probability));
+}
+function opinionFromDogmatic(probability, baseRate = 0.5) {
+  return dogmatic(clamp012(probability), clamp012(baseRate));
+}
+function opinionFromProjected(probability, uncertainty, baseRate = 0.5) {
+  const p = clamp012(probability);
+  const u = clamp012(uncertainty);
+  const remainingMass = 1 - u;
+  return {
+    b: p * remainingMass,
+    d: (1 - p) * remainingMass,
+    u,
+    a: clamp012(baseRate)
+  };
+}
+function hasProjectedOpinionChanged(current, next, tolerance = 0.01) {
+  return Math.abs(confidenceFromOpinion(next) - confidenceFromOpinion(current)) >= tolerance;
+}
+
+// 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: clamp012(
+      policy.beliefThreshold ?? DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD
+    ),
+    disbeliefThreshold: clamp012(
+      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/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_EVIDENTIAL_EVALUATOR = "evidential";
+var BUILT_IN_EVIDENTIAL_ALIASES = /* @__PURE__ */ new Set([
+  BUILT_IN_EVIDENTIAL_EVALUATOR,
+  "built_in_evidential",
+  "builtin_evidential"
+]);
+var BUILT_IN_METRIC_CHECKER = "metric_checker";
+var BUILT_IN_REFERENCE_CHECK_COUNTER = "reference_check_counter";
+var BUILT_IN_TEMPORAL_DEADLINE = "temporal_deadline";
+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/approximation.ts
+var SL_APPROXIMATION_OPERATOR_NAMES = [
+  "cumulativeFusion",
+  "averagingFusion",
+  "conditionalAbduction",
+  "opinionFromDirichlet",
+  "projectDirichletOpinion",
+  "opinionFromBeta",
+  "betaFromOpinion",
+  "dampedDependencyOpinion",
+  "dampedDependencyCascade"
+];
+
+// src/v1/operations/canonical.ts
+var SL_CANONICAL_OPERATOR_NAMES = [
+  "opinion",
+  "vacuous",
+  "dogmatic",
+  "project",
+  "trustDiscount",
+  "negate",
+  "conditionalDeduction",
+  "confidenceFromOpinion",
+  "confidenceFromSL",
+  "opinionFromBaseRate",
+  "opinionFromDogmatic",
+  "opinionFromProjected"
+];
+
+// 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"
+];
+
+// src/v1/operations/operatorTaxonomy.ts
+var OPERATOR_TAXONOMY_TAGS = [
+  "SL_CANONICAL",
+  "SL_APPROXIMATION",
+  "LUCERN_SPECIFIC"
+];
+var PUBLIC_OPERATOR_EXPORT_NAMES = [
+  ...SL_CANONICAL_OPERATOR_NAMES,
+  ...SL_APPROXIMATION_OPERATOR_NAMES,
+  ...LUCERN_SPECIFIC_OPERATOR_NAMES
+];
+var OPERATOR_TAXONOMY_ENTRIES = [
+  {
+    operator: "opinion",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Constructs the canonical binomial SL opinion tuple and normalizes it into valid mass components."
+  },
+  {
+    operator: "vacuous",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Builds the canonical vacuous opinion with full uncertainty and an explicit base rate."
+  },
+  {
+    operator: "dogmatic",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Builds the canonical dogmatic opinion with zero uncertainty at a projected probability."
+  },
+  {
+    operator: "project",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Implements the canonical SL projected probability formula P = b + a*u."
+  },
+  {
+    operator: "trustDiscount",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Implements standard trust discounting by attenuating belief/disbelief mass and returning the remainder to uncertainty."
+  },
+  {
+    operator: "negate",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Implements canonical opinion negation by swapping belief and disbelief and complementing the base rate."
+  },
+  {
+    operator: "confidenceFromOpinion",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Projects a stored opinion into its canonical scalar probability without adding Lucern-specific heuristics."
+  },
+  {
+    operator: "confidenceFromSL",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Thin wrapper over the canonical SL projection formula for callers that provide tuple components directly."
+  },
+  {
+    operator: "opinionFromBaseRate",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Constructs the canonical vacuous opinion from a prior/base-rate probability."
+  },
+  {
+    operator: "opinionFromDogmatic",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Constructs the canonical dogmatic opinion from a projected probability and base rate."
+  },
+  {
+    operator: "opinionFromProjected",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Reconstructs a valid opinion from projected probability plus explicit uncertainty without changing the SL tuple semantics."
+  },
+  {
+    operator: "cumulativeFusion",
+    tag: "SL_APPROXIMATION",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Implements the cumulative fusion family, but Lucern averages base rates and special-cases dogmatic pairs instead of claiming a verbatim textbook transcription."
+  },
+  {
+    operator: "averagingFusion",
+    tag: "SL_APPROXIMATION",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Implements the averaging fusion family with Lucern-specific base-rate averaging and dogmatic shortcuts."
+  },
+  {
+    operator: "conditionalDeduction",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Implements textbook J\xF8sang conditional deduction over (b, d, u, a) tuples with explicit child base-rate derivation and uncertainty correction."
+  },
+  {
+    operator: "conditionalAbduction",
+    tag: "SL_APPROXIMATION",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Implements inverse conditional reasoning through projected probabilities and a Lucern uncertainty floor rather than a full subjective-network derivation."
+  },
+  {
+    operator: "opinionFromDirichlet",
+    tag: "SL_APPROXIMATION",
+    sourceModule: "operations/bridge/index.ts",
+    rationale: "Bridges multinomial Dirichlet-style evidence counts into opinion mass with a configurable non-informative weight and normalized base-rate vector."
+  },
+  {
+    operator: "projectDirichletOpinion",
+    tag: "SL_APPROXIMATION",
+    sourceModule: "operations/bridge/index.ts",
+    rationale: "Projects a Dirichlet opinion back into a multinomial probability vector rather than into Lucern's scalar node confidence."
+  },
+  {
+    operator: "opinionFromBeta",
+    tag: "SL_APPROXIMATION",
+    sourceModule: "operations/bridge/index.ts",
+    rationale: "Bridges Beta evidence counts into SL opinions, but exposes a configurable non-informative weight instead of locking the canonical bridge to W = 2."
+  },
+  {
+    operator: "betaFromOpinion",
+    tag: "SL_APPROXIMATION",
+    sourceModule: "operations/bridge/index.ts",
+    rationale: "Bridges opinions back to Beta parameters while allowing a configurable non-informative weight and explicit dogmatic infinities."
+  },
+  {
+    operator: "dampedDependencyOpinion",
+    tag: "SL_APPROXIMATION",
+    sourceModule: "operations/dynamics/cascade.ts",
+    rationale: "Approximates dependency propagation with a threshold-or-damping scheme instead of a general SL network inference operator. Used as the fallback when edge metadata lacks explicit conditional opinions."
+  },
+  {
+    operator: "dampedDependencyCascade",
+    tag: "SL_APPROXIMATION",
+    sourceModule: "operations/dynamics/cascade.ts",
+    rationale: "Wraps the damped dependency approximation and records it as dependency_cascade provenance for graph propagation. Fallback path for depends_on when edge conditionals are absent."
+  },
+  {
+    operator: "clamp01",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Implementation helper for Lucern APIs; it has no direct J\xF8sang operator analogue."
+  },
+  {
+    operator: "toStoredOpinionFields",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Serializes opinions into Lucern storage fields rather than implementing an SL algebra operator."
+  },
+  {
+    operator: "readOpinionFromRecord",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Deserializes opinion fields from Lucern record shapes and fallback aliases; it is storage glue, not SL."
+  },
+  {
+    operator: "opinionFromScalar",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Lucern convenience wrapper that multiplexes several scalar-to-opinion construction modes behind one API."
+  },
+  {
+    operator: "temporalDecay",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/temporalDecay.ts",
+    rationale: "Lucern temporal operator that exponentially ages evidential mass back into uncertainty while preserving the prior/base rate."
+  },
+  {
+    operator: "toDogmaticOpinion",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Deprecated Lucern shim retained for compatibility rather than as a canonical SL operator."
+  },
+  {
+    operator: "hasProjectedOpinionChanged",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/scoring.ts",
+    rationale: "Lucern propagation threshold helper that decides whether a write is materially different enough to fan out."
+  },
+  {
+    operator: "normalizeTupleContradictionPolicy",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contradiction/detectTupleContradiction.ts",
+    rationale: "Normalizes Lucern tuple-contradiction thresholds; tuple contradiction is not a standard SL operator."
+  },
+  {
+    operator: "detectTupleContradiction",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contradiction/detectTupleContradiction.ts",
+    rationale: "Lucern heuristic that flags simultaneous high belief and disbelief mass as a first-class contradiction state."
+  },
+  {
+    operator: "evaluateTupleContradictionTransition",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contradiction/detectTupleContradiction.ts",
+    rationale: "Lucern transition helper that turns tuple-contradiction threshold crossings into workflow signals."
+  },
+  {
+    operator: "confidenceLevel",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Buckets opinions into Lucern UI labels; it is not part of J\xF8sang's operator set."
+  },
+  {
+    operator: "constraintFusion",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Lucern exclusivity/XOR heuristic that pressures paired opinions; there is no direct textbook SL operator with this behavior."
+  },
+  {
+    operator: "evidenceBalance",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Lucern analytic helper that summarizes resolved evidence tilt after uncertainty is excluded."
+  },
+  {
+    operator: "areTensioned",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Lucern heuristic for surfacing opinion tension based on projected agreement plus residual disbelief mass."
+  },
+  {
+    operator: "informationGain",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Lucern heuristic score over uncertainty and balance; it is neither Shannon entropy nor a named SL operator."
+  },
+  {
+    operator: "isPropagationEdgeType",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/propagation.ts",
+    rationale: "Lucern dispatch-table guard for graph edge semantics, not an SL algebra operator."
+  },
+  {
+    operator: "getPropagationTraversalSpecs",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/propagation.ts",
+    rationale: "Exposes the pure-module edge traversal ordering used by the local propagation helpers; graph-primitives owns the multi-hop runtime."
+  },
+  {
+    operator: "propagateThroughEdge",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/propagation.ts",
+    rationale: "Compiles Lucern edge types into operator application; the dispatch architecture itself has no direct J\xF8sang analogue."
+  },
+  {
+    operator: "propagateAllEdges",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/propagation.ts",
+    rationale: "Lucern bounded aggregator for ordered 1-hop dispatch results across edge families."
+  },
+  {
+    operator: "bayesianUpdate",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/revision.ts",
+    rationale: "Scalar Bayesian helper retained by Lucern as a fallback revision primitive outside the canonical SL operator family."
+  },
+  {
+    operator: "reviseConfidence",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/revision.ts",
+    rationale: "Lucern wrapper around the scalar Bayesian revision helper rather than a direct SL operator."
+  },
+  {
+    operator: "computeBaseDecay",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/decay.ts",
+    rationale: "Lucern recency heuristic over scored beliefs; decay tiers are a product rule, not part of SL."
+  },
+  {
+    operator: "computeDeadlineUrgency",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/decay.ts",
+    rationale: "Lucern deadline heuristic that modulates rescoring urgency outside the SL literature."
+  },
+  {
+    operator: "computeEffectiveDecay",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/decay.ts",
+    rationale: "Combines Lucern age, lifecycle, and deadline heuristics into an effective decay weight."
+  },
+  {
+    operator: "getRescoringSchedule",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/decay.ts",
+    rationale: "Produces Lucern operational scheduling guidance for rescoring rather than opinion algebra."
+  },
+  {
+    operator: "decay",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/decay.ts",
+    rationale: "Applies Lucern time-decay heuristics to an opinion tuple; it is not a named J\xF8sang operator."
+  },
+  {
+    operator: "applyNegativeSupport",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/defeat.ts",
+    rationale: "Lucern graph-specific defeater wrapper that chooses between XOR pressure and negation-plus-discount-plus-fusion."
+  },
+  {
+    operator: "applyNegativeEvidence",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/defeat.ts",
+    rationale: "Lucern signed-edge wrapper that interprets negative evidence through a composed anti-opinion path."
+  },
+  {
+    operator: "deriveContractStatus",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Lucern contract-lifecycle helper with no direct relation to the SL operator family."
+  },
+  {
+    operator: "deriveVerificationTrigger",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Maps Lucern contract evaluation results into confidence triggers for workflow use."
+  },
+  {
+    operator: "deriveContractModulationPlan",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Computes Lucern confidence deltas from contract outcomes; contracts are a Lucern control surface, not SL."
+  },
+  {
+    operator: "createInheritedContractRecord",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Builds Lucern contract lineage records rather than confidence algebra."
+  },
+  {
+    operator: "normalizeEvidentialAction",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Normalizes Lucern evidential contract actions for workflow execution."
+  },
+  {
+    operator: "parseComparisonOperator",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Parses Lucern contract evaluator configuration; it is not an SL operator."
+  },
+  {
+    operator: "parseNumericThreshold",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Lucern contract-config helper for numeric thresholds."
+  },
+  {
+    operator: "pickFiniteNumber",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Lucern parser utility for evaluator configuration and snapshots."
+  },
+  {
+    operator: "getEvaluatorInputRecord",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Extracts Lucern evaluator payloads from nested runtime records."
+  },
+  {
+    operator: "parseEvidentialEvaluatorConfig",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Parses Lucern evidential contract configuration into a typed evaluator plan."
+  },
+  {
+    operator: "compareMetricValue",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Executes Lucern contract comparison semantics rather than SL tuple algebra."
+  },
+  {
+    operator: "resolveComparisonResult",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Maps Lucern comparison outcomes into contract confirmation or disconfirmation."
+  },
+  {
+    operator: "buildComparisonRationale",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Renders Lucern contract-evaluation explanations for auditability."
+  },
+  {
+    operator: "buildEvidentialRationale",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Renders Lucern evidential evaluator explanations for auditability."
+  },
+  {
+    operator: "parseMetricCheckerConfig",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Parses the Lucern metric-checker contract evaluator."
+  },
+  {
+    operator: "parseReferenceCheckCounterConfig",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Parses the Lucern reference-check counter evaluator."
+  },
+  {
+    operator: "parseTemporalDeadlineConfig",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Parses Lucern deadline-evaluator configuration for time-bounded claims."
+  },
+  {
+    operator: "parseMarketIndexComparatorConfig",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/contracts/epistemicContract.ts",
+    rationale: "Parses the Lucern market-index comparator evaluator."
+  }
+];
+var OPERATOR_TAXONOMY = Object.freeze(
+  Object.fromEntries(
+    OPERATOR_TAXONOMY_ENTRIES.map((entry) => [entry.operator, entry])
+  )
+);
+var OPERATOR_TAXONOMY_BY_TAG = Object.freeze({
+  SL_CANONICAL: SL_CANONICAL_OPERATOR_NAMES,
+  SL_APPROXIMATION: SL_APPROXIMATION_OPERATOR_NAMES,
+  LUCERN_SPECIFIC: LUCERN_SPECIFIC_OPERATOR_NAMES
+});
+
+export { BUILT_IN_EVIDENTIAL_ALIASES, BUILT_IN_EVIDENTIAL_EVALUATOR, BUILT_IN_MARKET_INDEX_COMPARATOR, BUILT_IN_METRIC_CHECKER, BUILT_IN_REFERENCE_CHECK_COUNTER, BUILT_IN_TEMPORAL_DEADLINE, DEADLINE_URGENCY, DECAY_TIERS, DEFAULT_NON_INFORMATIVE_WEIGHT, DEFAULT_TEMPORAL_DECAY_HALF_LIFE_MS, DEFAULT_TUPLE_CONTRADICTION_BELIEF_THRESHOLD, DEFAULT_TUPLE_CONTRADICTION_DISBELIEF_THRESHOLD, OPERATOR_TAXONOMY, OPERATOR_TAXONOMY_BY_TAG, OPERATOR_TAXONOMY_ENTRIES, OPERATOR_TAXONOMY_TAGS, PROPAGATION_TRAVERSAL_SPECS, PUBLIC_OPERATOR_EXPORT_NAMES, applyNegativeEvidence, applyNegativeSupport, areTensioned, averagingFusion, bayesianUpdate, betaFromOpinion, buildComparisonRationale, buildEvidentialRationale, clamp012 as clamp01, compareMetricValue, computeBaseDecay, computeDeadlineUrgency, computeEffectiveDecay, conditionalAbduction, conditionalDeduction, confidenceFromOpinion, confidenceFromSL, confidenceLevel, constraintFusion, createInheritedContractRecord, cumulativeFusion, dampedDependencyCascade, dampedDependencyOpinion, decay, deriveContractModulationPlan, deriveContractStatus, deriveVerificationTrigger, detectTupleContradiction, dogmatic, evaluateTupleContradictionTransition, evidenceBalance, getEvaluatorInputRecord, getPropagationTraversalSpecs, getRescoringSchedule, hasProjectedOpinionChanged, informationGain, isPropagationEdgeType, negate, normalizeEvidentialAction, normalizeTupleContradictionPolicy, opinion, opinionFromBaseRate, opinionFromBeta, opinionFromDirichlet, opinionFromDogmatic, opinionFromProjected, opinionFromScalar, parseComparisonOperator, parseEvidentialEvaluatorConfig, parseMarketIndexComparatorConfig, parseMetricCheckerConfig, parseNumericThreshold, parseReferenceCheckCounterConfig, parseTemporalDeadlineConfig, pickFiniteNumber, project, projectDirichletOpinion, propagateAllEdges, propagateThroughEdge, readOpinionFromRecord, resolveComparisonResult, reviseConfidence, reviseConfidenceOpinion, temporalDecay, toDogmaticOpinion, toStoredOpinionFields, trustDiscount, vacuous };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map