@takk/bayesoutputgate 1.0.0

package/dist/policy/index.cjs

@@ -0,0 +1,88 @@
+'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/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 bayesFactor = Math.exp(logBayesFactor);
+    const action2 = bayesFactor >= policy.passAbove ? "pass" : bayesFactor <= 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 };
+}
+
+exports.decide = decide;
+exports.posteriorHighQuality = posteriorHighQuality;

package/dist/policy/index.d.cts

@@ -0,0 +1,11 @@
+import { P as PolicyConfig, i as PolicyDecision } from '../types-bMjn1j4e.cjs';
+
+/**
+ * Convert a natural-log Bayes Factor and a prior probability of high quality into the posterior
+ * probability of high quality, via posterior log-odds equals log-Bayes-Factor plus prior log-odds.
+ */
+declare function posteriorHighQuality(logBayesFactor: number, priorHighQuality: number): number;
+/** Apply a policy to a natural-log Bayes Factor and return the action plus its rationale. */
+declare function decide(logBayesFactor: number, policy: PolicyConfig): PolicyDecision;
+
+export { decide, posteriorHighQuality };

package/dist/policy/index.d.ts

@@ -0,0 +1,11 @@
+import { P as PolicyConfig, i as PolicyDecision } from '../types-bMjn1j4e.js';
+
+/**
+ * Convert a natural-log Bayes Factor and a prior probability of high quality into the posterior
+ * probability of high quality, via posterior log-odds equals log-Bayes-Factor plus prior log-odds.
+ */
+declare function posteriorHighQuality(logBayesFactor: number, priorHighQuality: number): number;
+/** Apply a policy to a natural-log Bayes Factor and return the action plus its rationale. */
+declare function decide(logBayesFactor: number, policy: PolicyConfig): PolicyDecision;
+
+export { decide, posteriorHighQuality };

package/dist/policy/index.js

@@ -0,0 +1,85 @@
+// 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/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 bayesFactor = Math.exp(logBayesFactor);
+    const action2 = bayesFactor >= policy.passAbove ? "pass" : bayesFactor <= 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 };
+}
+
+export { decide, posteriorHighQuality };

package/dist/types-bMjn1j4e.d.cts

