@lucern/graph-primitives 0.1.0-alpha.2

package/dist/confidencePropagationDispatch.js

@@ -0,0 +1,744 @@
+// ../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
+    )
+  };
+}
+
+// ../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/edges/contains.ts
+var containsPropagationSpec = {
+  edgeType: "contains",
+  direction: "outgoing",
+  transitivity: "none",
+  damping: 1,
+  maxHops: 1,
+  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,
+    normalization: edge.normalization ?? void 0,
+    propagation: edge.propagation ?? void 0,
+    conditionalA: edge.conditionalA ?? void 0,
+    conditionalNotA: edge.conditionalNotA ?? void 0
+  };
+}
+function applyPerHopDamping(sourceOpinion, damping) {
+  if (damping >= 1) {
+    return sourceOpinion;
+  }
+  return trustDiscount(sourceOpinion, Math.max(0, damping));
+}
+function annotateRationale(result, spec, hop) {
+  return {
+    ...result,
+    rationale: `hop=${hop} edge=${spec.edgeType} damping=${spec.damping.toFixed(
+      2
+    )} :: ${result.rationale}`
+  };
+}
+function propagatePositiveSupport(sourceOpinion, targetOpinion, edgeWeight) {
+  const discounted = trustDiscount(sourceOpinion, Math.abs(edgeWeight));
+  return {
+    opinion: cumulativeFusion(targetOpinion, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Supporting evidence (weight=${edgeWeight.toFixed(
+      2
+    )}) from source at ${project(sourceOpinion).toFixed(2)}`
+  };
+}
+function propagatePositiveInform(sourceOpinion, targetOpinion, edgeWeight) {
+  const discounted = trustDiscount(sourceOpinion, Math.abs(edgeWeight));
+  return {
+    opinion: cumulativeFusion(targetOpinion, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Supporting evidence (weight=${edgeWeight.toFixed(2)})`
+  };
+}
+function propagateNegativeSupportWithMetadata(sourceOpinion, targetOpinion, edgeWeight, edge) {
+  return applyNegativeSupport(
+    sourceOpinion,
+    targetOpinion,
+    edgeWeight,
+    readEdgeMetadata(edge)
+  );
+}
+function propagateNegativeInform(sourceOpinion, targetOpinion, edgeWeight) {
+  return applyNegativeEvidence(sourceOpinion, targetOpinion, edgeWeight);
+}
+
+// src/edges/contradicts.ts
+var contradictsPropagationSpec = {
+  edgeType: "contradicts",
+  direction: "bidirectional",
+  transitivity: "none",
+  damping: 0.85,
+  maxHops: 1,
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const negativeWeight = -Math.abs(edge.weight ?? 1);
+    const result = propagateNegativeSupportWithMetadata(
+      dampedSource,
+      targetOpinion,
+      negativeWeight,
+      edge
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  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",
+  transitivity: "damped",
+  damping: 0.8,
+  maxHops: "unbounded",
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const metadata = readEdgeMetadata(edge);
+    if (metadata.conditionalA && metadata.conditionalNotA) {
+      const deducedOpinion = conditionalDeduction(
+        dampedSource,
+        metadata.conditionalA,
+        metadata.conditionalNotA,
+        targetOpinion.a
+      );
+      return annotateRationale(
+        {
+          opinion: deducedOpinion,
+          operator: "conditional_deduction",
+          rationale: `Conditional deduction: prerequisite at ${project(
+            dampedSource
+          ).toFixed(2)}`
+        },
+        context.spec,
+        context.hop
+      );
+    }
+    const result = dampedDependencyCascade(
+      dampedSource,
+      targetOpinion,
+      metadata.propagation ?? "continuous"
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Structural gating. Textbook conditional deduction when edge conditionals exist, otherwise damped dependency cascade through downstream chains."
+};
+
+// src/edges/derivedFrom.ts
+var derivedFromPropagationSpec = {
+  edgeType: "derived_from",
+  direction: "incoming",
+  transitivity: "none",
+  damping: 1,
+  maxHops: 1,
+  operator: () => null,
+  description: "Provenance only. The traversal surface stays explicit, but confidence does not move across derived_from edges."
+};
+
+// src/edges/elaborates.ts
+var elaboratesPropagationSpec = {
+  edgeType: "elaborates",
+  direction: "outgoing",
+  transitivity: "damped",
+  damping: 0.7,
+  maxHops: 2,
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const contextualWeight = Math.min(Math.abs(edge.weight ?? 0.35), 0.35);
+    const result = propagatePositiveInform(
+      dampedSource,
+      targetOpinion,
+      contextualWeight
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Context-rich supporting detail. Elaborates carries a small positive effect with short, damped chaining."
+};
+
+// src/edges/informs.ts
+var informsPropagationSpec = {
+  edgeType: "informs",
+  direction: "outgoing",
+  transitivity: "full",
+  damping: 0.92,
+  maxHops: "unbounded",
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const weight = edge.weight ?? 1;
+    const result = weight < 0 ? propagateNegativeInform(dampedSource, targetOpinion, weight) : propagatePositiveInform(dampedSource, targetOpinion, weight);
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Evidence-bearing influence. Informs can chain through the graph with light per-hop damping."
+};
+
+// src/edges/propagationTypes.ts
+function isPropagationTraversalDirection(direction) {
+  return direction === "outgoing" || direction === "incoming";
+}
+function canTraverseHop(spec, nextHop) {
+  return spec.maxHops === "unbounded" || nextHop <= spec.maxHops;
+}
+function canContinueTransitively(spec, currentHop) {
+  if (spec.transitivity === "none") {
+    return false;
+  }
+  return spec.maxHops === "unbounded" || currentHop < spec.maxHops;
+}
+
+// src/edges/refutes.ts
+var refutesPropagationSpec = {
+  edgeType: "refutes",
+  direction: "outgoing",
+  transitivity: "none",
+  damping: 0.9,
+  maxHops: 1,
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const negativeWeight = -Math.abs(edge.weight ?? 1);
+    const result = propagateNegativeInform(
+      dampedSource,
+      targetOpinion,
+      negativeWeight
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Explicit negative evidence semantics. Refutes is treated as strong one-hop counter-evidence."
+};
+
+// src/edges/supports.ts
+var supportsPropagationSpec = {
+  edgeType: "supports",
+  direction: "outgoing",
+  transitivity: "full",
+  damping: 0.85,
+  maxHops: "unbounded",
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const weight = edge.weight ?? 1;
+    const result = weight < 0 ? propagateNegativeSupportWithMetadata(
+      dampedSource,
+      targetOpinion,
+      weight,
+      edge
+    ) : propagatePositiveSupport(dampedSource, targetOpinion, weight);
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Belief-to-belief influence. Supports chains transitively with moderate per-hop damping."
+};
+
+// src/edges/tests.ts
+var testsPropagationSpec = {
+  edgeType: "tests",
+  direction: "outgoing",
+  transitivity: "none",
+  damping: 1,
+  maxHops: 1,
+  operator: () => null,
+  description: "Interrogation linkage only. Tests edges do not directly move confidence."
+};
+
+// src/edges/index.ts
+var EDGE_PROPAGATION_SPECS = [
+  supportsPropagationSpec,
+  informsPropagationSpec,
+  dependsOnPropagationSpec,
+  derivedFromPropagationSpec,
+  containsPropagationSpec,
+  testsPropagationSpec,
+  contradictsPropagationSpec,
+  refutesPropagationSpec,
+  elaboratesPropagationSpec
+];
+new Map(EDGE_PROPAGATION_SPECS.map((spec) => [spec.edgeType, spec]));
+function getEdgePropagationSpecs() {
+  return EDGE_PROPAGATION_SPECS;
+}
+function getTraversalDirections(direction) {
+  if (isPropagationTraversalDirection(direction)) {
+    return [direction];
+  }
+  return ["outgoing", "incoming"];
+}
+
+// src/workspaceIsolation.ts
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function nodeMatchesWorkspaceReasoningScope(node, scope) {
+  if (!node) {
+    return false;
+  }
+  const scopeTenantId = normalizeScopeValue(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue(scope.workspaceId);
+  const nodeTenantId = normalizeScopeValue(node.tenantId);
+  const nodeWorkspaceId = normalizeScopeValue(node.workspaceId);
+  const epistemicLayer = typeof node.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  if (scopeTenantId && nodeTenantId && scopeTenantId !== nodeTenantId) {
+    return false;
+  }
+  if (epistemicLayer === "ontological" && nodeWorkspaceId === void 0) {
+    return true;
+  }
+  if (!scopeWorkspaceId && node.publicationStatus === "published") {
+    return true;
+  }
+  if (!scopeWorkspaceId) {
+    return nodeWorkspaceId === void 0;
+  }
+  return scopeWorkspaceId === nodeWorkspaceId;
+}
+function edgeMatchesWorkspaceReasoningScope(edge, scope) {
+  if (!edge) {
+    return false;
+  }
+  const scopeTenantId = normalizeScopeValue(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue(scope.workspaceId);
+  const edgeTenantId = normalizeScopeValue(edge.tenantId);
+  const edgeWorkspaceId = normalizeScopeValue(edge.workspaceId);
+  if (scopeTenantId && edgeTenantId && scopeTenantId !== edgeTenantId) {
+    return false;
+  }
+  if (!scopeWorkspaceId) {
+    return edgeWorkspaceId === void 0;
+  }
+  return scopeWorkspaceId === edgeWorkspaceId;
+}
+
+// src/confidencePropagationDispatch.ts
+function resolveTraversalTargetNodeId(edge, direction) {
+  const targetNodeId = direction === "outgoing" ? edge.toNodeId : edge.fromNodeId;
+  return targetNodeId ?? void 0;
+}
+function readNodeOpinion(node) {
+  const metadata = node.metadata ?? {};
+  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 }
+  );
+}
+async function collectConfidencePropagationDispatches(args) {
+  const dispatchesByTargetId = /* @__PURE__ */ new Map();
+  const opinionCache = /* @__PURE__ */ new Map();
+  const nodeCache = /* @__PURE__ */ new Map();
+  const traversalSpecs = args.traversalSpecs ?? getEdgePropagationSpecs();
+  const queue = [
+    {
+      nodeId: args.sourceNodeId,
+      opinion: args.sourceOpinion,
+      hop: 0,
+      visitedNodeIds: /* @__PURE__ */ new Set([String(args.sourceNodeId)])
+    }
+  ];
+  const loadNode = async (nodeId) => {
+    const cacheKey = String(nodeId);
+    if (!nodeCache.has(cacheKey)) {
+      nodeCache.set(cacheKey, await args.getNode(nodeId));
+    }
+    return nodeCache.get(cacheKey) ?? null;
+  };
+  while (queue.length > 0) {
+    const state = queue.shift();
+    if (!state) {
+      continue;
+    }
+    for (const spec of traversalSpecs) {
+      const nextHop = state.hop + 1;
+      if (!canTraverseHop(spec, nextHop)) {
+        continue;
+      }
+      for (const direction of getTraversalDirections(spec.direction)) {
+        const edges = await args.queryEdges({
+          nodeId: state.nodeId,
+          spec,
+          direction,
+          hop: nextHop
+        });
+        for (const edge of edges) {
+          if (args.sourceScope && !edgeMatchesWorkspaceReasoningScope(edge, args.sourceScope)) {
+            continue;
+          }
+          const targetNodeId = resolveTraversalTargetNodeId(edge, direction);
+          if (!targetNodeId) {
+            continue;
+          }
+          if (state.visitedNodeIds.has(String(targetNodeId))) {
+            continue;
+          }
+          const targetNode = await loadNode(targetNodeId);
+          if (!targetNode || targetNode.nodeType !== "belief") {
+            continue;
+          }
+          if (args.sourceScope && !nodeMatchesWorkspaceReasoningScope(targetNode, args.sourceScope)) {
+            continue;
+          }
+          const cacheKey = String(targetNodeId);
+          const targetOpinion = opinionCache.get(cacheKey) ?? readNodeOpinion(targetNode);
+          const result = spec.operator(state.opinion, targetOpinion, edge, {
+            hop: nextHop,
+            sourceNodeId: state.nodeId,
+            targetNodeId,
+            traversedDirection: direction,
+            spec
+          });
+          if (!result || !hasProjectedOpinionChanged(targetOpinion, result.opinion)) {
+            continue;
+          }
+          opinionCache.set(cacheKey, result.opinion);
+          const existingDispatch = dispatchesByTargetId.get(cacheKey);
+          dispatchesByTargetId.set(cacheKey, {
+            targetNodeId,
+            edgeType: spec.edgeType,
+            traversedDirection: direction,
+            weight: edge.weight ?? 1,
+            opinion: result.opinion,
+            operator: result.operator,
+            rationale: existingDispatch ? `${existingDispatch.rationale}; ${result.rationale}` : result.rationale,
+            hop: nextHop
+          });
+          if (canContinueTransitively(spec, nextHop)) {
+            queue.push({
+              nodeId: targetNodeId,
+              opinion: result.opinion,
+              hop: nextHop,
+              visitedNodeIds: /* @__PURE__ */ new Set([
+                ...state.visitedNodeIds,
+                String(targetNodeId)
+              ])
+            });
+          }
+        }
+      }
+    }
+  }
+  return Array.from(dispatchesByTargetId.values()).sort((left, right) => {
+    if (left.hop !== right.hop) {
+      return left.hop - right.hop;
+    }
+    return String(left.targetNodeId).localeCompare(String(right.targetNodeId));
+  });
+}
+
+export { collectConfidencePropagationDispatches };
+//# sourceMappingURL=confidencePropagationDispatch.js.map
+//# sourceMappingURL=confidencePropagationDispatch.js.map