@takk/bayesoutputgate 1.0.0

package/dist/beta/index.js

@@ -0,0 +1,178 @@
+// 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/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 clamp(x, lo, hi) {
+  if (x < lo) return lo;
+  if (x > hi) return hi;
+  return x;
+}
+
+// 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 }
+    };
+  }
+};
+
+export { BetaModel };

package/dist/calibration/index.cjs

@@ -0,0 +1,339 @@
+'use strict';
+
+// 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/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/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 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/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}`
+  );
+}
+
+exports.assessAssumptions = assessAssumptions;
+exports.brierScore = brierScore;
+exports.expectedCalibrationError = expectedCalibrationError;
+exports.goodnessOfFit = goodnessOfFit;
+exports.reliability = reliability;

package/dist/calibration/index.d.cts

@@ -0,0 +1,53 @@
+import { L as LabeledObservation, e as DimensionModel, A as AssumptionReport, b as BetaParams } from '../types-bMjn1j4e.cjs';
+
+/** A posterior probability of high quality paired with the realized binary outcome (1 high, 0 low). */
+interface Prediction {
+    readonly probability: number;
+    readonly outcome: number;
+}
+/** The Kolmogorov-Smirnov goodness-of-fit of scores against a fitted Beta. */
+interface GoodnessOfFit {
+    readonly ksStatistic: number;
+    readonly criticalValue: number;
+    /** True when the KS statistic is within the critical value, so the Beta assumption is reasonable. */
+    readonly adequate: boolean;
+    readonly samples: number;
+}
+/**
+ * Goodness-of-fit of observed scores against a fitted Beta, by the Kolmogorov-Smirnov statistic
+ * (the largest gap between the empirical CDF and the Beta CDF). When `adequate` is false, the scores
+ * are not Beta-distributed and the density-ratio likelihood should not be trusted for those scores.
+ */
+declare function goodnessOfFit(samples: readonly number[], params: BetaParams, alpha?: number): GoodnessOfFit;
+/** Mean squared error between predicted probabilities and realized binary outcomes. Lower is better. */
+declare function brierScore(predictions: readonly Prediction[]): number;
+/** One bin of a reliability diagram. */
+interface ReliabilityBin {
+    readonly lower: number;
+    readonly upper: number;
+    readonly count: number;
+    readonly meanPredicted: number;
+    readonly empiricalRate: number;
+}
+/** Bin predictions by predicted probability into a reliability diagram. */
+declare function reliability(predictions: readonly Prediction[], bins?: number): ReliabilityBin[];
+/** Expected calibration error: the count-weighted mean gap between predicted and empirical rates. */
+declare function expectedCalibrationError(predictions: readonly Prediction[], bins?: number): number;
+/** Options for {@link assessAssumptions}. */
+interface AssessOptions {
+    /** Significance level for the per-dimension goodness-of-fit test. Defaults to 0.05. */
+    readonly alpha?: number;
+    /** Absolute-correlation threshold above which a dimension pair is dependent. Defaults to 0.5. */
+    readonly dependenceThreshold?: number;
+    /** Minimum samples per hypothesis before a dimension's fit is tested. Defaults to 5. */
+    readonly minSamples?: number;
+}
+/**
+ * Assess whether the gate's modeling assumptions hold for a labeled history under a set of dimension
+ * models: the per-dimension Beta goodness-of-fit for both hypotheses, and the conditional-independence
+ * of the dimensions. Produces an {@link AssumptionReport} a gate can consult to escalate instead of
+ * trusting a Bayes Factor computed from a misspecified model.
+ */
+declare function assessAssumptions(history: readonly LabeledObservation[], models: readonly DimensionModel[], options?: AssessOptions): AssumptionReport;
+
+export { type AssessOptions, type GoodnessOfFit, type Prediction, type ReliabilityBin, assessAssumptions, brierScore, expectedCalibrationError, goodnessOfFit, reliability };

package/dist/calibration/index.d.ts

@@ -0,0 +1,53 @@
+import { L as LabeledObservation, e as DimensionModel, A as AssumptionReport, b as BetaParams } from '../types-bMjn1j4e.js';
+
+/** A posterior probability of high quality paired with the realized binary outcome (1 high, 0 low). */
+interface Prediction {
+    readonly probability: number;
+    readonly outcome: number;
+}
+/** The Kolmogorov-Smirnov goodness-of-fit of scores against a fitted Beta. */
+interface GoodnessOfFit {
+    readonly ksStatistic: number;
+    readonly criticalValue: number;
+    /** True when the KS statistic is within the critical value, so the Beta assumption is reasonable. */
+    readonly adequate: boolean;
+    readonly samples: number;
+}
+/**
+ * Goodness-of-fit of observed scores against a fitted Beta, by the Kolmogorov-Smirnov statistic
+ * (the largest gap between the empirical CDF and the Beta CDF). When `adequate` is false, the scores
+ * are not Beta-distributed and the density-ratio likelihood should not be trusted for those scores.
+ */
+declare function goodnessOfFit(samples: readonly number[], params: BetaParams, alpha?: number): GoodnessOfFit;
+/** Mean squared error between predicted probabilities and realized binary outcomes. Lower is better. */
+declare function brierScore(predictions: readonly Prediction[]): number;
+/** One bin of a reliability diagram. */
+interface ReliabilityBin {
+    readonly lower: number;
+    readonly upper: number;
+    readonly count: number;
+    readonly meanPredicted: number;
+    readonly empiricalRate: number;
+}
+/** Bin predictions by predicted probability into a reliability diagram. */
+declare function reliability(predictions: readonly Prediction[], bins?: number): ReliabilityBin[];
+/** Expected calibration error: the count-weighted mean gap between predicted and empirical rates. */
+declare function expectedCalibrationError(predictions: readonly Prediction[], bins?: number): number;
+/** Options for {@link assessAssumptions}. */
+interface AssessOptions {
+    /** Significance level for the per-dimension goodness-of-fit test. Defaults to 0.05. */
+    readonly alpha?: number;
+    /** Absolute-correlation threshold above which a dimension pair is dependent. Defaults to 0.5. */
+    readonly dependenceThreshold?: number;
+    /** Minimum samples per hypothesis before a dimension's fit is tested. Defaults to 5. */
+    readonly minSamples?: number;
+}
+/**
+ * Assess whether the gate's modeling assumptions hold for a labeled history under a set of dimension
+ * models: the per-dimension Beta goodness-of-fit for both hypotheses, and the conditional-independence
+ * of the dimensions. Produces an {@link AssumptionReport} a gate can consult to escalate instead of
+ * trusting a Bayes Factor computed from a misspecified model.
+ */
+declare function assessAssumptions(history: readonly LabeledObservation[], models: readonly DimensionModel[], options?: AssessOptions): AssumptionReport;
+
+export { type AssessOptions, type GoodnessOfFit, type Prediction, type ReliabilityBin, assessAssumptions, brierScore, expectedCalibrationError, goodnessOfFit, reliability };