@@ -0,0 +1,159 @@
+/** A quality score for one dimension of an output, always in the closed unit interval [0, 1]. */
+interface QualityScore {
+    /** The dimension this score measures, for example "factuality" or "safety". */
+    readonly dimension: string;
+    /** The score in [0, 1], where higher means better quality. */
+    readonly value: number;
+}
+/** A full set of per-dimension scores for a single output. */
+type ScoreVector = readonly QualityScore[];
+/** The two competing hypotheses the gate weighs for every output. */
+type HypothesisKind = "high" | "low";
+/** Parameters of a Beta distribution over a score in [0, 1]. Both must be positive. */
+interface BetaParams {
+    readonly a: number;
+    readonly b: number;
+}
+/**
+ * The calibrated model for one quality dimension: a Beta over the scores of known-high-quality
+ * outputs, a Beta over the scores of known-low-quality outputs, and the weight this dimension
+ * carries in the combined Bayes Factor.
+ */
+interface DimensionModel {
+    readonly dimension: string;
+    readonly high: BetaParams;
+    readonly low: BetaParams;
+    /** Non-negative multiplicative weight on this dimension's log-Bayes-Factor. Defaults to 1. */
+    readonly weight: number;
+}
+/** The label of a historical observation, used to calibrate the per-hypothesis score models. */
+interface LabeledObservation {
+    readonly scores: ScoreVector;
+    /** The known ground-truth quality of this output. */
+    readonly label: HypothesisKind;
+}
+/** Jeffreys-scale strength categories for a Bayes Factor (Kass and Raftery, 1995). */
+type EvidenceStrength = "decisive-low" | "strong-low" | "substantial-low" | "inconclusive" | "substantial-high" | "strong-high" | "decisive-high";
+/** The per-dimension contribution to the combined Bayes Factor. */
+interface DimensionContribution {
+    readonly dimension: string;
+    readonly score: number;
+    readonly logBayesFactor: number;
+    readonly weight: number;
+}
+/** The result of weighing one output's scores against the two hypotheses. */
+interface BayesFactorResult {
+    /** Natural-log Bayes Factor in favor of high quality, summed across weighted dimensions. */
+    readonly logBayesFactor: number;
+    /** The Bayes Factor itself, exp(logBayesFactor). May be Infinity for overwhelming evidence. */
+    readonly bayesFactor: number;
+    /** Which hypothesis the evidence favors. */
+    readonly favored: "high" | "low" | "inconclusive";
+    /** The Jeffreys-scale interpretation of the strength of the evidence. */
+    readonly strength: EvidenceStrength;
+    /** Per-dimension breakdown, in input order. */
+    readonly contributions: readonly DimensionContribution[];
+}
+/** The gate's verdict for an output. */
+type GateAction = "pass" | "fail" | "escalate";
+/**
+ * A decision policy expressed on the Bayes Factor scale. An output passes when the Bayes Factor is
+ * at or above `passAbove`, fails when it is at or below `failBelow`, and escalates in between.
+ */
+interface DecisionPolicy {
+    /** Bayes Factor at or above which the output passes. Must be >= 1. Defaults to 10 (Jeffreys strong). */
+    readonly passAbove: number;
+    /** Bayes Factor at or below which the output fails. Must be in (0, 1]. Defaults to 0.1. */
+    readonly failBelow: number;
+}
+/**
+ * A pure Bayes Factor decision policy on the Jeffreys scale. An output passes when the Bayes Factor
+ * is at or above `passAbove`, fails at or below `failBelow`, and escalates in between. Evidence-only,
+ * loss-agnostic. Use {@link DecisionTheoreticPolicy} when the costs of the two error types differ.
+ */
+interface BayesFactorPolicy {
+    readonly kind: "bayes-factor";
+    /** Bayes Factor at or above which the output passes. Must be >= 1. */
+    readonly passAbove: number;
+    /** Bayes Factor at or below which the output fails. Must be in (0, 1]. */
+    readonly failBelow: number;
+}
+/**
+ * A decision-theoretic policy. The Bayes Factor is converted to a posterior probability of high
+ * quality through an explicit prior, then the action that minimizes expected loss is chosen under an
+ * asymmetric loss: the cost of passing a low-quality output, the cost of failing a high-quality
+ * output, and the fixed cost of escalating to human review. This makes the gate utility-aware rather
+ * than a re-skinned threshold.
+ */
+interface DecisionTheoreticPolicy {
+    readonly kind: "decision-theoretic";
+    /** Prior probability that an output is high quality, before its scores. Must be in (0, 1). */
+    readonly priorHighQuality: number;
+    /** Loss incurred by passing an output that is actually low quality. Must be >= 0. */
+    readonly lossFalsePass: number;
+    /** Loss incurred by failing an output that is actually high quality. Must be >= 0. */
+    readonly lossFalseFail: number;
+    /** Fixed loss of escalating to human review. Must be >= 0. */
+    readonly escalationCost: number;
+}
+/** A gate decision policy. */
+type PolicyConfig = BayesFactorPolicy | DecisionTheoreticPolicy;
+/** The expected loss of each possible action, present for a decision-theoretic policy. */
+interface ExpectedLoss {
+    readonly pass: number;
+    readonly fail: number;
+    readonly escalate: number;
+}
+/** The verdict of a policy applied to a Bayes Factor. */
+interface PolicyDecision {
+    readonly action: GateAction;
+    readonly rationale: "bayes-factor" | "expected-loss";
+    /** Posterior probability of high quality, present for a decision-theoretic policy. */
+    readonly posteriorHighQuality?: number;
+    /** Expected loss per action, present for a decision-theoretic policy. */
+    readonly expectedLoss?: ExpectedLoss;
+}
+/**
+ * A report on whether the gate's modeling assumptions hold for the calibration data. The Bayes
+ * Factor is only trustworthy when the per-dimension Beta fit is adequate and the dimensions are
+ * close enough to conditionally independent; this report makes both checks explicit.
+ */
+interface AssumptionReport {
+    /** True when every checked dimension's Beta fit is adequate (Kolmogorov-Smirnov). */
+    readonly goodnessOfFitAdequate: boolean;
+    /** True when no dimension pair crosses the dependence threshold. */
+    readonly independenceAssumptionSafe: boolean;
+    /** Dimensions whose high-quality or low-quality Beta fit was inadequate. */
+    readonly inadequateDimensions: readonly string[];
+    /** Dimension pairs flagged as dependent, each formatted as "a~b". */
+    readonly dependentPairs: readonly string[];
+}
+/**
+ * Guards that let the gate refuse to trust the Bayes Factor when its modeling assumptions are
+ * violated. A precomputed {@link AssumptionReport} is attached to every decision; when a `require`
+ * flag is set and the matching assumption fails, the gate escalates to human review regardless of
+ * the Bayes Factor, because a verdict from a misspecified model should not be acted on.
+ */
+interface GateGuards {
+    /** A precomputed assumption report, attached to the decision and consulted by the require flags. */
+    readonly assumptions?: AssumptionReport;
+    /** When true, escalate (do not trust the Bayes Factor) if goodness-of-fit is inadequate. */
+    readonly requireGoodnessOfFit?: boolean;
+    /** When true, escalate if the conditional-independence assumption is unsafe. */
+    readonly requireIndependence?: boolean;
+}
+/** The full gate decision for one output, suitable for logging as compliance evidence. */
+interface GateDecision {
+    readonly action: GateAction;
+    readonly bayesFactor: number;
+    readonly logBayesFactor: number;
+    readonly strength: EvidenceStrength;
+    readonly rationale: "bayes-factor" | "expected-loss" | "assumption-violated";
+    readonly posteriorHighQuality?: number;
+    readonly expectedLoss?: ExpectedLoss;
+    /** The assumption report, present when the gate was given one through its guards. */
+    readonly assumptions?: AssumptionReport;
+    readonly contributions: readonly DimensionContribution[];
+}
+
+export type { AssumptionReport as A, BayesFactorPolicy as B, DecisionPolicy as D, EvidenceStrength as E, GateAction as G, HypothesisKind as H, LabeledObservation as L, PolicyConfig as P, QualityScore as Q, ScoreVector as S, BayesFactorResult as a, BetaParams as b, DecisionTheoreticPolicy as c, DimensionContribution as d, DimensionModel as e, ExpectedLoss as f, GateDecision as g, GateGuards as h, PolicyDecision as i };

