@lucern/confidence 0.3.0-alpha.0 → 0.3.0-alpha.1

package/dist/v1/index.js

@@ -1,8 +1,12 @@
+import { z } from 'zod';
+
+// src/v1/codec.ts
+
 // 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));
+function mkOpinion(belief, disbelief, uncertainty, baseRate) {
+  const b = Number.isFinite(belief) ? Math.max(0, belief) : 0;
+  const d = Number.isFinite(disbelief) ? Math.max(0, disbelief) : 0;
+  const u = Number.isFinite(uncertainty) ? Math.max(0, uncertainty) : 0;
   const a = Math.max(0, Math.min(1, baseRate));
   const sum = b + d + u;
   if (sum === 0) {
@@ -15,12 +19,13 @@ function opinion(belief, disbelief, uncertainty, baseRate = 0.5) {
     a
   };
 }
-function vacuous(baseRate = 0.5) {
-  return { b: 0, d: 0, u: 1, a: baseRate };
+var opinion = mkOpinion;
+function vacuous(baseRate) {
+  return mkOpinion(0, 0, 1, baseRate);
 }
-function dogmatic(probability, baseRate = 0.5) {
+function dogmatic(probability, baseRate) {
   const p = Math.max(0, Math.min(1, probability));
-  return { b: p, d: 1 - p, u: 0, a: baseRate };
+  return mkOpinion(p, 1 - p, 0, baseRate);
 }
 function project(o) {
   return o.b + o.a * o.u;
@@ -217,7 +222,7 @@ function conditionalAbduction(opinionY, ifTrue, ifFalse, baseRateX) {
   );
 }
 function negate(o) {
-  return { b: o.d, d: o.b, u: o.u, a: 1 - o.a };
+  return mkOpinion(o.d, o.b, o.u, 1 - o.a);
 }
 function constraintFusion(left, right, mode = "pressure") {
   if (mode === "redistribute") {
@@ -280,6 +285,43 @@ function informationGain(o) {
   return o.u * (1 - Math.abs(o.b - o.d));
 }
 
+// src/v1/codec.ts
+var SL_EPSILON = 1e-9;
+var SLOpinionRefinement = z.object({
+  b: z.number(),
+  d: z.number(),
+  u: z.number(),
+  a: z.number()
+}).refine((o) => Math.abs(o.b + o.d + o.u - 1) < SL_EPSILON, {
+  message: "SL invariant b+d+u=1 violated"
+});
+function fromStorage(fields) {
+  const sum = fields.belief + fields.disbelief + fields.uncertainty;
+  const opinion2 = mkOpinion(
+    fields.belief,
+    fields.disbelief,
+    fields.uncertainty,
+    fields.baseRate
+  );
+  if (Math.abs(sum - 1) < SL_EPSILON) {
+    return { ok: true, opinion: opinion2 };
+  }
+  return {
+    ok: false,
+    opinion: opinion2,
+    repairNeeded: true,
+    reason: `Stored fields sum to ${sum.toFixed(6)}, not 1; normalized on read`
+  };
+}
+function toStorage(opinion2) {
+  return {
+    belief: opinion2.b,
+    disbelief: opinion2.d,
+    uncertainty: opinion2.u,
+    baseRate: opinion2.a
+  };
+}
+
 // src/v1/operations/temporalDecay.ts
 var DEFAULT_TEMPORAL_DECAY_HALF_LIFE_MS = 90 * 24 * 60 * 60 * 1e3;
 function toEpochMs(value) {
@@ -313,7 +355,10 @@ function temporalDecay(sourceOpinion, now, decayParams) {
     return { ...sourceOpinion };
   }
   const retainedEvidenceWeight = Math.pow(0.5, ageMs / halfLifeMs);
-  return trustDiscount(sourceOpinion, retainedEvidenceWeight);
+  return trustDiscount(
+    mkOpinion(sourceOpinion.b, sourceOpinion.d, sourceOpinion.u, sourceOpinion.a),
+    retainedEvidenceWeight
+  );
 }
 
 // src/v1/operations/bridge/index.ts
@@ -334,10 +379,6 @@ 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}.`
@@ -346,11 +387,11 @@ function normalizeBaseRateVector(baseRate, size) {
   const normalized = baseRate.map((value) => clampNonNegative(value));
   const total = normalized.reduce((sum, value) => sum + value, 0);
   if (total === 0) {
-    return fallback;
+    throw new Error("Base-rate vector must contain at least one positive value.");
   }
   return normalized.map((value) => value / total);
 }
-function opinionFromDirichlet(alpha, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT, baseRate) {
+function opinionFromDirichlet(alpha, nonInformativeWeight, baseRate) {
   const evidence = alpha.map((value) => clampNonNegative(value));
   const safeWeight = normalizeNonInformativeWeight(nonInformativeWeight);
   const normalizedBaseRate = normalizeBaseRateVector(baseRate, evidence.length);
@@ -374,18 +415,18 @@ function projectDirichletOpinion(opinion2) {
     (belief, index) => belief + (opinion2.a[index] ?? 0) * opinion2.u
   );
 }
-function opinionFromBeta(alpha, beta, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT, baseRate = 0.5) {
+function opinionFromBeta(alpha, beta, nonInformativeWeight, baseRate) {
   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)
-  };
+  return mkOpinion(
+    dirichlet.b[0] ?? 0,
+    dirichlet.b[1] ?? 0,
+    dirichlet.u,
+    dirichlet.a[0] ?? clamp01(baseRate)
+  );
 }
 function betaFromOpinion(opinion2, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT) {
   if (opinion2.u === 0) {
@@ -406,13 +447,22 @@ function betaFromOpinion(opinion2, nonInformativeWeight = DEFAULT_NON_INFORMATIV
 function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+function requiredOpinionNumber(label, ...values) {
+  for (const value of values) {
+    const numberValue = finiteNumber(value);
+    if (numberValue !== void 0) {
+      return numberValue;
+    }
+  }
+  throw new Error(`Opinion record is missing required ${label}.`);
+}
 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) {
+function confidenceFromSL(belief, _disbelief, uncertainty, baseRate) {
   return confidenceFromOpinion({
     b: belief,
     u: uncertainty,
@@ -427,34 +477,56 @@ function toStoredOpinionFields(opinion2) {
     baseRate: opinion2.a
   };
 }
-function readOpinionFromRecord(source, fallback = {}) {
+function readOpinionFromRecord(source) {
   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
-  };
+  return mkOpinion(
+    requiredOpinionNumber(
+      "belief",
+      record.b,
+      record.belief,
+      record.slBelief,
+      record.opinion_b
+    ),
+    requiredOpinionNumber(
+      "disbelief",
+      record.d,
+      record.disbelief,
+      record.slDisbelief,
+      record.opinion_d
+    ),
+    requiredOpinionNumber(
+      "uncertainty",
+      record.u,
+      record.uncertainty,
+      record.slUncertainty,
+      record.opinion_u
+    ),
+    requiredOpinionNumber(
+      "baseRate",
+      record.a,
+      record.baseRate,
+      record.slBaseRate,
+      record.opinion_a
+    )
+  );
 }
 function opinionFromScalar(value, mode, options) {
   const clampedValue = clamp012(value);
-  const baseRate = clamp012(options?.baseRate ?? 0.5);
+  const baseRate = options?.baseRate === void 0 ? void 0 : clamp012(options.baseRate);
   switch (mode) {
     case "base_rate":
-      return {
-        b: 0,
-        d: 0,
-        u: 1,
-        a: clampedValue
-      };
+      return mkOpinion(0, 0, 1, clampedValue);
     case "dogmatic":
-      return {
-        b: clampedValue,
-        d: 1 - clampedValue,
-        u: 0,
-        a: baseRate
-      };
+      if (baseRate === void 0) {
+        throw new Error('opinionFromScalar(value, "dogmatic") requires options.baseRate.');
+      }
+      return mkOpinion(clampedValue, 1 - clampedValue, 0, baseRate);
     case "projected_with_u": {
+      if (baseRate === void 0) {
+        throw new Error(
+          'opinionFromScalar(value, "projected_with_u") requires options.baseRate.'
+        );
+      }
       const uncertainty = options?.uncertainty;
       if (uncertainty === void 0) {
         throw new Error(
@@ -463,35 +535,30 @@ function opinionFromScalar(value, mode, options) {
       }
       const clampedUncertainty = clamp012(uncertainty);
       const evidenceWeight = 1 - clampedUncertainty;
-      return {
-        b: clampedValue * evidenceWeight,
-        d: (1 - clampedValue) * evidenceWeight,
-        u: clampedUncertainty,
-        a: baseRate
-      };
+      return mkOpinion(
+        clampedValue * evidenceWeight,
+        (1 - clampedValue) * evidenceWeight,
+        clampedUncertainty,
+        baseRate
+      );
     }
   }
   throw new Error(`Unsupported opinionFromScalar mode: ${mode}`);
 }
-function toDogmaticOpinion(confidence, baseRate = 0.5) {
+function toDogmaticOpinion(confidence, baseRate) {
   return opinionFromScalar(confidence, "dogmatic", { baseRate });
 }
 function opinionFromBaseRate(probability) {
   return vacuous(clamp012(probability));
 }
-function opinionFromDogmatic(probability, baseRate = 0.5) {
+function opinionFromDogmatic(probability, baseRate) {
   return dogmatic(clamp012(probability), clamp012(baseRate));
 }
-function opinionFromProjected(probability, uncertainty, baseRate = 0.5) {
+function opinionFromProjected(probability, uncertainty, baseRate) {
   const p = clamp012(probability);
   const u = clamp012(uncertainty);
   const remainingMass = 1 - u;
-  return {
-    b: p * remainingMass,
-    d: (1 - p) * remainingMass,
-    u,
-    a: clamp012(baseRate)
-  };
+  return mkOpinion(p * remainingMass, (1 - p) * remainingMass, u, clamp012(baseRate));
 }
 function hasProjectedOpinionChanged(current, next, tolerance = 0.01) {
   return Math.abs(confidenceFromOpinion(next) - confidenceFromOpinion(current)) >= tolerance;
@@ -531,7 +598,14 @@ function evaluateTupleContradictionTransition(args) {
 
 // src/v1/operations/dynamics/cascade.ts
 function dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode = "continuous", threshold = 0.3) {
-  const dependencyProjection = project(dependencyOpinion);
+  const dependencyProjection = project(
+    mkOpinion(
+      dependencyOpinion.b,
+      dependencyOpinion.d,
+      dependencyOpinion.u,
+      dependencyOpinion.a
+    )
+  );
   if (mode === "threshold") {
     if (dependencyProjection < threshold) {
       return opinion(
@@ -556,40 +630,49 @@ function dampedDependencyCascade(dependencyOpinion, beliefOpinion, mode = "conti
     opinion: dampedDependencyOpinion(dependencyOpinion, beliefOpinion, mode),
     operator: "dependency_cascade",
     rationale: `Damped dependency cascade (${mode}): prerequisite at ${project(
-      dependencyOpinion
+      mkOpinion(
+        dependencyOpinion.b,
+        dependencyOpinion.d,
+        dependencyOpinion.u,
+        dependencyOpinion.a
+      )
     ).toFixed(2)}`
   };
 }
 
 // src/v1/operations/dynamics/defeat.ts
 function applyNegativeSupport(source, target, weight, metadata = {}) {
+  const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+  const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
   if (metadata.constraint === "xor") {
     const result = constraintFusion(
-      source,
-      target,
+      sourceOpinion,
+      targetOpinion,
       metadata.normalization ?? "pressure"
     );
     return {
       opinion: result.o2,
       operator: "constraint_fusion",
-      rationale: `XOR constraint: source belief at ${project(source).toFixed(
-        2
-      )} pressures target`
+      rationale: `XOR constraint: source belief at ${project(
+        sourceOpinion
+      ).toFixed(2)} pressures target`
     };
   }
-  const discounted = trustDiscount(negate(source), Math.abs(weight));
+  const discounted = trustDiscount(negate(sourceOpinion), Math.abs(weight));
   return {
-    opinion: cumulativeFusion(target, discounted),
+    opinion: cumulativeFusion(targetOpinion, discounted),
     operator: "cumulative_fusion",
     rationale: `Contradicting evidence (weight=${weight.toFixed(
       2
-    )}) from source at ${project(source).toFixed(2)}`
+    )}) from source at ${project(sourceOpinion).toFixed(2)}`
   };
 }
 function applyNegativeEvidence(source, target, weight) {
-  const discounted = trustDiscount(negate(source), Math.abs(weight));
+  const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+  const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
+  const discounted = trustDiscount(negate(sourceOpinion), Math.abs(weight));
   return {
-    opinion: cumulativeFusion(target, discounted),
+    opinion: cumulativeFusion(targetOpinion, discounted),
     operator: "cumulative_fusion",
     rationale: `Contradicting evidence (weight=${weight.toFixed(2)})`
   };
@@ -600,28 +683,32 @@ var EDGE_PROPAGATION_RULES = {
   supports: {
     direction: "outgoing",
     handler: (source, target, weight, metadata) => {
+      const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+      const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
       if (weight < 0) {
-        return applyNegativeSupport(source, target, weight, metadata);
+        return applyNegativeSupport(sourceOpinion, targetOpinion, weight, metadata);
       }
-      const discounted = trustDiscount(source, weight);
+      const discounted = trustDiscount(sourceOpinion, weight);
       return {
-        opinion: cumulativeFusion(target, discounted),
+        opinion: cumulativeFusion(targetOpinion, discounted),
         operator: "cumulative_fusion",
         rationale: `Supporting evidence (weight=${weight.toFixed(
           2
-        )}) from source at ${project(source).toFixed(2)}`
+        )}) from source at ${project(sourceOpinion).toFixed(2)}`
       };
     }
   },
   informs: {
     direction: "outgoing",
     handler: (source, target, weight) => {
+      const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+      const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
       if (weight < 0) {
-        return applyNegativeEvidence(source, target, weight);
+        return applyNegativeEvidence(sourceOpinion, targetOpinion, weight);
       }
-      const discounted = trustDiscount(source, Math.abs(weight));
+      const discounted = trustDiscount(sourceOpinion, Math.abs(weight));
       return {
-        opinion: cumulativeFusion(target, discounted),
+        opinion: cumulativeFusion(targetOpinion, discounted),
         operator: "cumulative_fusion",
         rationale: `Supporting evidence (weight=${weight.toFixed(2)})`
       };
@@ -630,23 +717,35 @@ var EDGE_PROPAGATION_RULES = {
   depends_on: {
     direction: "incoming",
     handler: (source, target, _weight, metadata) => {
+      const sourceOpinion = mkOpinion(source.b, source.d, source.u, source.a);
+      const targetOpinion = mkOpinion(target.b, target.d, target.u, target.a);
       if (metadata.conditionalA && metadata.conditionalNotA) {
         return {
           opinion: conditionalDeduction(
-            source,
-            metadata.conditionalA,
-            metadata.conditionalNotA,
-            target.a
+            sourceOpinion,
+            mkOpinion(
+              metadata.conditionalA.b,
+              metadata.conditionalA.d,
+              metadata.conditionalA.u,
+              metadata.conditionalA.a
+            ),
+            mkOpinion(
+              metadata.conditionalNotA.b,
+              metadata.conditionalNotA.d,
+              metadata.conditionalNotA.u,
+              metadata.conditionalNotA.a
+            ),
+            targetOpinion.a
           ),
           operator: "conditional_deduction",
           rationale: `Conditional deduction: prerequisite at ${project(
-            source
+            sourceOpinion
           ).toFixed(2)}`
         };
       }
       return dampedDependencyCascade(
-        source,
-        target,
+        sourceOpinion,
+        targetOpinion,
         metadata.propagation ?? "continuous"
       );
     }
@@ -752,7 +851,7 @@ function reviseConfidenceOpinion(args) {
     priorEvidence.alpha + newEvidence.alpha,
     priorEvidence.beta + newEvidence.beta,
     args.nonInformativeWeight ?? DEFAULT_NON_INFORMATIVE_WEIGHT,
-    args.baseRate ?? 0.5
+    args.baseRate
   );
 }
 
@@ -1338,6 +1437,7 @@ var SL_APPROXIMATION_OPERATOR_NAMES = [
 
 // src/v1/operations/canonical.ts
 var SL_CANONICAL_OPERATOR_NAMES = [
+  "mkOpinion",
   "opinion",
   "vacuous",
   "dogmatic",
@@ -1355,6 +1455,8 @@ var SL_CANONICAL_OPERATOR_NAMES = [
 // src/v1/operations/lucern.ts
 var LUCERN_SPECIFIC_OPERATOR_NAMES = [
   "clamp01",
+  "fromStorage",
+  "toStorage",
   "toStoredOpinionFields",
   "readOpinionFromRecord",
   "opinionFromScalar",
@@ -1375,6 +1477,7 @@ var LUCERN_SPECIFIC_OPERATOR_NAMES = [
   "propagateAllEdges",
   "bayesianUpdate",
   "reviseConfidence",
+  "reviseConfidenceOpinion",
   "computeBaseDecay",
   "computeDeadlineUrgency",
   "computeEffectiveDecay",
@@ -1414,6 +1517,12 @@ var PUBLIC_OPERATOR_EXPORT_NAMES = [
   ...LUCERN_SPECIFIC_OPERATOR_NAMES
 ];
 var OPERATOR_TAXONOMY_ENTRIES = [
+  {
+    operator: "mkOpinion",
+    tag: "SL_CANONICAL",
+    sourceModule: "operations/subjectiveLogic/index.ts",
+    rationale: "Constructs the canonical binomial SL opinion tuple and normalizes it into valid mass components."
+  },
   {
     operator: "opinion",
     tag: "SL_CANONICAL",
@@ -1546,6 +1655,18 @@ var OPERATOR_TAXONOMY_ENTRIES = [
     sourceModule: "operations/scoring.ts",
     rationale: "Implementation helper for Lucern APIs; it has no direct J\xF8sang operator analogue."
   },
+  {
+    operator: "fromStorage",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "codec.ts",
+    rationale: "Reads Lucern storage fields into a normalized opinion and reports repair metadata; it is storage glue, not SL algebra."
+  },
+  {
+    operator: "toStorage",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "codec.ts",
+    rationale: "Serializes a normalized opinion into Lucern storage fields rather than implementing an SL algebra operator."
+  },
   {
     operator: "toStoredOpinionFields",
     tag: "LUCERN_SPECIFIC",
@@ -1666,6 +1787,12 @@ var OPERATOR_TAXONOMY_ENTRIES = [
     sourceModule: "operations/dynamics/revision.ts",
     rationale: "Lucern wrapper around the scalar Bayesian revision helper rather than a direct SL operator."
   },
+  {
+    operator: "reviseConfidenceOpinion",
+    tag: "LUCERN_SPECIFIC",
+    sourceModule: "operations/dynamics/revision.ts",
+    rationale: "Lucern revision helper that exposes the Beta-bridge opinion behind scalar confidence revision."
+  },
   {
     operator: "computeBaseDecay",
     tag: "LUCERN_SPECIFIC",
@@ -1828,6 +1955,6 @@ var OPERATOR_TAXONOMY_BY_TAG = Object.freeze({
   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 };
+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, SLOpinionRefinement, 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, fromStorage, getEvaluatorInputRecord, getPropagationTraversalSpecs, getRescoringSchedule, hasProjectedOpinionChanged, informationGain, isPropagationEdgeType, mkOpinion, 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, toStorage, toStoredOpinionFields, trustDiscount, vacuous };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map