@cavelang/fusion 0.34.0 → 0.36.0

package/README.md

@@ -24,18 +24,103 @@ For normally distributed estimates with `+/- Δ` at kσ: σ = Δ/k, precision
 - posterior mean μ = Σ wᵢxᵢ / Σ wᵢ
 - posterior σ = 1 / √(Σ wᵢ)
 
-`estimateOf(claim)` extracts `{ mean, sigma, conf }` from any numeric claim
-carrying `+/-` uncertainty (attribute or metric payload); claims without a
-usable estimate and zero-confidence estimates are skipped. Invalid zero,
+`estimateOf(claim)` extracts `{ mean, sigma, conf }` plus the optional `unit`
+from a numeric claim carrying `+/-` uncertainty (attribute or metric payload).
+It returns `undefined` without a numeric payload or uncertainty. `fuseClaims`
+omits those claims, and fusion skips zero-confidence estimates after validation.
+Extraction validates the returned estimate's finite mean and confidence in
+`[0, 1]`, including structurally constructed claims that bypass `Claim.of`.
+Invalid values throw `RangeError` even at zero confidence; a valid
+zero-confidence claim still extracts an estimate, which `fuse` subsequently skips.
+These helpers operate on the supplied occurrences: they do not resolve store
+history, deduplicate claims or group source contexts. Supplying an old estimate
+beside its zero-confidence retraction still includes the old estimate. Repeating
+an estimate four times contributes four times its precision and halves its
+posterior sigma. Select current evidence for the intended snapshot and quantity,
+and account for repeated or correlated observations before calling `fuseClaims`.
+Invalid zero,
 negative, or non-finite σ values throw the same typed core uncertainty error
-used by parsed and constructed claims. The spec's worked example is a test
+used by parsed and constructed claims. `estimateOf` also validates sigma after
+converting the uncertainty unit to the value's unit: overflow or underflow
+throws `Uncertainty.InvalidUncertaintyError` instead of returning an infinite
+or zero spread. Finite, positive converted spreads remain valid, including
+representable subnormal values. The spec's worked example is a test
 case verbatim.
 
+`estimateOf` captures the payload's numeric value and unit and the uncertainty's
+magnitude and unit once. Sigma calculation and unit conversion use those captured
+fields, so changing getters cannot mix separate uncertainty observations.
+
+`fuse` captures each estimate's mean, sigma, confidence and unit once before
+validation and calculation. `noisyAndIndependent` validates and multiplies each
+condition value in one pass, still validating later conditions after a zero.
+`normalizeHypotheses` captures each confidence and its enumerable metadata before
+normalizing. Getter-backed inputs therefore cannot substitute an unvalidated
+second value during calculation. Inherited confidence fields and enumerable
+symbol metadata retain their normal meaning; normalization returns fresh objects.
+
+All confidence inputs to fusion and the conditional/hypothesis helpers must be
+finite probabilities in `[0, 1]`; invalid values throw `RangeError`. Estimate
+means must also be finite. Every estimate is validated before zero-confidence
+entries are skipped. Omitted or `undefined` estimate confidence defaults to 1;
+explicit `null` is invalid. A supplied estimate unit must be a string, otherwise
+validation throws `TypeError`, even on a zero-confidence estimate. Arbitrary
+string units retain the exact-match rules below.
+Fusion normalizes weights and means to avoid intermediate
+overflow and uses compensated summation for both total weight and posterior mean
+contributions. This retains the combined precision of many weak estimates beside
+a strong estimate and smaller mean contributions beside large opposing estimates.
+Subnormal means are scaled by a power of two before weighting, and a finite
+compensated weighted sum is divided only once. This avoids erasing representable
+tiny averages through premature rounding, including equal means with unequal
+weights and small residuals after cancellation. If the unnormalized weighted
+sum overflows, or subnormal weighted products contribute to a subnormal provisional
+mean, a fallback sums binary64 mean and normalized-weight products as
+exact integers and rounds their quotient once, with halfway cases rounded to
+even. This preserves subnormal residuals even when large estimates cancel and
+individual weighted contributions would round to zero. It also corrects early
+rounding of nonzero subnormal products after cancellation, even when the sum
+never overflows. Other finite sums retain the compensated floating-point path. The fallback does not make unit
+conversion, weight calculation or the entire fusion procedure exact.
+Its integer operands come from finite binary64 means and normalized weights,
+so their widths are bounded by binary64 exponents rather than arbitrary-length
+numeric text. Summing more terms can increase the accumulator width; traversal,
+temporary storage and exact arithmetic still cost more as the estimate count
+grows. These pure synchronous helpers impose no estimate-count limit,
+cancellation check or wall-clock deadline. Callers managing large evidence sets
+must bound that work before calling them.
+The returned mean is bounded to the smallest and largest converted means with
+positive weight, preventing roundoff from extrapolating beyond the evidence.
+In particular, identical converted means retain that exact mean regardless of
+their relative weights.
+After validating all estimates and calculating the posterior precision and spread,
+fusion returns an identical converted mean directly. Mixed signed zeros keep the
+general path. This avoids unnecessary weighted sums and exact fallback work,
+while retaining invalid-input and unrepresentable-precision errors.
+When an individual root precision becomes subnormal or underflows during its
+initial division, normalization uses its separate confidence and spread factors
+when their combined denominator is finite. A representable
+mean contribution can therefore survive even when that unnormalized root
+precision cannot be represented on its own.
+Converted estimates and the posterior's positive precision and spread
+must fit finite JavaScript numbers, otherwise it throws `RangeError` rather than
+returning `NaN`, infinity, or zero precision. This is a numeric representation
+limit, not evidence that an estimate has zero confidence.
+
+Claim, estimate, condition and hypothesis arrays must be dense. A missing array slot
+is invalid evidence and throws, including when a preceding probability is zero.
+Empty arrays retain their usual meanings: no conditions leave claim confidence
+unchanged, fusion and normalization return `undefined`, and an empty hypothesis
+set has gap `-1`.
+
 Fusion preserves units at the library boundary. Missing units combine only
 with missing units, arbitrary units combine only by exact equality, and the