package/dist/types-bMjn1j4e.d.ts

@@ -0,0 +1,159 @@
+/** A quality score for one dimension of an output, always in the closed unit interval [0, 1]. */
+interface QualityScore {
+    /** The dimension this score measures, for example "factuality" or "safety". */
+    readonly dimension: string;
+    /** The score in [0, 1], where higher means better quality. */
+    readonly value: number;
+}
+/** A full set of per-dimension scores for a single output. */
+type ScoreVector = readonly QualityScore[];
+/** The two competing hypotheses the gate weighs for every output. */
+type HypothesisKind = "high" | "low";
+/** Parameters of a Beta distribution over a score in [0, 1]. Both must be positive. */
+interface BetaParams {
+    readonly a: number;
+    readonly b: number;
+}
+/**
+ * The calibrated model for one quality dimension: a Beta over the scores of known-high-quality
+ * outputs, a Beta over the scores of known-low-quality outputs, and the weight this dimension
+ * carries in the combined Bayes Factor.
+ */
+interface DimensionModel {
+    readonly dimension: string;
+    readonly high: BetaParams;
+    readonly low: BetaParams;
+    /** Non-negative multiplicative weight on this dimension's log-Bayes-Factor. Defaults to 1. */
+    readonly weight: number;
+}
+/** The label of a historical observation, used to calibrate the per-hypothesis score models. */
+interface LabeledObservation {
+    readonly scores: ScoreVector;
+    /** The known ground-truth quality of this output. */
+    readonly label: HypothesisKind;
+}
+/** Jeffreys-scale strength categories for a Bayes Factor (Kass and Raftery, 1995). */
+type EvidenceStrength = "decisive-low" | "strong-low" | "substantial-low" | "inconclusive" | "substantial-high" | "strong-high" | "decisive-high";
+/** The per-dimension contribution to the combined Bayes Factor. */
+interface DimensionContribution {
+    readonly dimension: string;
+    readonly score: number;
+    readonly logBayesFactor: number;
+    readonly weight: number;
+}
+/** The result of weighing one output's scores against the two hypotheses. */
+interface BayesFactorResult {
+    /** Natural-log Bayes Factor in favor of high quality, summed across weighted dimensions. */
+    readonly logBayesFactor: number;
+    /** The Bayes Factor itself, exp(logBayesFactor). May be Infinity for overwhelming evidence. */
+    readonly bayesFactor: number;
+    /** Which hypothesis the evidence favors. */
+    readonly favored: "high" | "low" | "inconclusive";
+    /** The Jeffreys-scale interpretation of the strength of the evidence. */
+    readonly strength: EvidenceStrength;
+    /** Per-dimension breakdown, in input order. */
+    readonly contributions: readonly DimensionContribution[];
+}
+/** The gate's verdict for an output. */
+type GateAction = "pass" | "fail" | "escalate";
+/**
+ * A decision policy expressed on the Bayes Factor scale. An output passes when the Bayes Factor is
+ * at or above `passAbove`, fails when it is at or below `failBelow`, and escalates in between.
+ */
+interface DecisionPolicy {
+    /** Bayes Factor at or above which the output passes. Must be >= 1. Defaults to 10 (Jeffreys strong). */
+    readonly passAbove: number;
+    /** Bayes Factor at or below which the output fails. Must be in (0, 1]. Defaults to 0.1. */
+    readonly failBelow: number;
+}
+/**
+ * A pure Bayes Factor decision policy on the Jeffreys scale. An output passes when the Bayes Factor
+ * is at or above `passAbove`, fails at or below `failBelow`, and escalates in between. Evidence-only,
+ * loss-agnostic. Use {@link DecisionTheoreticPolicy} when the costs of the two error types differ.
+ */
+interface BayesFactorPolicy {
+    readonly kind: "bayes-factor";
+    /** Bayes Factor at or above which the output passes. Must be >= 1. */
+    readonly passAbove: number;
+    /** Bayes Factor at or below which the output fails. Must be in (0, 1]. */
+    readonly failBelow: number;
+}
+/**
+ * A decision-theoretic policy. The Bayes Factor is converted to a posterior probability of high
+ * quality through an explicit prior, then the action that minimizes expected loss is chosen under an
+ * asymmetric loss: the cost of passing a low-quality output, the cost of failing a high-quality
+ * output, and the fixed cost of escalating to human review. This makes the gate utility-aware rather
+ * than a re-skinned threshold.
+ */
+interface DecisionTheoreticPolicy {
+    readonly kind: "decision-theoretic";
+    /** Prior probability that an output is high quality, before its scores. Must be in (0, 1). */
+    readonly priorHighQuality: number;
+    /** Loss incurred by passing an output that is actually low quality. Must be >= 0. */
+    readonly lossFalsePass: number;
+    /** Loss incurred by failing an output that is actually high quality. Must be >= 0. */
+    readonly lossFalseFail: number;
+    /** Fixed loss of escalating to human review. Must be >= 0. */
+    readonly escalationCost: number;
+}
+/** A gate decision policy. */
+type PolicyConfig = BayesFactorPolicy | DecisionTheoreticPolicy;
+/** The expected loss of each possible action, present for a decision-theoretic policy. */
+interface ExpectedLoss {
+    readonly pass: number;
+    readonly fail: number;
+    readonly escalate: number;
+}
+/** The verdict of a policy applied to a Bayes Factor. */
+interface PolicyDecision {
+    readonly action: GateAction;
+    readonly rationale: "bayes-factor" | "expected-loss";
+    /** Posterior probability of high quality, present for a decision-theoretic policy. */
+    readonly posteriorHighQuality?: number;
+    /** Expected loss per action, present for a decision-theoretic policy. */
+    readonly expectedLoss?: ExpectedLoss;
+}
+/**
+ * A report on whether the gate's modeling assumptions hold for the calibration data. The Bayes
+ * Factor is only trustworthy when the per-dimension Beta fit is adequate and the dimensions are
+ * close enough to conditionally independent; this report makes both checks explicit.
+ */
+interface AssumptionReport {
+    /** True when every checked dimension's Beta fit is adequate (Kolmogorov-Smirnov). */
+    readonly goodnessOfFitAdequate: boolean;
+    /** True when no dimension pair crosses the dependence threshold. */
+    readonly independenceAssumptionSafe: boolean;
+    /** Dimensions whose high-quality or low-quality Beta fit was inadequate. */
+    readonly inadequateDimensions: readonly string[];
+    /** Dimension pairs flagged as dependent, each formatted as "a~b". */
+    readonly dependentPairs: readonly string[];
+}
+/**
+ * Guards that let the gate refuse to trust the Bayes Factor when its modeling assumptions are
+ * violated. A precomputed {@link AssumptionReport} is attached to every decision; when a `require`
+ * flag is set and the matching assumption fails, the gate escalates to human review regardless of
+ * the Bayes Factor, because a verdict from a misspecified model should not be acted on.
+ */
+interface GateGuards {
+    /** A precomputed assumption report, attached to the decision and consulted by the require flags. */
+    readonly assumptions?: AssumptionReport;
+    /** When true, escalate (do not trust the Bayes Factor) if goodness-of-fit is inadequate. */
+    readonly requireGoodnessOfFit?: boolean;
+    /** When true, escalate if the conditional-independence assumption is unsafe. */
+    readonly requireIndependence?: boolean;
+}
+/** The full gate decision for one output, suitable for logging as compliance evidence. */
+interface GateDecision {
+    readonly action: GateAction;
+    readonly bayesFactor: number;
+    readonly logBayesFactor: number;
+    readonly strength: EvidenceStrength;
+    readonly rationale: "bayes-factor" | "expected-loss" | "assumption-violated";
+    readonly posteriorHighQuality?: number;
+    readonly expectedLoss?: ExpectedLoss;
+    /** The assumption report, present when the gate was given one through its guards. */
+    readonly assumptions?: AssumptionReport;
+    readonly contributions: readonly DimensionContribution[];
+}
+
+export type { AssumptionReport as A, BayesFactorPolicy as B, DecisionPolicy as D, EvidenceStrength as E, GateAction as G, HypothesisKind as H, LabeledObservation as L, PolicyConfig as P, QualityScore as Q, ScoreVector as S, BayesFactorResult as a, BetaParams as b, DecisionTheoreticPolicy as c, DimensionContribution as d, DimensionModel as e, ExpectedLoss as f, GateDecision as g, GateGuards as h, PolicyDecision as i };

