@lucern/graph-primitives 0.3.0-alpha.0 → 0.3.0-alpha.1

package/dist/confidencePropagationDispatch.d.ts

@@ -1,4 +1,4 @@
-import { Opinion, SLOperator } from '@lucern/confidence';
+import { SLOpinion, SLOperator } from '@lucern/confidence';
 import { PropagationEdgeRecord, PropagationEdgeType, PropagationTraversalDirection, EdgePropagationSpec } from './edges/propagationTypes.js';
 
 type PropagationDispatchScope = {
@@ -24,14 +24,14 @@ type ConfidencePropagationDispatch<TNodeId extends string = string> = {
     edgeType: PropagationEdgeType;
     traversedDirection: PropagationTraversalDirection;
     weight: number;
-    opinion: Opinion;
+    opinion: SLOpinion;
     operator: SLOperator;
     rationale: string;
     hop: number;
 };
 declare function collectConfidencePropagationDispatches<TNodeId extends string = string>(args: {
     sourceNodeId: TNodeId;
-    sourceOpinion: Opinion;
+    sourceOpinion: SLOpinion;
     sourceScope?: PropagationDispatchScope;
     traversalSpecs?: readonly EdgePropagationSpec<TNodeId>[];
     queryEdges: (args: {

package/dist/confidencePropagationDispatch.js

@@ -1,296 +1,7 @@
-// ../confidence/src/v1/operations/subjectiveLogic/index.ts
-function opinion(belief, disbelief, uncertainty, baseRate = 0.5) {
-  const b = Math.max(0, Math.min(1, belief));
-  const d = Math.max(0, Math.min(1, disbelief));
-  const u = Math.max(0, Math.min(1, uncertainty));
-  const a = Math.max(0, Math.min(1, baseRate));
-  const sum = b + d + u;
-  if (sum === 0) {
-    return { b: 0, d: 0, u: 1, a };
-  }
-  return {
-    b: b / sum,
-    d: d / sum,
-    u: u / sum,
-    a
-  };
-}
-function vacuous(baseRate = 0.5) {
-  return { b: 0, d: 0, u: 1, a: baseRate };
-}
-function project(o) {
-  return o.b + o.a * o.u;
-}
-function cumulativeFusion(left, right) {
-  if (left.u === 0 && right.u === 0) {
-    return opinion(
-      (left.b + right.b) / 2,
-      (left.d + right.d) / 2,
-      0,
-      (left.a + right.a) / 2
-    );
-  }
-  const k = left.u + right.u - left.u * right.u;
-  if (k === 0) {
-    return vacuous((left.a + right.a) / 2);
-  }
-  return opinion(
-    (left.b * right.u + right.b * left.u) / k,
-    (left.d * right.u + right.d * left.u) / k,
-    left.u * right.u / k,
-    (left.a + right.a) / 2
-  );
-}
-function trustDiscount(sourceOpinion, trust) {
-  const weight = Math.max(0, Math.min(1, Math.abs(trust)));
-  return opinion(
-    weight * sourceOpinion.b,
-    weight * sourceOpinion.d,
-    1 - weight * (sourceOpinion.b + sourceOpinion.d),
-    sourceOpinion.a
-  );
-}
-var EPSILON = 1e-9;
-function childBaseRateFallback(ifTrue, ifFalse, fallbackBaseRate) {
-  if (fallbackBaseRate !== void 0) {
-    return Math.max(0, Math.min(1, fallbackBaseRate));
-  }
-  if (Math.abs(ifTrue.a - ifFalse.a) <= EPSILON) {
-    return ifTrue.a;
-  }
-  return (ifTrue.a + ifFalse.a) / 2;
-}
-function computeConditionalDeductionBaseRate(opinionA, ifTrue, ifFalse, fallbackBaseRate) {
-  const denominator = 1 - opinionA.a * ifTrue.u - (1 - opinionA.a) * ifFalse.u;
-  if (ifTrue.u + ifFalse.u < 2 - EPSILON && Math.abs(denominator) > EPSILON) {
-    const baseRate = (opinionA.a * ifTrue.b + (1 - opinionA.a) * ifFalse.b) / denominator;
-    if (baseRate >= -EPSILON && baseRate <= 1 + EPSILON) {
-      return Math.max(0, Math.min(1, baseRate));
-    }
-  }
-  return fallbackBaseRate;
-}
-function safeCorrectionTerm(numerator, denominator) {
-  if (Math.abs(denominator) <= EPSILON) {
-    return void 0;
-  }
-  const value = numerator / denominator;
-  if (!Number.isFinite(value)) {
-    return void 0;
-  }
-  return Math.max(0, value);
-}
-function conditionalDeduction(opinionA, ifTrue, ifFalse, fallbackBaseRate) {
-  const fallbackChildBaseRate = childBaseRateFallback(
-    ifTrue,
-    ifFalse,
-    fallbackBaseRate
-  );
-  const childBaseRate = computeConditionalDeductionBaseRate(
-    opinionA,
-    ifTrue,
-    ifFalse,
-    fallbackChildBaseRate
-  );
-  const projectedAntecedent = project(opinionA);
-  const projectedAntecedentComplement = 1 - projectedAntecedent;
-  const intermediateBelief = opinionA.b * ifTrue.b + opinionA.d * ifFalse.b + opinionA.u * (ifTrue.b * opinionA.a + ifFalse.b * (1 - opinionA.a));
-  const intermediateDisbelief = opinionA.b * ifTrue.d + opinionA.d * ifFalse.d + opinionA.u * (ifTrue.d * opinionA.a + ifFalse.d * (1 - opinionA.a));
-  const intermediateUncertainty = opinionA.b * ifTrue.u + opinionA.d * ifFalse.u + opinionA.u * (ifTrue.u * opinionA.a + ifFalse.u * (1 - opinionA.a));
-  const projectedVacuousDeduction = ifTrue.b * opinionA.a + ifFalse.b * (1 - opinionA.a) + childBaseRate * (ifTrue.u * opinionA.a + ifFalse.u * (1 - opinionA.a));
-  const projectedConditionalA = ifTrue.b + childBaseRate * (1 - ifTrue.b - ifTrue.d);
-  let correction = 0;
-  if (ifTrue.b > ifFalse.b && ifTrue.d > ifFalse.d || ifTrue.b <= ifFalse.b && ifTrue.d <= ifFalse.d) {
-    correction = 0;
-  } else if (ifTrue.b > ifFalse.b && ifTrue.d <= ifFalse.d) {
-    const beliefGap = ifTrue.b - ifFalse.b;
-    const disbeliefGap = ifFalse.d - ifTrue.d;
-    if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent <= opinionA.a) {
-      correction = safeCorrectionTerm(
-        opinionA.a * opinionA.u * (intermediateBelief - ifTrue.b),
-        projectedAntecedent * childBaseRate
-      ) ?? 0;
-    } else if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent > opinionA.a) {
-      correction = safeCorrectionTerm(
-        opinionA.a * opinionA.u * (intermediateDisbelief - ifTrue.d) * beliefGap,
-        projectedAntecedentComplement * childBaseRate * disbeliefGap
-      ) ?? 0;
-    } else if (projectedVacuousDeduction > projectedConditionalA && projectedAntecedent <= opinionA.a) {
-      correction = safeCorrectionTerm(
-        (1 - opinionA.a) * opinionA.u * (intermediateBelief - ifTrue.b) * disbeliefGap,
-        projectedAntecedent * (1 - childBaseRate) * beliefGap
-      ) ?? 0;
-    } else {
-      correction = safeCorrectionTerm(
-        (1 - opinionA.a) * opinionA.u * (intermediateDisbelief - ifTrue.d),
-        projectedAntecedentComplement * (1 - childBaseRate)
-      ) ?? 0;
-    }
-  } else {
-    const beliefGap = ifFalse.b - ifTrue.b;
-    const disbeliefGap = ifTrue.d - ifFalse.d;
-    if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent <= opinionA.a) {
-      correction = safeCorrectionTerm(
-        (1 - opinionA.a) * opinionA.u * (intermediateDisbelief - ifTrue.d) * beliefGap,
-        projectedAntecedent * childBaseRate * disbeliefGap
-      ) ?? 0;
-    } else if (projectedVacuousDeduction <= projectedConditionalA && projectedAntecedent > opinionA.a) {
-      correction = safeCorrectionTerm(
-        (1 - opinionA.a) * opinionA.u * (intermediateBelief - ifTrue.b),
-        projectedAntecedentComplement * childBaseRate
-      ) ?? 0;
-    } else if (projectedVacuousDeduction > projectedConditionalA && projectedAntecedent <= opinionA.a) {
-      correction = safeCorrectionTerm(
-        opinionA.a * opinionA.u * (intermediateDisbelief - ifTrue.d),
-        projectedAntecedent * (1 - childBaseRate)
-      ) ?? 0;
-    } else {
-      correction = safeCorrectionTerm(
-        opinionA.a * opinionA.u * (intermediateBelief - ifTrue.b) * disbeliefGap,
-        projectedAntecedentComplement * (1 - childBaseRate) * beliefGap
-      ) ?? 0;
-    }
-  }
-  return opinion(
-    intermediateBelief - childBaseRate * correction,
-    intermediateDisbelief - (1 - childBaseRate) * correction,
-    intermediateUncertainty + correction,
-    childBaseRate
-  );
-}
-function negate(o) {
-  return { b: o.d, d: o.b, u: o.u, a: 1 - o.a };
-}
-function constraintFusion(left, right, mode = "pressure") {
-  if (mode === "redistribute") {
-    const leftProjected = project(left);
-    const rightProjected = project(right);
-    const total = leftProjected + rightProjected;
-    if (total <= 1) {
-      return { o1: left, o2: right };
-    }
-    const scale = 1 / total;
-    return {
-      o1: opinion(
-        left.b * scale,
-        left.d + left.b * (1 - scale),
-        left.u,
-        left.a
-      ),
-      o2: opinion(
-        right.b * scale,
-        right.d + right.b * (1 - scale),
-        right.u,
-        right.a
-      )
-    };
-  }
-  const pressureLeft = right.b * 0.5;
-  const pressureRight = left.b * 0.5;
-  return {
-    o1: opinion(
-      left.b - pressureLeft * 0.3,
-      left.d + pressureLeft * 0.3,
-      left.u,
-      left.a
-    ),
-    o2: opinion(
-      right.b - pressureRight * 0.3,
-      right.d + pressureRight * 0.3,
-      right.u,
-      right.a
-    )
-  };
-}
+import { conditionalDeduction, mkOpinion, project, dampedDependencyCascade, trustDiscount, applyNegativeSupport, cumulativeFusion, applyNegativeEvidence, hasProjectedOpinionChanged, readOpinionFromRecord } from '@lucern/confidence';
+import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
 
-// ../confidence/src/v1/operations/scoring.ts
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function clamp01(value) {
-  return Math.max(0, Math.min(1, value));
-}
-function confidenceFromOpinion(opinion2) {
-  return clamp01(opinion2.b + opinion2.a * opinion2.u);
-}
-function 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 hasProjectedOpinionChanged(current, next, tolerance = 0.01) {
-  return Math.abs(confidenceFromOpinion(next) - confidenceFromOpinion(current)) >= tolerance;
-}
-
-// ../confidence/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)}`
-  };
-}
-
-// ../confidence/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/confidencePropagationDispatch.ts
 
 // src/edges/contains.ts
 var containsPropagationSpec = {
@@ -302,8 +13,6 @@ var containsPropagationSpec = {
   operator: () => null,
   description: "Structural containment only. Traversed for explicit semantics, but it never propagates opinions."
 };
-
-// src/edges/utils.ts
 function readEdgeMetadata(edge) {
   return {
     constraint: edge.constraint ?? void 0,
@@ -380,8 +89,6 @@ var contradictsPropagationSpec = {
   },
   description: "Legacy contradiction edges move negative pressure in either direction, but never beyond one hop."
 };
-
-// src/edges/dependsOn.ts
 var dependsOnPropagationSpec = {
   edgeType: "depends_on",
   direction: "incoming",
@@ -397,8 +104,18 @@ var dependsOnPropagationSpec = {
     if (metadata.conditionalA && metadata.conditionalNotA) {
       const deducedOpinion = conditionalDeduction(
         dampedSource,
-        metadata.conditionalA,
-        metadata.conditionalNotA,
+        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
       );
       return annotateRationale(
@@ -570,8 +287,6 @@ function getTraversalDirections(direction) {
   }
   return ["outgoing", "incoming"];
 }
-
-// src/workspaceIsolation.ts
 function normalizeScopeValue(value) {
   if (typeof value !== "string") {
     return;
@@ -626,16 +341,17 @@ function resolveTraversalTargetNodeId(edge, direction) {
 }
 function readNodeOpinion(node) {
   const metadata = node.metadata ?? {};
-  return readOpinionFromRecord(
-    {
+  try {
+    return readOpinionFromRecord({
       ...metadata,
       opinion_b: node.opinion_b,
       opinion_d: node.opinion_d,
       opinion_u: node.opinion_u,
       opinion_a: node.opinion_a
-    },
-    { b: 0, d: 0, u: 1, a: 0.5 }
-  );
+    });
+  } catch {
+    return mkOpinion(0, 0, 1, 0.5);
+  }
 }
 async function collectConfidencePropagationDispatches(args) {
   const dispatchesByTargetId = /* @__PURE__ */ new Map();
@@ -704,14 +420,20 @@ async function collectConfidencePropagationDispatches(args) {
           if (!result || !hasProjectedOpinionChanged(targetOpinion, result.opinion)) {
             continue;
           }
-          opinionCache.set(cacheKey, result.opinion);
+          const projectedOpinion = mkOpinion(
+            result.opinion.b,
+            result.opinion.d,
+            result.opinion.u,
+            result.opinion.a
+          );
+          opinionCache.set(cacheKey, projectedOpinion);
           const existingDispatch = dispatchesByTargetId.get(cacheKey);
           dispatchesByTargetId.set(cacheKey, {
             targetNodeId,
             edgeType: spec.edgeType,
             traversedDirection: direction,
             weight: edge.weight ?? 1,
-            opinion: result.opinion,
+            opinion: projectedOpinion,
             operator: result.operator,
             rationale: existingDispatch ? `${existingDispatch.rationale}; ${result.rationale}` : result.rationale,
             hop: nextHop
@@ -719,7 +441,7 @@ async function collectConfidencePropagationDispatches(args) {
           if (canContinueTransitively(spec, nextHop)) {
             queue.push({
               nodeId: targetNodeId,
-              opinion: result.opinion,
+              opinion: projectedOpinion,
               hop: nextHop,
               visitedNodeIds: /* @__PURE__ */ new Set([
                 ...state.visitedNodeIds,