-fixed-duration units `ms`, `s`, `min`, and `h` convert to the first estimate's
+fixed-duration units `ms`, `s`, `min`, and `h` convert to the first positive-confidence estimate's
 unit before weighting. Every other mixture throws a typed `FusionUnitError`;
 adapters surface that same failure instead of maintaining separate checks.
+Reordering usable estimates can therefore change the output unit while retaining
+the same physical mean, spread and precision after conversion. A zero-confidence
+estimate does not select the output unit.
 
 ## Conditional confidence (§10.2)
 
@@ -51,8 +136,62 @@ explicit in the query engine, never silently assumed.
 itself stays manual — new confidences are appended as new claims, which is
 the append-only §9 discipline, not a computation.
 
+Both helpers use compensated summation so many small probabilities alongside a
+dominant hypothesis contribute to the total instead of disappearing one by one
+through rounding. `hypothesisGap` subtracts the unit baseline before combining
+the summation correction, preserving representable excesses and deficits that
+would disappear if the total were first rounded near one. For example,
+`hypothesisGap([1, 2 ** -54])` returns `2 ** -54` rather than zero. Results still
+use JavaScript floating-point precision.
+Normalization returns new records with updated confidences, preserving the
+other enumerable fields and leaving the input records untouched. Empty and
+all-zero sets return `undefined`; equal positive probabilities normalize equally,
+including the smallest positive representable values.
+
+## Fallback cost trial
+
+Run `node scripts/fusion-fallback-bench.mjs` from the repository root. The trial
+uses 128, 1,024 and 8,192 estimates, two untimed warmups and nine single-call
+samples per fixture. Input construction and correctness assertions are outside
+the timer. All samples, runtime details and source hashes are retained in
+[the fusion fallback trial](../../benchmarks/fusion-fallback-review.json).
+Sequential macOS arm64 runs gave these median milliseconds for 8,192 estimates:
+
+| Fixture | Node 24 before | Node 24 after | Node 26 before | Node 26 after |
+|---|---:|---:|---:|---:|
+| Identical mean 42 | 0.923 | 0.969 | 0.847 | 0.858 |
+| Identical MAX_VALUE | 13.770 | 1.184 | 14.013 | 0.895 |
+| Overflow cancellation with tiny residual | 4.635 | 5.144 | 4.473 | 4.715 |
+| Finite cancellation with tiny residual | 4.377 | 4.551 | 3.802 | 5.204 |
+
+“Before” already includes the exact overflow and subnormal-product fallbacks;
+“after” adds the identical-mean shortcut. Both preserve each fixture's expected
+mean, precision and spread. The extreme identical-mean case benefits because it
+previously entered the exact fallback. Ordinary identical means show no material
+improvement at this size, and the unchanged cancellation paths vary between
+runs. These fixed-order samples are bounded measurements, not a workload cap,
+statistical confidence interval or browser performance result. The integer
+fallback still costs more than ordinary fusion and scales with input count.
+
 ## Tests
 
+The fusion cancellation tests compare 768 deterministic ordered cases with an
+independent integer-weight oracle. Powers-of-two uncertainty and confidence
+make scaled weights exact small integers; opposite large means cancel
+analytically, leaving a rational number of `MIN_VALUE` units. The oracle rounds
+that rational directly, without using the fallback's binary64 decomposition.
+Cases vary signed tiny means, input order, uncertainty, confidence, cancelling
+pair count, and large magnitudes of 1 or MAX_VALUE. They check mean and precision.
+This validates a bounded cancellation family, not arbitrary floating-point
+inputs, unit-conversion rounding or a general exact-fusion guarantee.
+
+The hypothesis-gap tests compare 768 ordered near-unit calculations against
+BigInt sums of exactly representable binary fractions. The fixtures include
+positive, negative and zero gaps and three input orders; they independently
+check the cancellation boundary without using the floating-point summation
+implementation as the expected result. This is bounded numerical coverage,
+not a claim of correctly rounded results for every possible probability set.
+
 ```
 pnpm --filter @cavelang/fusion test
 ```