package/package.json

@@ -0,0 +1,142 @@
+{
+  "name": "@takk/bayesoutputgate",
+  "version": "1.0.0",
+  "description": "BayesOutputGate: calibrated quality scoring with the Bayes Factor for output validation. Feed the quality scores of an output across one or more dimensions and get a calibrated pass, fail, or escalate decision on the Jeffreys scale instead of an arbitrary threshold. A zero-runtime-dependency, TypeScript-first output-validation gate for Massive Intelligence (IM) infrastructure and non-human entities, with a principled Bayes Factor between a high-quality and a low-quality hypothesis, calibrated likelihoods that update online, multi-dimension scoring (factuality, fluency, safety, relevance), measured calibration (reliability, Brier, ECE), a tamper-evident audit trail, and a node-free core that runs in Node, edge runtimes, and the browser, with optional peers @takk/keymesh and @takk/modelchain.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "author": "David C Cavalcante <davcavalcante@proton.me> (https://takk.ag)",
+  "homepage": "https://github.com/davccavalcante/bayesoutputgate",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davccavalcante/bayesoutputgate.git"
+  },
+  "bugs": {
+    "url": "https://github.com/davccavalcante/bayesoutputgate/issues"
+  },
+  "keywords": [
+    "bayes-factor",
+    "output-validation",
+    "quality-gate",
+    "calibration",
+    "llm-as-judge",
+    "hallucination-detection",
+    "guardrails",
+    "bayesian",
+    "eu-ai-act",
+    "compliance",
+    "mcp",
+    "edge",
+    "llm",
+    "nodejs",
+    "zero-dependency",
+    "typescript"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "packageManager": "pnpm@10.34.1",
+  "sideEffects": false,
+  "bin": {
+    "bayesoutputgate": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "NOTICE",
+    "SPEC.md",
+    "SECURITY.md"
+  ],
+  "exports": {
+    ".": {
+      "import": { "types": "./dist/index.d.ts", "default": "./dist/index.js" },
+      "require": { "types": "./dist/index.d.cts", "default": "./dist/index.cjs" }
+    },
+    "./beta": {
+      "import": { "types": "./dist/beta/index.d.ts", "default": "./dist/beta/index.js" },
+      "require": { "types": "./dist/beta/index.d.cts", "default": "./dist/beta/index.cjs" }
+    },
+    "./hypothesis": {
+      "import": { "types": "./dist/hypothesis/index.d.ts", "default": "./dist/hypothesis/index.js" },
+      "require": { "types": "./dist/hypothesis/index.d.cts", "default": "./dist/hypothesis/index.cjs" }
+    },
+    "./likelihood": {
+      "import": { "types": "./dist/likelihood/index.d.ts", "default": "./dist/likelihood/index.js" },
+      "require": { "types": "./dist/likelihood/index.d.cts", "default": "./dist/likelihood/index.cjs" }
+    },
+    "./bayesfactor": {
+      "import": { "types": "./dist/bayesfactor/index.d.ts", "default": "./dist/bayesfactor/index.js" },
+      "require": { "types": "./dist/bayesfactor/index.d.cts", "default": "./dist/bayesfactor/index.cjs" }
+    },
+    "./dimensions": {
+      "import": { "types": "./dist/dimensions/index.d.ts", "default": "./dist/dimensions/index.js" },
+      "require": { "types": "./dist/dimensions/index.d.cts", "default": "./dist/dimensions/index.cjs" }
+    },
+    "./policy": {
+      "import": { "types": "./dist/policy/index.d.ts", "default": "./dist/policy/index.js" },
+      "require": { "types": "./dist/policy/index.d.cts", "default": "./dist/policy/index.cjs" }
+    },
+    "./calibration": {
+      "import": { "types": "./dist/calibration/index.d.ts", "default": "./dist/calibration/index.js" },
+      "require": { "types": "./dist/calibration/index.d.cts", "default": "./dist/calibration/index.cjs" }
+    },
+    "./gate": {
+      "import": { "types": "./dist/gate/index.d.ts", "default": "./dist/gate/index.js" },
+      "require": { "types": "./dist/gate/index.d.cts", "default": "./dist/gate/index.cjs" }
+    },
+    "./audit": {
+      "import": { "types": "./dist/audit/index.d.ts", "default": "./dist/audit/index.js" },
+      "require": { "types": "./dist/audit/index.d.cts", "default": "./dist/audit/index.cjs" }
+    },
+    "./adapter": {
+      "import": { "types": "./dist/adapter/index.d.ts", "default": "./dist/adapter/index.js" },
+      "require": { "types": "./dist/adapter/index.d.cts", "default": "./dist/adapter/index.cjs" }
+    },
+    "./node": {
+      "import": { "types": "./dist/node/index.d.ts", "default": "./dist/node/index.js" },
+      "require": { "types": "./dist/node/index.d.cts", "default": "./dist/node/index.cjs" }
+    },
+    "./edge": {
+      "import": { "types": "./dist/edge/index.d.ts", "default": "./dist/edge/index.js" },
+      "require": { "types": "./dist/edge/index.d.cts", "default": "./dist/edge/index.cjs" }
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "smoke:dist": "node scripts/smoke-dist.mjs",
+    "publint": "publint",
+    "attw": "attw --pack . --profile node16",
+    "size": "size-limit",
+    "verify": "pnpm run lint && pnpm run typecheck && pnpm run test && pnpm run build && pnpm run smoke:dist && pnpm run publint",
+    "prepublishOnly": "pnpm run build"
+  },
+  "peerDependencies": {
+    "@takk/keymesh": ">=1.0.0",
+    "@takk/modelchain": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@takk/keymesh": { "optional": true },
+    "@takk/modelchain": { "optional": true }
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.4",
+    "@biomejs/biome": "^2.5.1",
+    "@size-limit/preset-small-lib": "^12.1.0",
+    "@types/node": "^25.0.0",
+    "publint": "^0.3.21",
+    "size-limit": "^12.1.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9",
+    "@vitest/coverage-v8": "^4.1.9"
+  }
+}