@takk/bayesoutputgate 1.0.0

package/dist/index.js

@@ -0,0 +1,1109 @@
+// src/errors.ts
+var BayesOutputGateError = class _BayesOutputGateError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "BayesOutputGateError";
+    this.code = code;
+    Object.setPrototypeOf(this, _BayesOutputGateError.prototype);
+  }
+};
+function invariant(condition, code, message) {
+  if (!condition) {
+    throw new BayesOutputGateError(code, message);
+  }
+}
+
+// src/canonical.ts
+function canonicalize(value) {
+  return serialize(value);
+}
+function serialize(value) {
+  if (value === null) {
+    return "null";
+  }
+  const kind = typeof value;
+  if (kind === "number") {
+    return Number.isFinite(value) ? String(value) : "null";
+  }
+  if (kind === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (kind === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => serialize(item)).join(",")}]`;
+  }
+  if (kind === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+    const body = entries.map(([key, v]) => `${JSON.stringify(key)}:${serialize(v)}`).join(",");
+    return `{${body}}`;
+  }
+  return "null";
+}
+
+// src/audit/index.ts
+var GENESIS_HASH = "0".repeat(64);
+async function sha256Hex(input) {
+  const bytes = new TextEncoder().encode(input);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function recordOf(index, payload, previousHash, timestamp) {
+  return timestamp !== void 0 ? { index, timestamp, payload, previousHash } : { index, payload, previousHash };
+}
+var AuditChain = class {
+  entries = [];
+  /** Append a payload, sealing it against the previous entry's hash. */
+  async append(payload, meta = {}) {
+    const index = this.entries.length;
+    const previousHash = index === 0 ? GENESIS_HASH : this.entries[index - 1].hash;
+    const record = recordOf(index, payload, previousHash, meta.timestamp);
+    const hash = await sha256Hex(canonicalize(record));
+    const entry = meta.timestamp !== void 0 ? { index, timestamp: meta.timestamp, payload, previousHash, hash } : { index, payload, previousHash, hash };
+    this.entries.push(entry);
+    return entry;
+  }
+  /** A copy of the chain's entries in order. */
+  toArray() {
+    return [...this.entries];
+  }
+  /** Number of entries in the chain. */
+  get length() {
+    return this.entries.length;
+  }
+};
+async function verifyChain(entries) {
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const expectedPrevious = i === 0 ? GENESIS_HASH : entries[i - 1].hash;
+    if (entry.index !== i || entry.previousHash !== expectedPrevious) {
+      return { valid: false, brokenAt: i };
+    }
+    const record = recordOf(entry.index, entry.payload, entry.previousHash, entry.timestamp);
+    const recomputed = await sha256Hex(canonicalize(record));
+    if (recomputed !== entry.hash) {
+      return { valid: false, brokenAt: i };
+    }
+  }
+  return { valid: true };
+}
+
+// src/mathspecial.ts
+var LN_SQRT_2PI = 0.9189385332046728;
+var LANCZOS_G = 7;
+var LANCZOS_COEFFICIENTS = [
+  0.9999999999998099,
+  676.5203681218851,
+  -1259.1392167224028,
+  771.3234287776531,
+  -176.6150291621406,
+  12.507343278686905,
+  -0.13857109526572012,
+  9984369578019572e-21,
+  15056327351493116e-23
+];
+function lgamma(x) {
+  if (!Number.isFinite(x) || x <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `lgamma requires a positive finite argument, got ${x}`
+    );
+  }
+  const z = x - 1;
+  let acc = LANCZOS_COEFFICIENTS[0];
+  for (let i = 1; i < LANCZOS_COEFFICIENTS.length; i++) {
+    acc += LANCZOS_COEFFICIENTS[i] / (z + i);
+  }
+  const t = z + LANCZOS_G + 0.5;
+  return LN_SQRT_2PI + (z + 0.5) * Math.log(t) - t + Math.log(acc);
+}
+function lbeta(a, b) {
+  return lgamma(a) + lgamma(b) - lgamma(a + b);
+}
+function betaLogDensity(x, a, b) {
+  if (a <= 0 || b <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `Beta shape parameters must be positive, got a=${a}, b=${b}`
+    );
+  }
+  if (x < 0 || x > 1 || !Number.isFinite(x)) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (x === 0) {
+    if (a < 1) return Number.POSITIVE_INFINITY;
+    if (a > 1) return Number.NEGATIVE_INFINITY;
+    return -lbeta(a, b) + (b - 1) * Math.log(1);
+  }
+  if (x === 1) {
+    if (b < 1) return Number.POSITIVE_INFINITY;
+    if (b > 1) return Number.NEGATIVE_INFINITY;
+    return -lbeta(a, b);
+  }
+  return (a - 1) * Math.log(x) + (b - 1) * Math.log1p(-x) - lbeta(a, b);
+}
+function logMarginalBernoulli(successes, trials, a, b) {
+  if (successes < 0 || trials < 0 || successes > trials) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `invalid Bernoulli counts: ${successes} successes in ${trials} trials`
+    );
+  }
+  if (a <= 0 || b <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `Beta prior parameters must be positive, got a=${a}, b=${b}`
+    );
+  }
+  return lbeta(successes + a, trials - successes + b) - lbeta(a, b);
+}
+function clamp(x, lo, hi) {
+  if (x < lo) return lo;
+  if (x > hi) return hi;
+  return x;
+}
+function regularizedIncompleteBeta(x, a, b) {
+  if (a <= 0 || b <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `incomplete beta requires positive shapes, got a=${a}, b=${b}`
+    );
+  }
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  const logFront = lgamma(a + b) - lgamma(a) - lgamma(b) + a * Math.log(x) + b * Math.log1p(-x);
+  const front = Math.exp(logFront);
+  if (x < (a + 1) / (a + b + 2)) {
+    return front * betaContinuedFraction(x, a, b) / a;
+  }
+  return 1 - front * betaContinuedFraction(1 - x, b, a) / b;
+}
+function betaCdf(x, a, b) {
+  return regularizedIncompleteBeta(x, a, b);
+}
+function betaContinuedFraction(x, a, b) {
+  const maxIterations = 200;
+  const epsilon = 3e-12;
+  const tiny = 1e-300;
+  const qab = a + b;
+  const qap = a + 1;
+  const qam = a - 1;
+  let c = 1;
+  let d = 1 - qab * x / qap;
+  if (Math.abs(d) < tiny) d = tiny;
+  d = 1 / d;
+  let h = d;
+  for (let m = 1; m <= maxIterations; m++) {
+    const m2 = 2 * m;
+    let aa = m * (b - m) * x / ((qam + m2) * (a + m2));
+    d = 1 + aa * d;
+    if (Math.abs(d) < tiny) d = tiny;
+    c = 1 + aa / c;
+    if (Math.abs(c) < tiny) c = tiny;
+    d = 1 / d;
+    h *= d * c;
+    aa = -(a + m) * (qab + m) * x / ((a + m2) * (qap + m2));
+    d = 1 + aa * d;
+    if (Math.abs(d) < tiny) d = tiny;
+    c = 1 + aa / c;
+    if (Math.abs(c) < tiny) c = tiny;
+    d = 1 / d;
+    const delta = d * c;
+    h *= delta;
+    if (Math.abs(delta - 1) < epsilon) {
+      break;
+    }
+  }
+  return h;
+}
+
+// src/bayesfactor/index.ts
+var LN_3 = Math.log(3);
+var LN_10 = Math.log(10);
+var LN_100 = Math.log(100);
+var DENSITY_EPSILON = 1e-6;
+function jeffreysStrength(logBayesFactor) {
+  const x = logBayesFactor;
+  if (x >= LN_100) return "decisive-high";
+  if (x >= LN_10) return "strong-high";
+  if (x >= LN_3) return "substantial-high";
+  if (x > -LN_3) return "inconclusive";
+  if (x > -LN_10) return "substantial-low";
+  if (x > -LN_100) return "strong-low";
+  return "decisive-low";
+}
+function bayesFactor(scores, models) {
+  invariant(models.length > 0, "INVALID_CONFIG", "at least one dimension model is required");
+  const map = /* @__PURE__ */ new Map();
+  for (const s of scores) {
+    invariant(
+      Number.isFinite(s.value) && s.value >= 0 && s.value <= 1,
+      "INVALID_SCORE",
+      `score for "${s.dimension}" must be a finite number in [0, 1], got ${s.value}`
+    );
+    invariant(
+      !map.has(s.dimension),
+      "INVALID_SCORE",
+      `duplicate score for dimension "${s.dimension}"`
+    );
+    map.set(s.dimension, s.value);
+  }
+  const contributions = [];
+  let logBayesFactor = 0;
+  for (const model of models) {
+    const value = map.get(model.dimension);
+    if (value === void 0) {
+      continue;
+    }
+    invariant(
+      Number.isFinite(model.weight) && model.weight >= 0,
+      "INVALID_CONFIG",
+      `weight for "${model.dimension}" must be a non-negative finite number, got ${model.weight}`
+    );
+    const x = clamp(value, DENSITY_EPSILON, 1 - DENSITY_EPSILON);
+    const logHigh = betaLogDensity(x, model.high.a, model.high.b);
+    const logLow = betaLogDensity(x, model.low.a, model.low.b);
+    const weighted = model.weight * (logHigh - logLow);
+    logBayesFactor += weighted;
+    contributions.push({
+      dimension: model.dimension,
+      score: value,
+      logBayesFactor: weighted,
+      weight: model.weight
+    });
+  }
+  invariant(
+    contributions.length > 0,
+    "INVALID_SCORE",
+    "no scored dimension matched a configured dimension model"
+  );
+  invariant(Number.isFinite(logBayesFactor), "NUMERIC", "combined log-Bayes-Factor is not finite");
+  const strength = jeffreysStrength(logBayesFactor);
+  const favored = strength.endsWith("high") ? "high" : strength.endsWith("low") ? "low" : "inconclusive";
+  return {
+    logBayesFactor,
+    bayesFactor: Math.exp(logBayesFactor),
+    favored,
+    strength,
+    contributions
+  };
+}
+
+// src/dimensions/index.ts
+function dependenceDiagnostic(history, options = {}) {
+  const threshold = options.threshold ?? 0.5;
+  invariant(
+    Number.isFinite(threshold) && threshold >= 0 && threshold <= 1,
+    "INVALID_CONFIG",
+    `threshold must be in [0, 1], got ${threshold}`
+  );
+  invariant(
+    history.length >= 2,
+    "INVALID_OBSERVATION",
+    "dependence diagnostic needs at least two score vectors"
+  );
+  const dimensionSet = /* @__PURE__ */ new Set();
+  for (const vector of history) {
+    for (const score of vector) {
+      dimensionSet.add(score.dimension);
+    }
+  }
+  const dimensions = [...dimensionSet].sort();
+  const rows = history.map((vector) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const score of vector) {
+      map.set(score.dimension, score.value);
+    }
+    return map;
+  });
+  const pairs = [];
+  for (let i = 0; i < dimensions.length; i++) {
+    for (let j = i + 1; j < dimensions.length; j++) {
+      const a = dimensions[i];
+      const b = dimensions[j];
+      const xs = [];
+      const ys = [];
+      for (const row of rows) {
+        const x = row.get(a);
+        const y = row.get(b);
+        if (x !== void 0 && y !== void 0) {
+          xs.push(x);
+          ys.push(y);
+        }
+      }
+      if (xs.length >= 2) {
+        const correlation = pearson(xs, ys);
+        if (Number.isFinite(correlation)) {
+          pairs.push({ a, b, correlation, samples: xs.length });
+        }
+      }
+    }
+  }
+  pairs.sort((left, right) => Math.abs(right.correlation) - Math.abs(left.correlation));
+  const maxAbsCorrelation = pairs.length > 0 ? Math.abs(pairs[0].correlation) : 0;
+  const flagged = pairs.filter((pair) => Math.abs(pair.correlation) >= threshold);
+  return {
+    dimensions,
+    pairs,
+    flagged,
+    maxAbsCorrelation,
+    independenceAssumptionSafe: flagged.length === 0
+  };
+}
+function pearson(xs, ys) {
+  const n = xs.length;
+  let sumX = 0;
+  let sumY = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += xs[i];
+    sumY += ys[i];
+  }
+  const meanX = sumX / n;
+  const meanY = sumY / n;
+  let covariance = 0;
+  let varianceX = 0;
+  let varianceY = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = xs[i] - meanX;
+    const dy = ys[i] - meanY;
+    covariance += dx * dy;
+    varianceX += dx * dx;
+    varianceY += dy * dy;
+  }
+  if (varianceX === 0 || varianceY === 0) {
+    return 0;
+  }
+  return covariance / Math.sqrt(varianceX * varianceY);
+}
+
+// src/calibration/index.ts
+function goodnessOfFit(samples, params, alpha = 0.05) {
+  invariant(
+    samples.length >= 5,
+    "INVALID_OBSERVATION",
+    "goodnessOfFit needs at least five samples"
+  );
+  invariant(params.a > 0 && params.b > 0, "INVALID_CONFIG", "Beta parameters must be positive");
+  const sorted = [...samples].sort((left, right) => left - right);
+  const n = sorted.length;
+  let ks = 0;
+  for (let i = 0; i < n; i++) {
+    const value = sorted[i];
+    invariant(
+      Number.isFinite(value) && value >= 0 && value <= 1,
+      "INVALID_SCORE",
+      `samples must be finite and in [0, 1], got ${value}`
+    );
+    const cdf = betaCdf(value, params.a, params.b);
+    const upper = (i + 1) / n - cdf;
+    const lower = cdf - i / n;
+    ks = Math.max(ks, upper, lower);
+  }
+  const coefficient = alpha <= 0.01 ? 1.628 : alpha <= 0.05 ? 1.358 : 1.224;
+  const criticalValue = coefficient / Math.sqrt(n);
+  return { ksStatistic: ks, criticalValue, adequate: ks <= criticalValue, samples: n };
+}
+function brierScore(predictions) {
+  invariant(
+    predictions.length > 0,
+    "INVALID_OBSERVATION",
+    "brierScore needs at least one prediction"
+  );
+  let sum = 0;
+  for (const prediction of predictions) {
+    validatePrediction(prediction);
+    sum += (prediction.probability - prediction.outcome) ** 2;
+  }
+  return sum / predictions.length;
+}
+function reliability(predictions, bins = 10) {
+  invariant(
+    Number.isInteger(bins) && bins >= 1,
+    "INVALID_CONFIG",
+    `bins must be a positive integer, got ${bins}`
+  );
+  invariant(
+    predictions.length > 0,
+    "INVALID_OBSERVATION",
+    "reliability needs at least one prediction"
+  );
+  const sums = new Array(bins).fill(0);
+  const hits = new Array(bins).fill(0);
+  const counts = new Array(bins).fill(0);
+  for (const prediction of predictions) {
+    validatePrediction(prediction);
+    const index = Math.min(bins - 1, Math.floor(prediction.probability * bins));
+    sums[index] = sums[index] + prediction.probability;
+    hits[index] = hits[index] + prediction.outcome;
+    counts[index] = counts[index] + 1;
+  }
+  const out = [];
+  for (let b = 0; b < bins; b++) {
+    const count = counts[b];
+    out.push({
+      lower: b / bins,
+      upper: (b + 1) / bins,
+      count,
+      meanPredicted: count > 0 ? sums[b] / count : 0,
+      empiricalRate: count > 0 ? hits[b] / count : 0
+    });
+  }
+  return out;
+}
+function expectedCalibrationError(predictions, bins = 10) {
+  const diagram = reliability(predictions, bins);
+  const total = predictions.length;
+  let ece = 0;
+  for (const bin of diagram) {
+    if (bin.count > 0) {
+      ece += bin.count / total * Math.abs(bin.empiricalRate - bin.meanPredicted);
+    }
+  }
+  return ece;
+}
+function scoresForDimension(history, dimension, label) {
+  const out = [];
+  for (const observation of history) {
+    if (observation.label !== label) {
+      continue;
+    }
+    for (const score of observation.scores) {
+      if (score.dimension === dimension) {
+        out.push(score.value);
+      }
+    }
+  }
+  return out;
+}
+function assessAssumptions(history, models, options = {}) {
+  const alpha = options.alpha ?? 0.05;
+  const minSamples = options.minSamples ?? 5;
+  const inadequateDimensions = [];
+  for (const model of models) {
+    const high = scoresForDimension(history, model.dimension, "high");
+    const low = scoresForDimension(history, model.dimension, "low");
+    const highBad = high.length >= minSamples && !goodnessOfFit(high, model.high, alpha).adequate;
+    const lowBad = low.length >= minSamples && !goodnessOfFit(low, model.low, alpha).adequate;
+    if (highBad || lowBad) {
+      inadequateDimensions.push(model.dimension);
+    }
+  }
+  const vectors = history.map((observation) => observation.scores);
+  let independenceAssumptionSafe = true;
+  const dependentPairs = [];
+  if (vectors.length >= 2) {
+    const diagnostic = dependenceDiagnostic(
+      vectors,
+      options.dependenceThreshold !== void 0 ? { threshold: options.dependenceThreshold } : {}
+    );
+    independenceAssumptionSafe = diagnostic.independenceAssumptionSafe;
+    for (const pair of diagnostic.flagged) {
+      dependentPairs.push(`${pair.a}~${pair.b}`);
+    }
+  }
+  return {
+    goodnessOfFitAdequate: inadequateDimensions.length === 0,
+    independenceAssumptionSafe,
+    inadequateDimensions,
+    dependentPairs
+  };
+}
+function validatePrediction(prediction) {
+  invariant(
+    Number.isFinite(prediction.probability) && prediction.probability >= 0 && prediction.probability <= 1,
+    "INVALID_SCORE",
+    `prediction probability must be in [0, 1], got ${prediction.probability}`
+  );
+  invariant(
+    prediction.outcome === 0 || prediction.outcome === 1,
+    "INVALID_OBSERVATION",
+    `prediction outcome must be 0 or 1, got ${prediction.outcome}`
+  );
+}
+
+// src/beta/index.ts
+var VARIANCE_FLOOR = 1e-9;
+var CONCENTRATION_FLOOR = 1e-3;
+var BetaModel = class _BetaModel {
+  priorA;
+  priorB;
+  count = 0;
+  sum = 0;
+  sumSquares = 0;
+  constructor(options = {}) {
+    const prior = options.prior ?? { a: 1, b: 1 };
+    invariant(
+      prior.a > 0 && prior.b > 0 && Number.isFinite(prior.a) && Number.isFinite(prior.b),
+      "INVALID_CONFIG",
+      `prior Beta parameters must be positive and finite, got a=${prior.a}, b=${prior.b}`
+    );
+    this.priorA = prior.a;
+    this.priorB = prior.b;
+  }
+  /** Build a model from labeled scores in one pass. */
+  static fromSamples(samples, options = {}) {
+    const model = new _BetaModel(options);
+    for (const s of samples) {
+      model.observe(s);
+    }
+    return model;
+  }
+  /** Restore a model from a snapshot. */
+  static fromSnapshot(snapshot) {
+    const model = new _BetaModel({ prior: snapshot.prior });
+    invariant(
+      snapshot.count >= 0 && Number.isFinite(snapshot.sum) && Number.isFinite(snapshot.sumSquares),
+      "INVALID_SNAPSHOT",
+      "snapshot fields must be finite and non-negative"
+    );
+    model.count = snapshot.count;
+    model.sum = snapshot.sum;
+    model.sumSquares = snapshot.sumSquares;
+    return model;
+  }
+  /** Number of real observations folded into this model so far. */
+  get observations() {
+    return this.count;
+  }
+  /** Fold a single score in [0, 1] into the model, updating its calibration online. */
+  observe(score) {
+    invariant(
+      Number.isFinite(score) && score >= 0 && score <= 1,
+      "INVALID_SCORE",
+      `score must be a finite number in [0, 1], got ${score}`
+    );
+    this.count += 1;
+    this.sum += score;
+    this.sumSquares += score * score;
+    return this;
+  }
+  /**
+   * The fitted Beta parameters. The prior is mixed in as `priorA + priorB` pseudo-observations with
+   * the prior's own mean and variance, then a and b come from method of moments on the blend, so a
+   * cold model returns its prior and a warm model is data-driven.
+   */
+  params() {
+    const priorStrength = this.priorA + this.priorB;
+    const priorMean = this.priorA / priorStrength;
+    const priorVariance = priorMean * (1 - priorMean) / (priorStrength + 1);
+    const totalCount = this.count + priorStrength;
+    const totalSum = this.sum + priorStrength * priorMean;
+    const totalSumSquares = this.sumSquares + priorStrength * (priorVariance + priorMean * priorMean);
+    const mean = clamp(totalSum / totalCount, VARIANCE_FLOOR, 1 - VARIANCE_FLOOR);
+    const rawVariance = totalSumSquares / totalCount - mean * mean;
+    const maxVariance = mean * (1 - mean);
+    const variance = clamp(rawVariance, VARIANCE_FLOOR, maxVariance * (1 - VARIANCE_FLOOR));
+    const concentration = Math.max(mean * (1 - mean) / variance - 1, CONCENTRATION_FLOOR);
+    const a = Math.max(mean * concentration, CONCENTRATION_FLOOR);
+    const b = Math.max((1 - mean) * concentration, CONCENTRATION_FLOOR);
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+      throw new BayesOutputGateError("NUMERIC", "Beta fit produced non-finite parameters");
+    }
+    return { a, b };
+  }
+  /** Mean of the fitted Beta. */
+  mean() {
+    const { a, b } = this.params();
+    return a / (a + b);
+  }
+  /** Log-density of an observed score under the fitted Beta. */
+  logDensity(score) {
+    const { a, b } = this.params();
+    return betaLogDensity(score, a, b);
+  }
+  /** A serializable snapshot of the current state. */
+  snapshot() {
+    return {
+      count: this.count,
+      sum: this.sum,
+      sumSquares: this.sumSquares,
+      prior: { a: this.priorA, b: this.priorB }
+    };
+  }
+};
+
+// src/hypothesis/index.ts
+var HypothesisManager = class {
+  entries = /* @__PURE__ */ new Map();
+  defaultWeight;
+  defaultPriorHigh;
+  defaultPriorLow;
+  configured = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.defaultWeight = options.defaultWeight ?? 1;
+    this.defaultPriorHigh = options.defaultPriorHigh ?? { a: 2, b: 1 };
+    this.defaultPriorLow = options.defaultPriorLow ?? { a: 1, b: 2 };
+    invariant(
+      Number.isFinite(this.defaultWeight) && this.defaultWeight >= 0,
+      "INVALID_CONFIG",
+      `defaultWeight must be a non-negative finite number, got ${this.defaultWeight}`
+    );
+    for (const config of options.dimensions ?? []) {
+      this.configured.set(config.dimension, config);
+      this.ensure(config.dimension);
+    }
+  }
+  ensure(dimension) {
+    const existing = this.entries.get(dimension);
+    if (existing) {
+      return existing;
+    }
+    const config = this.configured.get(dimension);
+    const entry = {
+      high: new BetaModel({ prior: config?.priorHigh ?? this.defaultPriorHigh }),
+      low: new BetaModel({ prior: config?.priorLow ?? this.defaultPriorLow }),
+      weight: config?.weight ?? this.defaultWeight
+    };
+    invariant(
+      Number.isFinite(entry.weight) && entry.weight >= 0,
+      "INVALID_CONFIG",
+      `weight for "${dimension}" must be a non-negative finite number, got ${entry.weight}`
+    );
+    this.entries.set(dimension, entry);
+    return entry;
+  }
+  /** Fold one labeled output into the high or low model of each scored dimension. */
+  observe(observation) {
+    invariant(
+      observation.label === "high" || observation.label === "low",
+      "INVALID_OBSERVATION",
+      `observation label must be "high" or "low", got ${String(observation.label)}`
+    );
+    for (const score of observation.scores) {
+      const entry = this.ensure(score.dimension);
+      const model = observation.label === "high" ? entry.high : entry.low;
+      model.observe(score.value);
+    }
+    return this;
+  }
+  /** Fold a batch of labeled observations. */
+  fit(observations) {
+    for (const observation of observations) {
+      this.observe(observation);
+    }
+    return this;
+  }
+  /** The dimension names this manager currently tracks. */
+  get dimensions() {
+    return [...this.entries.keys()];
+  }
+  /** Snapshot the current calibrated models as the dimension models the Bayes Factor consumes. */
+  models() {
+    const out = [];
+    for (const [dimension, entry] of this.entries) {
+      out.push({
+        dimension,
+        high: entry.high.params(),
+        low: entry.low.params(),
+        weight: entry.weight
+      });
+    }
+    return out;
+  }
+  /** Number of labeled observations folded into a dimension under one hypothesis. */
+  observationCount(dimension, kind) {
+    const entry = this.entries.get(dimension);
+    if (!entry) {
+      return 0;
+    }
+    return (kind === "high" ? entry.high : entry.low).observations;
+  }
+};
+
+// src/policy/index.ts
+function posteriorHighQuality(logBayesFactor, priorHighQuality) {
+  invariant(
+    priorHighQuality > 0 && priorHighQuality < 1,
+    "INVALID_CONFIG",
+    `priorHighQuality must be in (0, 1), got ${priorHighQuality}`
+  );
+  invariant(
+    Number.isFinite(logBayesFactor),
+    "NUMERIC",
+    `logBayesFactor must be finite, got ${logBayesFactor}`
+  );
+  const logPosteriorOdds = logBayesFactor + Math.log(priorHighQuality / (1 - priorHighQuality));
+  if (logPosteriorOdds >= 0) {
+    return 1 / (1 + Math.exp(-logPosteriorOdds));
+  }
+  const odds = Math.exp(logPosteriorOdds);
+  return odds / (1 + odds);
+}
+function decide(logBayesFactor, policy) {
+  if (policy.kind === "bayes-factor") {
+    invariant(
+      policy.passAbove >= 1,
+      "INVALID_CONFIG",
+      `passAbove must be >= 1, got ${policy.passAbove}`
+    );
+    invariant(
+      policy.failBelow > 0 && policy.failBelow <= 1,
+      "INVALID_CONFIG",
+      `failBelow must be in (0, 1], got ${policy.failBelow}`
+    );
+    invariant(
+      policy.passAbove > policy.failBelow,
+      "INVALID_CONFIG",
+      "passAbove must be greater than failBelow"
+    );
+    const bayesFactor2 = Math.exp(logBayesFactor);
+    const action2 = bayesFactor2 >= policy.passAbove ? "pass" : bayesFactor2 <= policy.failBelow ? "fail" : "escalate";
+    return { action: action2, rationale: "bayes-factor" };
+  }
+  invariant(
+    policy.lossFalsePass >= 0 && policy.lossFalseFail >= 0 && policy.escalationCost >= 0,
+    "INVALID_CONFIG",
+    "decision-theoretic losses must be non-negative"
+  );
+  invariant(
+    Number.isFinite(policy.lossFalsePass) && Number.isFinite(policy.lossFalseFail) && Number.isFinite(policy.escalationCost),
+    "INVALID_CONFIG",
+    "decision-theoretic losses must be finite"
+  );
+  const posterior = posteriorHighQuality(logBayesFactor, policy.priorHighQuality);
+  const expectedLoss = {
+    pass: (1 - posterior) * policy.lossFalsePass,
+    fail: posterior * policy.lossFalseFail,
+    escalate: policy.escalationCost
+  };
+  let action = "pass";
+  let best = expectedLoss.pass;
+  if (expectedLoss.fail < best) {
+    action = "fail";
+    best = expectedLoss.fail;
+  }
+  if (expectedLoss.escalate < best) {
+    action = "escalate";
+  }
+  return { action, rationale: "expected-loss", posteriorHighQuality: posterior, expectedLoss };
+}
+
+// src/gate/index.ts
+function toDecision(factor, policy, guards) {
+  const base = {
+    action: policy.action,
+    bayesFactor: factor.bayesFactor,
+    logBayesFactor: factor.logBayesFactor,
+    strength: factor.strength,
+    rationale: policy.rationale,
+    contributions: factor.contributions,
+    ...policy.posteriorHighQuality !== void 0 ? { posteriorHighQuality: policy.posteriorHighQuality } : {},
+    ...policy.expectedLoss !== void 0 ? { expectedLoss: policy.expectedLoss } : {}
+  };
+  const assumptions = guards?.assumptions;
+  if (assumptions === void 0) {
+    return base;
+  }
+  const goodnessOfFitViolated = guards?.requireGoodnessOfFit === true && !assumptions.goodnessOfFitAdequate;
+  const independenceViolated = guards?.requireIndependence === true && !assumptions.independenceAssumptionSafe;
+  if (goodnessOfFitViolated || independenceViolated) {
+    return { ...base, action: "escalate", rationale: "assumption-violated", assumptions };
+  }
+  return { ...base, assumptions };
+}
+function evaluate(scores, models, policy, guards) {
+  const factor = bayesFactor(scores, models);
+  const decision = decide(factor.logBayesFactor, policy);
+  return toDecision(factor, decision, guards);
+}
+var OutputGate = class {
+  models;
+  policy;
+  guards;
+  constructor(options) {
+    invariant(
+      options.models.length > 0,
+      "INVALID_CONFIG",
+      "a gate needs at least one dimension model"
+    );
+    this.models = [...options.models];
+    this.policy = options.policy;
+    this.guards = options.guards;
+  }
+  /** Evaluate one output's scores. */
+  evaluate(scores) {
+    return evaluate(scores, this.models, this.policy, this.guards);
+  }
+  /** A copy of the gate's dimension models. */
+  dimensionModels() {
+    return [...this.models];
+  }
+};
+var OutputGateMonitor = class {
+  manager;
+  policy;
+  chain = new AuditChain();
+  guards;
+  assumptions;
+  constructor(options) {
+    this.manager = options.manager ?? new HypothesisManager();
+    this.policy = options.policy;
+    this.guards = options.guards;
+  }
+  /** Fold one labeled observation into the calibration. Does not recompute the assumption report. */
+  observe(observation) {
+    this.manager.observe(observation);
+    return this;
+  }
+  /** Fold a batch of labeled observations, and reassess the modeling assumptions when guarded. */
+  fit(observations) {
+    const list = [...observations];
+    for (const observation of list) {
+      this.manager.observe(observation);
+    }
+    if (this.guards !== void 0 && (this.guards.requireGoodnessOfFit === true || this.guards.requireIndependence === true)) {
+      this.assumptions = assessAssumptions(list, this.manager.models(), this.guards);
+    }
+    return this;
+  }
+  /** Evaluate without recording. */
+  evaluate(scores) {
+    return evaluate(scores, this.manager.models(), this.policy, this.guardsForEvaluate());
+  }
+  guardsForEvaluate() {
+    if (this.guards === void 0) {
+      return void 0;
+    }
+    return {
+      ...this.assumptions !== void 0 ? { assumptions: this.assumptions } : {},
+      ...this.guards.requireGoodnessOfFit !== void 0 ? { requireGoodnessOfFit: this.guards.requireGoodnessOfFit } : {},
+      ...this.guards.requireIndependence !== void 0 ? { requireIndependence: this.guards.requireIndependence } : {}
+    };
+  }
+  /** Evaluate and seal the decision into the audit chain. */
+  async record(scores, meta = {}) {
+    const decision = this.evaluate(scores);
+    const entry = await this.chain.append(decision, meta);
+    return { decision, entry };
+  }
+  /** A copy of the audit chain. */
+  auditTrail() {
+    return this.chain.toArray();
+  }
+  /** Number of sealed decisions. */
+  get auditLength() {
+    return this.chain.length;
+  }
+  /** The most recent assumption report, present after a guarded {@link OutputGateMonitor.fit}. */
+  get assumptionReport() {
+    return this.assumptions;
+  }
+  /** The current calibrated dimension models. */
+  models() {
+    return this.manager.models();
+  }
+};
+
+// src/adapter/index.ts
+var TOOL_NAME = "bayes_output_gate";
+var DEFAULT_POLICY = { kind: "bayes-factor", passAbove: 10, failBelow: 0.1 };
+function toJsonSafe(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toJsonSafe(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      out[key] = toJsonSafe(item);
+    }
+    return out;
+  }
+  return value;
+}
+function asObject(value, message) {
+  invariant(
+    typeof value === "object" && value !== null && !Array.isArray(value),
+    "INVALID_CONFIG",
+    message
+  );
+  return value;
+}
+function parseBeta(value, where) {
+  const obj = asObject(value, `${where} must be an object with positive a and b`);
+  const a = obj["a"];
+  const b = obj["b"];
+  invariant(
+    typeof a === "number" && typeof b === "number" && a > 0 && b > 0,
+    "INVALID_CONFIG",
+    `${where} must have positive numeric a and b`
+  );
+  return { a, b };
+}
+function parseScore(value) {
+  const obj = asObject(value, "each score must be an object with dimension and value");
+  const dimension = obj["dimension"];
+  const score = obj["value"];
+  invariant(
+    typeof dimension === "string" && dimension.length > 0,
+    "INVALID_SCORE",
+    "score dimension must be a non-empty string"
+  );
+  invariant(
+    typeof score === "number" && Number.isFinite(score) && score >= 0 && score <= 1,
+    "INVALID_SCORE",
+    `score value for "${dimension}" must be a finite number in [0, 1]`
+  );
+  return { dimension, value: score };
+}
+function parseModel(value) {
+  const obj = asObject(value, "each model must be an object");
+  const dimension = obj["dimension"];
+  invariant(
+    typeof dimension === "string" && dimension.length > 0,
+    "INVALID_CONFIG",
+    "model dimension must be a non-empty string"
+  );
+  const rawWeight = obj["weight"];
+  const weight = rawWeight === void 0 ? 1 : rawWeight;
+  invariant(
+    typeof weight === "number" && Number.isFinite(weight) && weight >= 0,
+    "INVALID_CONFIG",
+    `model weight for "${dimension}" must be a non-negative number`
+  );
+  return {
+    dimension,
+    high: parseBeta(obj["high"], `model "${dimension}" high`),
+    low: parseBeta(obj["low"], `model "${dimension}" low`),
+    weight
+  };
+}
+function parsePolicy(value) {
+  if (value === void 0) {
+    return DEFAULT_POLICY;
+  }
+  const obj = asObject(value, "policy must be an object");
+  const kind = obj["kind"];
+  if (kind === "decision-theoretic") {
+    const prior = obj["priorHighQuality"];
+    const lossFalsePass = obj["lossFalsePass"];
+    const lossFalseFail = obj["lossFalseFail"];
+    const escalationCost = obj["escalationCost"];
+    invariant(
+      typeof prior === "number" && typeof lossFalsePass === "number" && typeof lossFalseFail === "number" && typeof escalationCost === "number",
+      "INVALID_CONFIG",
+      "decision-theoretic policy requires numeric priorHighQuality, lossFalsePass, lossFalseFail, escalationCost"
+    );
+    return {
+      kind: "decision-theoretic",
+      priorHighQuality: prior,
+      lossFalsePass,
+      lossFalseFail,
+      escalationCost
+    };
+  }
+  invariant(kind === "bayes-factor", "INVALID_CONFIG", `unknown policy kind ${String(kind)}`);
+  const passAbove = obj["passAbove"];
+  const failBelow = obj["failBelow"];
+  invariant(
+    typeof passAbove === "number" && typeof failBelow === "number",
+    "INVALID_CONFIG",
+    "bayes-factor policy requires numeric passAbove and failBelow"
+  );
+  return { kind: "bayes-factor", passAbove, failBelow };
+}
+function parseGateInput(input) {
+  const obj = asObject(input, "tool input must be an object");
+  invariant(Array.isArray(obj["scores"]), "INVALID_SCORE", "scores must be an array");
+  invariant(Array.isArray(obj["models"]), "INVALID_CONFIG", "models must be an array");
+  const scores = obj["scores"].map(parseScore);
+  const models = obj["models"].map(parseModel);
+  invariant(models.length > 0, "INVALID_CONFIG", "at least one model is required");
+  return { scores, models, policy: parsePolicy(obj["policy"]) };
+}
+function runTool(input) {
+  const { scores, models, policy } = parseGateInput(input);
+  return evaluate(scores, models, policy);
+}
+function describeTool() {
+  return {
+    name: TOOL_NAME,
+    description: "Weigh an output's per-dimension quality scores against a high-quality and a low-quality hypothesis with a calibrated Bayes Factor, and return a pass, fail, or escalate decision on the Jeffreys scale.",
+    inputSchema: {
+      type: "object",
+      required: ["scores", "models"],
+      properties: {
+        scores: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["dimension", "value"],
+            properties: {
+              dimension: { type: "string" },
+              value: { type: "number", minimum: 0, maximum: 1 }
+            }
+          }
+        },
+        models: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["dimension", "high", "low"],
+            properties: {
+              dimension: { type: "string" },
+              high: { type: "object", required: ["a", "b"] },
+              low: { type: "object", required: ["a", "b"] },
+              weight: { type: "number", minimum: 0 }
+            }
+          }
+        },
+        policy: { type: "object" }
+      }
+    }
+  };
+}
+var bayesOutputGateTool = {
+  ...describeTool(),
+  handler: (input) => toJsonSafe(runTool(input))
+};
+
+// src/likelihood/index.ts
+function logScoreLikelihood(score, params) {
+  return betaLogDensity(score, params.a, params.b);
+}
+function logBinaryMarginalLikelihood(successes, trials, prior) {
+  return logMarginalBernoulli(successes, trials, prior.a, prior.b);
+}
+function toScoreMap(scores) {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of scores) {
+    invariant(
+      Number.isFinite(s.value) && s.value >= 0 && s.value <= 1,
+      "INVALID_SCORE",
+      `score for "${s.dimension}" must be a finite number in [0, 1], got ${s.value}`
+    );
+    invariant(
+      !map.has(s.dimension),
+      "INVALID_SCORE",
+      `duplicate score for dimension "${s.dimension}"`
+    );
+    map.set(s.dimension, s.value);
+  }
+  return map;
+}
+function logVectorLikelihood(scores, models, kind) {
+  const map = toScoreMap(scores);
+  let logLikelihood = 0;
+  let matched = 0;
+  for (const model of models) {
+    const value = map.get(model.dimension);
+    if (value === void 0) {
+      continue;
+    }
+    invariant(
+      Number.isFinite(model.weight) && model.weight >= 0,
+      "INVALID_CONFIG",
+      `weight for "${model.dimension}" must be a non-negative finite number, got ${model.weight}`
+    );
+    const params = kind === "high" ? model.high : model.low;
+    logLikelihood += model.weight * betaLogDensity(value, params.a, params.b);
+    matched += 1;
+  }
+  return { logLikelihood, matched };
+}
+
+export { AuditChain, BayesOutputGateError, BetaModel, GENESIS_HASH, HypothesisManager, OutputGate, OutputGateMonitor, TOOL_NAME, assessAssumptions, bayesFactor, bayesOutputGateTool, brierScore, decide, dependenceDiagnostic, describeTool, evaluate, expectedCalibrationError, goodnessOfFit, invariant, jeffreysStrength, logBinaryMarginalLikelihood, logScoreLikelihood, logVectorLikelihood, parseGateInput, posteriorHighQuality, reliability, runTool, sha256Hex, toJsonSafe, toScoreMap, verifyChain };