package/dist/src/conditional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conditional.d.ts","sourceRoot":"","sources":["../../src/conditional.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,WAAW,MAAM,EAAE,gBAAgB,SAAS,MAAM,EAAE,KAAG,MACtB,CAAA;AAErE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACrE,YAAY,SAAS,CAAC,EAAE,KACvB,SAAS,GAAG,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAM7C,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MACT,CAAA"}
+{"version":3,"file":"conditional.d.ts","sourceRoot":"","sources":["../../src/conditional.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAmBH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,WAAW,MAAM,EAAE,gBAAgB,SAAS,MAAM,EAAE,KAAG,MAQ1F,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACrE,YAAY,SAAS,CAAC,EAAE,KACvB,SAAS,GAAG,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAU7C,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MAExD,CAAA"}

package/dist/src/conditional.js

@@ -10,11 +10,34 @@
  * silently assumed for all domains (spec §10.2); hence the deliberately
  * loud function name.
  */
+import { validateConfidence } from "./validate.js";
+/** Neumaier summation retains small probabilities beside a dominant value. */
+const confidenceTotal = (values, confidence, baseline = 0) => {
+    let total = 0;
+    let correction = 0;
+    for (const value of values) {
+        const conf = confidence(value);
+        validateConfidence(conf);
+        const next = total + conf;
+        correction += total >= conf ? (total - next) + conf : (conf - next) + total;
+        total = next;
+    }
+    // Subtract the baseline before rounding away a small correction near one.
+    return (total - baseline) + correction;
+};
 /**
  * Noisy-AND under an explicit independence assumption:
  * `noisyAndIndependent(0.8, [0.6])` → 0.48 (spec §10.2's example).
  */
-export const noisyAndIndependent = (claimConf, conditionConfs) => conditionConfs.reduce((product, conf) => product * conf, claimConf);
+export const noisyAndIndependent = (claimConf, conditionConfs) => {
+    validateConfidence(claimConf);
+    let product = claimConf;
+    for (const conf of conditionConfs) {
+        validateConfidence(conf);
+        product *= conf;
+    }
+    return product;
+};
 /**
  * Normalizes an exhaustive hypothesis set so confidences sum to 1
  * (spec §10.3: "confidences of an exhaustive hypothesis set should sum to
@@ -22,7 +45,11 @@ export const noisyAndIndependent = (claimConf, conditionConfs) => conditionConfs
  * @returns `undefined` when every confidence is 0.
  */
 export const normalizeHypotheses = (hypotheses) => {
-    const total = hypotheses.reduce((sum, hypothesis) => sum + hypothesis.conf, 0);
+    hypotheses = Array.from(hypotheses, hypothesis => {
+        const { conf, ...metadata } = hypothesis;
+        return { ...metadata, conf };
+    });
+    const total = confidenceTotal(hypotheses, hypothesis => hypothesis.conf);
     if (!(total > 0)) {
         return undefined;
     }
@@ -32,5 +59,7 @@ export const normalizeHypotheses = (hypotheses) => {
  * @returns how far a hypothesis set is from exhaustive (Σ conf − 1);
  * ≈0 for a well-formed set, negative when probability mass is missing.
  */
-export const hypothesisGap = (confs) => confs.reduce((sum, conf) => sum + conf, 0) - 1;
+export const hypothesisGap = (confs) => {
+    return confidenceTotal(confs, conf => conf, 1);
+};
 //# sourceMappingURL=conditional.js.map

package/dist/src/conditional.js.map

@@ -1 +1 @@
-{"version":3,"file":"conditional.js","sourceRoot":"","sources":["../../src/conditional.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,SAAiB,EAAE,cAAiC,EAAU,EAAE,CAClG,cAAc,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC,OAAO,GAAG,IAAI,EAAE,SAAS,CAAC,CAAA;AAErE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,UAAwB,EACuB,EAAE;IACjD,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,CAAC,GAAG,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IAC9E,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC;QACjB,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,OAAO,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,UAAU,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,GAAG,KAAK,EAAE,CAAC,CAAC,CAAA;AACzF,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAwB,EAAU,EAAE,CAChE,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA"}
+{"version":3,"file":"conditional.js","sourceRoot":"","sources":["../../src/conditional.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAElD,8EAA8E;AAC9E,MAAM,eAAe,GAAG,CAAI,MAAoB,EAAE,UAAgC,EAAE,QAAQ,GAAG,CAAC,EAAU,EAAE;IAC1G,IAAI,KAAK,GAAG,CAAC,CAAA;IACb,IAAI,UAAU,GAAG,CAAC,CAAA;IAClB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;QAC9B,kBAAkB,CAAC,IAAI,CAAC,CAAA;QACxB,MAAM,IAAI,GAAG,KAAK,GAAG,IAAI,CAAA;QACzB,UAAU,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,KAAK,CAAA;QAC3E,KAAK,GAAG,IAAI,CAAA;IACd,CAAC;IACD,0EAA0E;IAC1E,OAAO,CAAC,KAAK,GAAG,QAAQ,CAAC,GAAG,UAAU,CAAA;AACxC,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,SAAiB,EAAE,cAAiC,EAAU,EAAE;IAClG,kBAAkB,CAAC,SAAS,CAAC,CAAA;IAC7B,IAAI,OAAO,GAAG,SAAS,CAAA;IACvB,KAAK,MAAM,IAAI,IAAI,cAAc,EAAE,CAAC;QAClC,kBAAkB,CAAC,IAAI,CAAC,CAAA;QACxB,OAAO,IAAI,IAAI,CAAA;IACjB,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,UAAwB,EACuB,EAAE;IACjD,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE;QAC/C,MAAM,EAAE,IAAI,EAAE,GAAG,QAAQ,EAAE,GAAG,UAAU,CAAA;QACxC,OAAO,EAAE,GAAG,QAAQ,EAAE,IAAI,EAAO,CAAA;IACnC,CAAC,CAAC,CAAA;IACF,MAAM,KAAK,GAAG,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;IACxE,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC;QACjB,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,OAAO,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,UAAU,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,GAAG,KAAK,EAAE,CAAC,CAAC,CAAA;AACzF,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAwB,EAAU,EAAE;IAChE,OAAO,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;AAChD,CAAC,CAAA"}

package/dist/src/fuse.d.ts

@@ -13,7 +13,7 @@
  * CAVE itself only stores claims and metadata.
  */
 import { Claim } from '@cavelang/core';
-/** One numeric estimate: mean, σ, and confidence weight p ∈ (0, 1]. */
+/** One numeric estimate: finite mean, positive finite σ, confidence p ∈ [0, 1]. */
 export type Estimate = {
     readonly mean: number;
     readonly sigma: number;
@@ -36,8 +36,9 @@ export declare class FusionUnitError extends Error {
     constructor(units: readonly (string | undefined)[]);
 }
 /**
- * Fuses estimates into a posterior. Estimates with `conf` 0 or a
- * non-positive σ contribute nothing and are skipped.
+ * Fuses finite estimates into a posterior. Zero-confidence estimates are
+ * skipped after validating every input; invalid inputs and unrepresentable
+ * posteriors throw instead of returning NaN or infinity.
  * @returns `undefined` when no estimate carries usable weight.
  */
 export declare const fuse: (estimates: readonly Estimate[]) => undefined | Posterior;

package/dist/src/fuse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fuse.d.ts","sourceRoot":"","sources":["../../src/fuse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,KAAK,EAAe,MAAM,gBAAgB,CAAA;AAEnD,uEAAuE;AACvE,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,uEAAuE;IACvE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,qCAAqC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAiBD,gFAAgF;AAChF,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAA;gBAEnC,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE;CAOnD;AAED;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAI,WAAW,SAAS,QAAQ,EAAE,KAAG,SAAS,GAAG,SAyBjE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,KAAK,CAAC,CAAC,KAAG,SAAS,GAAG,QAuBvD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,SAAS,KAAK,CAAC,CAAC,EAAE,KAAG,SAAS,GAAG,SAI/D,CAAA"}
+{"version":3,"file":"fuse.d.ts","sourceRoot":"","sources":["../../src/fuse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,KAAK,EAAe,MAAM,gBAAgB,CAAA;AAGnD,mFAAmF;AACnF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,uEAAuE;IACvE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAWD,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,qCAAqC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAiBD,gFAAgF;AAChF,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAA;gBAEnC,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE;CAOnD;AAuCD;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,WAAW,SAAS,QAAQ,EAAE,KAAG,SAAS,GAAG,SAsHjE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,KAAK,CAAC,CAAC,KAAG,SAAS,GAAG,QA4BvD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,SAAS,KAAK,CAAC,CAAC,EAAE,KAAG,SAAS,GAAG,SAOnE,CAAA"}

package/dist/src/fuse.js

@@ -13,6 +13,16 @@
  * CAVE itself only stores claims and metadata.
  */
 import { Claim, Uncertainty } from '@cavelang/core';
+import { validateConfidence } from "./validate.js";
+const validateEstimate = (estimate) => {
+    Uncertainty.validateSigma(estimate.sigma);
+    validateConfidence(estimate.conf === undefined ? 1 : estimate.conf);
+    if (!Number.isFinite(estimate.mean))
+        throw new RangeError('estimate mean must be finite');
+    if (estimate.unit !== undefined && typeof estimate.unit !== 'string') {
+        throw new TypeError('estimate unit must be a string when supplied');
+    }
+};
 const durationScale = {
     ms: 0.001,
     s: 1,
@@ -24,8 +34,8 @@ const conversionFactor = (from, to) => {
         return 1;
     if (from === undefined || to === undefined)
         return undefined;
-    const fromScale = durationScale[from];
-    const toScale = durationScale[to];
+    const fromScale = Object.hasOwn(durationScale, from) ? durationScale[from] : undefined;
+    const toScale = Object.hasOwn(durationScale, to) ? durationScale[to] : undefined;
     return fromScale === undefined || toScale === undefined ? undefined : fromScale / toScale;
 };
 /** Typed boundary failure for estimates that do not share a compatible unit. */
@@ -39,13 +49,58 @@ export class FusionUnitError extends Error {
         this.units = unique;
     }
 }
+/** Sum finite weighted binary64 terms exactly, then round once. Rare overflow/underflow fallback. */
+const exactAverage = (terms, weight) => {
+    const view = new DataView(new ArrayBuffer(8));
+    // Every finite double is an integer multiple of 2^-1074. Using that common
+    // scale preserves tiny residuals even when large partial sums overflow.
+    const units = (value) => {
+        view.setFloat64(0, value);
+        const bits = view.getBigUint64(0);
+        const exponent = Number((bits >> 52n) & 0x7ffn);
+        const fraction = bits & ((1n << 52n) - 1n);
+        const magnitude = exponent === 0 ? fraction : ((1n << 52n) | fraction) << BigInt(exponent - 1);
+        return bits >> 63n === 0n ? magnitude : -magnitude;
+    };
+    let numerator = 0n;
+    for (const term of terms) {
+        const ratio = units(term.ratio);
+        numerator += units(term.mean) * ratio * ratio;
+    }
+    if (numerator === 0n)
+        return 0;
+    const sign = numerator < 0n ? -1 : 1;
+    if (numerator < 0n)
+        numerator = -numerator;
+    // Three factors in each numerator term versus one in the denominator.
+    let denominator = units(weight) << 2148n;
+    // Find the quotient's binary exponent,
+    // then round its 53-bit significand (or subnormal integer) ties to even.
+    let exponent = numerator.toString(2).length - denominator.toString(2).length;
+    if (exponent >= 0 ? numerator < (denominator << BigInt(exponent)) :
+        (numerator << BigInt(-exponent)) < denominator)
+        exponent--;
+    const shift = Math.max(-1074, exponent - 52);
+    if (shift < 0)
+        numerator <<= BigInt(-shift);
+    else
+        denominator <<= BigInt(shift);
+    let rounded = numerator / denominator;
+    const remainder = numerator % denominator;
+    if (remainder * 2n > denominator || (remainder * 2n === denominator && (rounded & 1n) !== 0n))
+        rounded++;
+    return sign * Number(rounded) * 2 ** shift;
+};
 /**
- * Fuses estimates into a posterior. Estimates with `conf` 0 or a
- * non-positive σ contribute nothing and are skipped.
+ * Fuses finite estimates into a posterior. Zero-confidence estimates are
+ * skipped after validating every input; invalid inputs and unrepresentable
+ * posteriors throw instead of returning NaN or infinity.
  * @returns `undefined` when no estimate carries usable weight.
  */
 export const fuse = (estimates) => {
-    estimates.forEach(estimate => Uncertainty.validateSigma(estimate.sigma));
+    estimates = Array.from(estimates, ({ mean, sigma, conf, unit }) => ({ mean, sigma, conf, unit }));
+    for (const estimate of estimates)
+        validateEstimate(estimate);
     const usable = estimates.filter(estimate => (estimate.conf ?? 1) > 0);
     if (usable.length === 0)
         return undefined;
@@ -54,20 +109,114 @@ export const fuse = (estimates) => {
     if (factors.some(factor => factor === undefined)) {
         throw new FusionUnitError(usable.map(estimate => estimate.unit));
     }
-    let totalWeight = 0;
-    let weightedSum = 0;
-    for (const [index, estimate] of usable.entries()) {
-        const conf = estimate.conf ?? 1;
+    let maxRootWeight = 0;
+    let maxMean = 0;
+    let lowestMean = Infinity;
+    let highestMean = -Infinity;
+    const scaled = usable.map((estimate, index) => {
         const factor = factors[index];
         const sigma = estimate.sigma * factor;
-        const weight = conf / (sigma * sigma);
-        totalWeight += weight;
-        weightedSum += weight * estimate.mean * factor;
+        const mean = estimate.mean * factor;
+        if (!Number.isFinite(mean) || !Number.isFinite(sigma) || sigma <= 0) {
+            throw new RangeError('converted estimate is outside the finite numeric range');
+        }
+        const rootConfidence = Math.sqrt(estimate.conf ?? 1);
+        const rootWeight = rootConfidence / sigma;
+        maxRootWeight = Math.max(maxRootWeight, rootWeight);
+        maxMean = Math.max(maxMean, Math.abs(mean));
+        lowestMean = Math.min(lowestMean, mean);
+        highestMean = Math.max(highestMean, mean);
+        return { mean, rootWeight, rootConfidence, sigma };
+    });
+    if (!Number.isFinite(maxRootWeight) || maxRootWeight === 0) {
+        throw new RangeError('posterior precision is outside the finite numeric range');
+    }
+    // A root weight may underflow even though its ratio to a small maximum,
+    // and the resulting weighted mean, are representable. Keep its factors.
+    const ratioOf = (estimate) => {
+        const denominator = estimate.sigma * maxRootWeight;
+        return estimate.rootWeight < 2 ** -1022 && Number.isFinite(denominator)
+            ? estimate.rootConfidence / denominator
+            : estimate.rootWeight / maxRootWeight;
+    };
+    // Normalize before squaring or multiplying by means. Direct σ² and w*x
+    // intermediates can overflow even when the posterior is representable.
+    let totalWeight = 0;
+    let weightCorrection = 0;
+    for (const estimate of scaled) {
+        const weight = ratioOf(estimate) ** 2;
+        const next = totalWeight + weight;
+        weightCorrection += totalWeight >= weight
+            ? (totalWeight - next) + weight : (weight - next) + totalWeight;
+        totalWeight = next;
+    }
+    totalWeight += weightCorrection;
+    const rootPrecision = maxRootWeight * Math.sqrt(totalWeight);
+    const precision = rootPrecision * rootPrecision;
+    const sigma = 1 / rootPrecision;
+    if (!Number.isFinite(precision) || precision === 0 || !Number.isFinite(sigma) || sigma === 0) {
+        throw new RangeError('posterior precision is outside the finite numeric range');
+    }
+    // A convex average of identical converted means is that mean. Precision and
+    // input validation above still apply; Object.is keeps mixed signed zeros on
+    // the general path with its existing rounding behavior.
+    if (Object.is(lowestMean, highestMean)) {
+        return { mean: lowestMean, sigma, precision, ...unit === undefined ? {} : { unit } };
     }
+    // Multiply each root-weight factor separately: squaring a tiny ratio first
+    // could erase a representable contribution from a very large mean.
+    let mean = 0;
+    let meanCorrection = 0;
+    // A power-of-two scale preserves subnormal inputs exactly while preventing
+    // their weighted products from rounding away before they can be added.
+    const meanScale = maxMean > 0 && maxMean < 2 ** -1022 ? 2 ** -1022 : 1;
+    let numerator = 0;
+    let numeratorCorrection = 0;
+    let subnormalProduct = false;
+    for (const estimate of scaled) {
+        const ratio = ratioOf(estimate);
+        const weightedMean = ((estimate.mean / meanScale) * ratio) * ratio;
+        if (estimate.mean !== 0 && ratio !== 0 && Math.abs(weightedMean) < 2 ** -1022)
+            subnormalProduct = true;
+        const numeratorNext = numerator + weightedMean;
+        numeratorCorrection += Math.abs(numerator) >= Math.abs(weightedMean)
+            ? (numerator - numeratorNext) + weightedMean : (weightedMean - numeratorNext) + numerator;
+        numerator = numeratorNext;
+        const contribution = weightedMean / totalWeight;
+        const next = mean + contribution;
+        // Keep small contributions when large positive and negative means cancel.
+        meanCorrection += Math.abs(mean) >= Math.abs(contribution)
+            ? (mean - next) + contribution : (contribution - next) + mean;
+        mean = next;
+    }
+    mean += meanCorrection;
+    // Divide once when possible: separate divisions can erase subnormal terms
+    // that would survive their combined average, including after cancellation.
+    const correctedNumerator = numerator + numeratorCorrection;
+    if (Number.isFinite(correctedNumerator))
+        mean = correctedNumerator / totalWeight;
+    // A finite sum cannot recover contributions already rounded during weighting.
+    // Recompute only when those subnormal products may determine a tiny result.
+    if (!Number.isFinite(correctedNumerator) || (subnormalProduct && Math.abs(mean) < 2 ** -1022)) {
+        mean = exactAverage(scaled.map(estimate => ({
+            mean: estimate.mean / meanScale, ratio: ratioOf(estimate)
+        })), totalWeight);
+    }
+    mean *= meanScale;
+    if (!Number.isFinite(mean)) {
+        // Near Number.MAX_VALUE, rounded convex contributions can sum just beyond
+        // the finite range. Rescale that boundary case before summing.
+        const normalized = scaled.reduce((sum, estimate) => sum +
+            ratioOf(estimate) ** 2 * (estimate.mean / maxMean), 0) / totalWeight;
+        mean = Math.max(-1, Math.min(1, normalized)) * maxMean;
+    }
+    // Positive weights form a convex average. Bound floating-point roundoff to
+    // the converted input interval, including identical and subnormal means.
+    mean = Math.max(lowestMean, Math.min(highestMean, mean));
     return {
-        mean: weightedSum / totalWeight,
-        sigma: 1 / Math.sqrt(totalWeight),
-        precision: totalWeight,
+        mean,
+        sigma,
+        precision,
         ...unit === undefined ? {} : { unit }
     };
 };
@@ -81,31 +230,45 @@ export const estimateOf = (claim) => {
     const value = payload.kind === 'attribute' ? payload.value :
         payload.kind === 'metric' ? payload.value :
             undefined;
-    if (value?.num === undefined) {
+    if (value === undefined)
         return undefined;
-    }
-    const sigma = Claim.sigmaOf(claim);
-    if (sigma === undefined || !(sigma > 0)) {
+    const mean = value.num;
+    if (mean === undefined)
         return undefined;
-    }
-    const factor = conversionFactor(claim.delta?.unit, value.unit);
+    const delta = claim.delta;
+    if (delta === undefined)
+        return undefined;
+    const magnitude = delta.num;
+    if (magnitude === undefined)
+        return undefined;
+    const sigma = Uncertainty.sigma(magnitude, claim.sigmaLevel);
+    const unit = value.unit;
+    const deltaUnit = delta.unit;
+    const factor = conversionFactor(deltaUnit, unit);
     if (factor === undefined) {
-        throw new FusionUnitError([value.unit, claim.delta?.unit]);
+        throw new FusionUnitError([unit, deltaUnit]);
     }
-    return {
-        mean: value.num,
+    const estimate = {
+        mean,
         sigma: sigma * factor,
-        ...value.unit === undefined ? {} : { unit: value.unit },
+        ...unit === undefined ? {} : { unit },
         conf: claim.conf
     };
+    validateEstimate(estimate);
+    return estimate;
 };
 /**
  * Fuses the numeric estimates found in `claims` (spec §10.1's worked
  * example lives in the tests). Claims without usable numeric uncertainty
  * are ignored.
  */
-export const fuseClaims = (claims) => fuse(claims.flatMap(claim => {
-    const estimate = estimateOf(claim);
-    return estimate === undefined ? [] : [estimate];
-}));
+export const fuseClaims = (claims) => {
+    const estimates = [];
+    for (const claim of claims) {
+        const estimate = estimateOf(claim);
+        if (estimate !== undefined)
+            estimates.push(estimate);
+    }
+    return fuse(estimates);
+};
 //# sourceMappingURL=fuse.js.map

package/dist/src/fuse.js.map

@@ -1 +1 @@
-{"version":3,"file":"fuse.js","sourceRoot":"","sources":["../../src/fuse.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fuse.js","sourceRoot":"","sources":["../../src/fuse.ts"],"names":[],"mappings":"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"}

package/dist/src/validate.d.ts

@@ -0,0 +1,3 @@
+/** Shared numeric boundary for probabilities accepted by the fusion API. */
+export declare const validateConfidence: (conf: number) => void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/src/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/validate.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,IAIjD,CAAA"}

package/dist/src/validate.js

@@ -0,0 +1,7 @@
+/** Shared numeric boundary for probabilities accepted by the fusion API. */
+export const validateConfidence = (conf) => {
+    if (!Number.isFinite(conf) || conf < 0 || conf > 1) {
+        throw new RangeError('confidence must be finite and between 0 and 1');
+    }
+};
+//# sourceMappingURL=validate.js.map

package/dist/src/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../src/validate.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,IAAY,EAAQ,EAAE;IACvD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,UAAU,CAAC,+CAA+C,CAAC,CAAA;IACvE,CAAC;AACH,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cavelang/fusion",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "type": "module",
   "description": "CAVE probabilistic layer — Bayesian fusion of numeric estimates, noisy-AND conditional confidence, hypothesis helpers.",
   "keywords": [
@@ -21,7 +21,7 @@
     "directory": "packages/fusion"
   },
   "engines": {
-    "node": "^22.18.0 || ^24.0.0 || ^26.0.0"
+    "node": "^24.16.0 || ^26.1.0"
   },
   "exports": {
     ".": {
@@ -43,7 +43,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cavelang/core": "0.34.0"
+    "@cavelang/core": "0.36.0"
   },
   "scripts": {
     "build": "tsc -b",

package/src/conditional.ts

@@ -11,12 +11,36 @@
  * loud function name.
  */
 
+import { validateConfidence } from './validate.ts'
+
+/** Neumaier summation retains small probabilities beside a dominant value. */
+const confidenceTotal = <T>(values: readonly T[], confidence: (value: T) => number, baseline = 0): number => {
+  let total = 0
+  let correction = 0
+  for (const value of values) {
+    const conf = confidence(value)
+    validateConfidence(conf)
+    const next = total + conf
+    correction += total >= conf ? (total - next) + conf : (conf - next) + total
+    total = next
+  }
+  // Subtract the baseline before rounding away a small correction near one.
+  return (total - baseline) + correction
+}
+
 /**
  * Noisy-AND under an explicit independence assumption:
  * `noisyAndIndependent(0.8, [0.6])` → 0.48 (spec §10.2's example).
  */
-export const noisyAndIndependent = (claimConf: number, conditionConfs: readonly number[]): number =>
-  conditionConfs.reduce((product, conf) => product * conf, claimConf)
+export const noisyAndIndependent = (claimConf: number, conditionConfs: readonly number[]): number => {
+  validateConfidence(claimConf)
+  let product = claimConf
+  for (const conf of conditionConfs) {
+    validateConfidence(conf)
+    product *= conf
+  }
+  return product
+}
 
 /**
  * Normalizes an exhaustive hypothesis set so confidences sum to 1
@@ -27,7 +51,11 @@ export const noisyAndIndependent = (claimConf: number, conditionConfs: readonly
 export const normalizeHypotheses = <T extends { readonly conf: number }>(
   hypotheses: readonly T[]
 ): undefined | (T & { readonly conf: number })[] => {
-  const total = hypotheses.reduce((sum, hypothesis) => sum + hypothesis.conf, 0)
+  hypotheses = Array.from(hypotheses, hypothesis => {
+    const { conf, ...metadata } = hypothesis
+    return { ...metadata, conf } as T
+  })
+  const total = confidenceTotal(hypotheses, hypothesis => hypothesis.conf)
   if (!(total > 0)) {
     return undefined
   }
@@ -38,5 +66,6 @@ export const normalizeHypotheses = <T extends { readonly conf: number }>(
  * @returns how far a hypothesis set is from exhaustive (Σ conf − 1);
  * ≈0 for a well-formed set, negative when probability mass is missing.
  */
-export const hypothesisGap = (confs: readonly number[]): number =>
-  confs.reduce((sum, conf) => sum + conf, 0) - 1
+export const hypothesisGap = (confs: readonly number[]): number => {
+  return confidenceTotal(confs, conf => conf, 1)
+}

package/src/fuse.ts

@@ -14,8 +14,9 @@
  */
 
 import { Claim, Uncertainty } from '@cavelang/core'
+import { validateConfidence } from './validate.ts'
 
-/** One numeric estimate: mean, σ, and confidence weight p ∈ (0, 1]. */
+/** One numeric estimate: finite mean, positive finite σ, confidence p ∈ [0, 1]. */
 export type Estimate = {
   readonly mean: number
   readonly sigma: number
@@ -25,6 +26,15 @@ export type Estimate = {
   readonly conf?: number
 }
 
+const validateEstimate = (estimate: Estimate): void => {
+  Uncertainty.validateSigma(estimate.sigma)
+  validateConfidence(estimate.conf === undefined ? 1 : estimate.conf)
+  if (!Number.isFinite(estimate.mean)) throw new RangeError('estimate mean must be finite')
+  if (estimate.unit !== undefined && typeof estimate.unit !== 'string') {
+    throw new TypeError('estimate unit must be a string when supplied')
+  }
+}
+
 export type Posterior = {
   readonly mean: number
   readonly sigma: number
@@ -44,8 +54,8 @@ const durationScale: Readonly<Record<string, number>> = {
 const conversionFactor = (from: undefined | string, to: undefined | string): undefined | number => {
   if (from === to) return 1
   if (from === undefined || to === undefined) return undefined
-  const fromScale = durationScale[from]
-  const toScale = durationScale[to]
+  const fromScale = Object.hasOwn(durationScale, from) ? durationScale[from] : undefined
+  const toScale = Object.hasOwn(durationScale, to) ? durationScale[to] : undefined
   return fromScale === undefined || toScale === undefined ? undefined : fromScale / toScale
 }
 
@@ -62,13 +72,52 @@ export class FusionUnitError extends Error {
   }
 }
 
+/** Sum finite weighted binary64 terms exactly, then round once. Rare overflow/underflow fallback. */
+const exactAverage = (terms: readonly { mean: number, ratio: number }[], weight: number): number => {
+  const view = new DataView(new ArrayBuffer(8))
+  // Every finite double is an integer multiple of 2^-1074. Using that common
+  // scale preserves tiny residuals even when large partial sums overflow.
+  const units = (value: number): bigint => {
+    view.setFloat64(0, value)
+    const bits = view.getBigUint64(0)
+    const exponent = Number((bits >> 52n) & 0x7ffn)
+    const fraction = bits & ((1n << 52n) - 1n)
+    const magnitude = exponent === 0 ? fraction : ((1n << 52n) | fraction) << BigInt(exponent - 1)
+    return bits >> 63n === 0n ? magnitude : -magnitude
+  }
+  let numerator = 0n
+  for (const term of terms) {
+    const ratio = units(term.ratio)
+    numerator += units(term.mean) * ratio * ratio
+  }
+  if (numerator === 0n) return 0
+  const sign = numerator < 0n ? -1 : 1
+  if (numerator < 0n) numerator = -numerator
+  // Three factors in each numerator term versus one in the denominator.
+  let denominator = units(weight) << 2148n
+  // Find the quotient's binary exponent,
+  // then round its 53-bit significand (or subnormal integer) ties to even.
+  let exponent = numerator.toString(2).length - denominator.toString(2).length
+  if (exponent >= 0 ? numerator < (denominator << BigInt(exponent)) :
+    (numerator << BigInt(-exponent)) < denominator) exponent--
+  const shift = Math.max(-1074, exponent - 52)
+  if (shift < 0) numerator <<= BigInt(-shift)
+  else denominator <<= BigInt(shift)
+  let rounded = numerator / denominator
+  const remainder = numerator % denominator
+  if (remainder * 2n > denominator || (remainder * 2n === denominator && (rounded & 1n) !== 0n)) rounded++
+  return sign * Number(rounded) * 2 ** shift
+}
+
 /**
- * Fuses estimates into a posterior. Estimates with `conf` 0 or a
- * non-positive σ contribute nothing and are skipped.
+ * Fuses finite estimates into a posterior. Zero-confidence estimates are
+ * skipped after validating every input; invalid inputs and unrepresentable
+ * posteriors throw instead of returning NaN or infinity.
  * @returns `undefined` when no estimate carries usable weight.
  */
 export const fuse = (estimates: readonly Estimate[]): undefined | Posterior => {
-  estimates.forEach(estimate => Uncertainty.validateSigma(estimate.sigma))
+  estimates = Array.from(estimates, ({ mean, sigma, conf, unit }) => ({ mean, sigma, conf, unit }))
+  for (const estimate of estimates) validateEstimate(estimate)
   const usable = estimates.filter(estimate => (estimate.conf ?? 1) > 0)
   if (usable.length === 0) return undefined
   const unit = usable[0]!.unit
@@ -76,20 +125,112 @@ export const fuse = (estimates: readonly Estimate[]): undefined | Posterior => {
   if (factors.some(factor => factor === undefined)) {
     throw new FusionUnitError(usable.map(estimate => estimate.unit))
   }
-  let totalWeight = 0
-  let weightedSum = 0
-  for (const [index, estimate] of usable.entries()) {
-    const conf = estimate.conf ?? 1
+  let maxRootWeight = 0
+  let maxMean = 0
+  let lowestMean = Infinity
+  let highestMean = -Infinity
+  const scaled = usable.map((estimate, index) => {
     const factor = factors[index]!
     const sigma = estimate.sigma * factor
-    const weight = conf / (sigma * sigma)
-    totalWeight += weight
-    weightedSum += weight * estimate.mean * factor
+    const mean = estimate.mean * factor
+    if (!Number.isFinite(mean) || !Number.isFinite(sigma) || sigma <= 0) {
+      throw new RangeError('converted estimate is outside the finite numeric range')
+    }
+    const rootConfidence = Math.sqrt(estimate.conf ?? 1)
+    const rootWeight = rootConfidence / sigma
+    maxRootWeight = Math.max(maxRootWeight, rootWeight)
+    maxMean = Math.max(maxMean, Math.abs(mean))
+    lowestMean = Math.min(lowestMean, mean)
+    highestMean = Math.max(highestMean, mean)
+    return { mean, rootWeight, rootConfidence, sigma }
+  })
+  if (!Number.isFinite(maxRootWeight) || maxRootWeight === 0) {
+    throw new RangeError('posterior precision is outside the finite numeric range')
+  }
+  // A root weight may underflow even though its ratio to a small maximum,
+  // and the resulting weighted mean, are representable. Keep its factors.
+  const ratioOf = (estimate: typeof scaled[number]): number => {
+    const denominator = estimate.sigma * maxRootWeight
+    return estimate.rootWeight < 2 ** -1022 && Number.isFinite(denominator)
+      ? estimate.rootConfidence / denominator
+      : estimate.rootWeight / maxRootWeight
+  }
+  // Normalize before squaring or multiplying by means. Direct σ² and w*x
+  // intermediates can overflow even when the posterior is representable.
+  let totalWeight = 0
+  let weightCorrection = 0
+  for (const estimate of scaled) {
+    const weight = ratioOf(estimate) ** 2
+    const next = totalWeight + weight
+    weightCorrection += totalWeight >= weight
+      ? (totalWeight - next) + weight : (weight - next) + totalWeight
+    totalWeight = next
   }
+  totalWeight += weightCorrection
+  const rootPrecision = maxRootWeight * Math.sqrt(totalWeight)
+  const precision = rootPrecision * rootPrecision
+  const sigma = 1 / rootPrecision
+  if (!Number.isFinite(precision) || precision === 0 || !Number.isFinite(sigma) || sigma === 0) {
+    throw new RangeError('posterior precision is outside the finite numeric range')
+  }
+  // A convex average of identical converted means is that mean. Precision and
+  // input validation above still apply; Object.is keeps mixed signed zeros on
+  // the general path with its existing rounding behavior.
+  if (Object.is(lowestMean, highestMean)) {
+    return { mean: lowestMean, sigma, precision, ...unit === undefined ? {} : { unit } }
+  }
+  // Multiply each root-weight factor separately: squaring a tiny ratio first
+  // could erase a representable contribution from a very large mean.
+  let mean = 0
+  let meanCorrection = 0
+  // A power-of-two scale preserves subnormal inputs exactly while preventing
+  // their weighted products from rounding away before they can be added.
+  const meanScale = maxMean > 0 && maxMean < 2 ** -1022 ? 2 ** -1022 : 1
+  let numerator = 0
+  let numeratorCorrection = 0
+  let subnormalProduct = false
+  for (const estimate of scaled) {
+    const ratio = ratioOf(estimate)
+    const weightedMean = ((estimate.mean / meanScale) * ratio) * ratio
+    if (estimate.mean !== 0 && ratio !== 0 && Math.abs(weightedMean) < 2 ** -1022) subnormalProduct = true
+    const numeratorNext = numerator + weightedMean
+    numeratorCorrection += Math.abs(numerator) >= Math.abs(weightedMean)
+      ? (numerator - numeratorNext) + weightedMean : (weightedMean - numeratorNext) + numerator
+    numerator = numeratorNext
+    const contribution = weightedMean / totalWeight
+    const next = mean + contribution
+    // Keep small contributions when large positive and negative means cancel.
+    meanCorrection += Math.abs(mean) >= Math.abs(contribution)
+      ? (mean - next) + contribution : (contribution - next) + mean
+    mean = next
+  }
+  mean += meanCorrection
+  // Divide once when possible: separate divisions can erase subnormal terms
+  // that would survive their combined average, including after cancellation.
+  const correctedNumerator = numerator + numeratorCorrection
+  if (Number.isFinite(correctedNumerator)) mean = correctedNumerator / totalWeight
+  // A finite sum cannot recover contributions already rounded during weighting.
+  // Recompute only when those subnormal products may determine a tiny result.
+  if (!Number.isFinite(correctedNumerator) || (subnormalProduct && Math.abs(mean) < 2 ** -1022)) {
+    mean = exactAverage(scaled.map(estimate => ({
+      mean: estimate.mean / meanScale, ratio: ratioOf(estimate)
+    })), totalWeight)
+  }
+  mean *= meanScale
+  if (!Number.isFinite(mean)) {
+    // Near Number.MAX_VALUE, rounded convex contributions can sum just beyond
+    // the finite range. Rescale that boundary case before summing.
+    const normalized = scaled.reduce((sum, estimate) => sum +
+      ratioOf(estimate) ** 2 * (estimate.mean / maxMean), 0) / totalWeight
+    mean = Math.max(-1, Math.min(1, normalized)) * maxMean
+  }
+  // Positive weights form a convex average. Bound floating-point roundoff to
+  // the converted input interval, including identical and subnormal means.
+  mean = Math.max(lowestMean, Math.min(highestMean, mean))
   return {
-    mean: weightedSum / totalWeight,
-    sigma: 1 / Math.sqrt(totalWeight),
-    precision: totalWeight,
+    mean,
+    sigma,
+    precision,
     ...unit === undefined ? {} : { unit }
   }
 }
@@ -105,23 +246,28 @@ export const estimateOf = (claim: Claim.t): undefined | Estimate => {
     payload.kind === 'attribute' ? payload.value :
     payload.kind === 'metric' ? payload.value :
     undefined
-  if (value?.num === undefined) {
-    return undefined
-  }
-  const sigma = Claim.sigmaOf(claim)
-  if (sigma === undefined || !(sigma > 0)) {
-    return undefined
-  }
-  const factor = conversionFactor(claim.delta?.unit, value.unit)
+  if (value === undefined) return undefined
+  const mean = value.num
+  if (mean === undefined) return undefined
+  const delta = claim.delta
+  if (delta === undefined) return undefined
+  const magnitude = delta.num
+  if (magnitude === undefined) return undefined
+  const sigma = Uncertainty.sigma(magnitude, claim.sigmaLevel)
+  const unit = value.unit
+  const deltaUnit = delta.unit
+  const factor = conversionFactor(deltaUnit, unit)
   if (factor === undefined) {
-    throw new FusionUnitError([value.unit, claim.delta?.unit])
+    throw new FusionUnitError([unit, deltaUnit])
   }
-  return {
-    mean: value.num,
+  const estimate: Estimate = {
+    mean,
     sigma: sigma * factor,
-    ...value.unit === undefined ? {} : { unit: value.unit },
+    ...unit === undefined ? {} : { unit },
     conf: claim.conf
   }
+  validateEstimate(estimate)
+  return estimate
 }
 
 /**
@@ -129,8 +275,11 @@ export const estimateOf = (claim: Claim.t): undefined | Estimate => {
  * example lives in the tests). Claims without usable numeric uncertainty
  * are ignored.
  */
-export const fuseClaims = (claims: readonly Claim.t[]): undefined | Posterior =>
-  fuse(claims.flatMap(claim => {
+export const fuseClaims = (claims: readonly Claim.t[]): undefined | Posterior => {
+  const estimates: Estimate[] = []
+  for (const claim of claims) {
     const estimate = estimateOf(claim)
-    return estimate === undefined ? [] : [estimate]
-  }))
+    if (estimate !== undefined) estimates.push(estimate)
+  }
+  return fuse(estimates)
+}

package/src/validate.ts

@@ -0,0 +1,6 @@
+/** Shared numeric boundary for probabilities accepted by the fusion API. */
+export const validateConfidence = (conf: number): void => {
+  if (!Number.isFinite(conf) || conf < 0 || conf > 1) {
+    throw new RangeError('confidence must be finite and between 0 and 1')
+  }
+}