@tangle-network/agent-eval 0.179.0 → 0.181.0

package/dist/experiment/index.js

@@ -1,523 +1,18 @@
 import { n as CaptureIntegrityError, s as ValidationError } from "../errors-Dngq5h35.js";
-import { r as canonicalString } from "../canonical-DPyQ_rpt.js";
-import { _ as verifyManifest, g as signManifest, h as manifestContentDigest, m as hashJson, p as evaluateHypothesis } from "../agent-profile-cell-0gSi5ffD.js";
+import { a as hashCanonical } from "../canonical-DPyQ_rpt.js";
+import { _ as verifyManifest, g as signManifest, h as manifestContentDigest, m as hashJson, p as evaluateHypothesis } from "../agent-profile-cell-Cv6UA-W_.js";
 import { t as mulberry32 } from "../random-Dn5fPWkt.js";
 import { a as requiredSampleSize, c as holm, i as requiredPairedSampleSize, n as mcnemarRequiredN, o as benjaminiHochberg, r as pairedMde, s as bonferroni, t as mcnemarPower } from "../power-and-mde-B8F2RdcD.js";
 import { f as mcnemar, g as pairedRiskDifferenceScore, h as pairedRiskDifferenceExact, m as pairedRiskDifference, n as pairArms, r as pairRunRecords, t as comparePairedArms, v as wilson } from "../paired-arms-D4aeIHUy.js";
 import { r as pairedBootstrap, t as BOOTSTRAP_GATE_MIN_N } from "../paired-tests-C8iCsioC.js";
 import { t as eProcess } from "../sequential-eprocess-D1jKoihe.js";
-import { M as heldoutSignificance, N as pairHoldout, O as powerPreflight, a as createEvidenceReceipt, i as INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, n as EVIDENCE_AUTHORITY_KINDS, o as isIndependentEvidence, r as EVIDENCE_RECEIPT_VERSION, s as verifyEvidenceReceipt, t as createCampaignEvidenceReceipt } from "../campaign-evidence-D8DBLqLI.js";
+import { A as FinalEvidenceConflictError, M as openFinalEvidenceLedger, N as defineEvaluationClaim, P as summarizeEvaluationUnits, a as createEvidenceReceipt, at as pairHoldout, i as INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, it as heldoutSignificance, j as FinalEvidenceError, k as powerPreflight, n as EVIDENCE_AUTHORITY_KINDS, o as isIndependentEvidence, r as EVIDENCE_RECEIPT_VERSION, s as verifyEvidenceReceipt, t as createCampaignEvidenceReceipt } from "../campaign-evidence-B8oF9xQ6.js";
+import { _ as runSelectionRule, a as evaluateHaltRule, c as evaluatePopulationReproducibilityGate, d as evaluateProvenanceGate, f as executeDecisionRule, g as readField, h as projectNLadderBudget, i as evaluateCondition, l as evaluatePowerFloorGate, m as powerFloorProblems, n as computeEstimand, o as evaluateIdentityGate, p as intervalSpecProblems, r as computeInterval, s as evaluateOracleDeterminismGate, t as classifyReissue, u as evaluatePredicate, v as runUniformPassBudget } from "../ast-CP9ae9B0.js";
 import { a as inMemoryExperimentStore, r as fileExperimentStore, t as ExperimentTracker } from "../experiment-tracker-BKEumQug.js";
 import { n as pairedEvalueSequence, r as sequentialCrossingHorizon } from "../sequential-CzK5DarL.js";
-import { n as paretoPolicy, r as paretoSignificanceGate, t as buildEvidenceVector } from "../promotion-policy-DWOm70gx.js";
-import { n as sequentialPairedGate, t as sequentialDecide } from "../sequential-B5gXgcyp.js";
-import { createHash } from "node:crypto";
+import { n as paretoPolicy, r as paretoSignificanceGate, t as buildEvidenceVector } from "../promotion-policy-CDMMxzb6.js";
+import { n as sequentialPairedGate, t as sequentialDecide } from "../sequential-DAsyV2T9.js";
 import { z } from "zod";
-//#region src/experiment/ast.ts
-/**
-* The registered-rule AST: every rule an experiment registers is DATA.
-*
-* A closure cannot be canonicalized or hashed; a node tree can. `sealExperiment`
-* hashes the whole tree, and every interpreter in this file takes only a node
-* plus evidence records — no parameter for alpha, threshold, metric, or
-* stopping rule exists on any executable surface. The registered object and
-* the executed object are therefore the same object, and registered-vs-ran
-* drift is unrepresentable rather than checked.
-*
-* Node families:
-*   Predicate       closed-key comparisons — the only leaf
-*   AdmissionRule   monotone funnel stages with registered waivers
-*   SelectionRule   deterministic subsets over a closed field set
-*   Estimand        what the experiment measures
-*   IntervalSpec    how uncertainty is computed, seed included
-*   Condition       decision guards over named derived quantities
-*   DecisionRule    ordered verdict table, or a registered absence of one
-*   Obligation      a control that must exist before a verdict class is read
-*   ValidityGate    pre-spend design checks
-*   HaltRule        gates as prerequisites — failure refuses the spend
-*   BudgetRule      spend schedules with a named ledger
-*   MatchedBudgetRule  arm budget matching as a refusal
-*   ReissuePolicy   carrier faults are reissued; model outcomes stand
-*/
-/** A decision rule's branches did not cover the evidence. */
-var DecisionTableNotTotalError = class extends ValidationError {};
-/** Read a dot-separated field path. Missing segments yield `undefined`. */
-function readField(record, path) {
-	let current = record;
-	for (const key of path.split(".")) {
-		if (current === null || typeof current !== "object") return void 0;
-		current = current[key];
-	}
-	return current;
-}
-/** Evaluate a predicate against one evidence record. */
-function evaluatePredicate(predicate, record) {
-	switch (predicate.kind) {
-		case "compare": return compareValues(readField(record, predicate.field), predicate.op, predicate.value);
-		case "in": return predicate.values.includes(readField(record, predicate.field));
-		case "all": return predicate.of.every((p) => evaluatePredicate(p, record));
-		case "any": return predicate.of.some((p) => evaluatePredicate(p, record));
-		case "not": return !evaluatePredicate(predicate.of, record);
-	}
-}
-/** Numbers compare numerically; everything else compares as strings. */
-function compareValues(value, op, target) {
-	if (op === "eq") return value === target;
-	if (op === "ne") return value !== target;
-	const numeric = typeof value === "number" && typeof target === "number";
-	const left = numeric ? value : String(value);
-	const right = numeric ? target : String(target);
-	switch (op) {
-		case "lt": return left < right;
-		case "lte": return left <= right;
-		case "gt": return left > right;
-		case "gte": return left >= right;
-	}
-}
-/**
-* Execute a selection rule.
-*
-* Round-robin walks groups in lexicographic order and takes ids in
-* within-group order until `take` ids are chosen. Filter-of keeps the ids of
-* `bases[rule.base]` whose record satisfies the predicate, in the registered
-* order. Ids absent from `records` are evaluated on their id alone (fields
-* derived from the id via `idFields`), so a sealed base outlives its source
-* records.
-*/
-function runSelectionRule(rule, records, options) {
-	if (rule.kind === "round-robin") {
-		const allowed = new Set(rule.reads);
-		for (const field of [rule.groupBy, rule.withinOrder.field]) if (!allowed.has(field)) throw new ValidationError(`runSelectionRule: round-robin reads '${field}' but its closed read set is [${rule.reads.join(", ")}]`);
-		const byGroup = /* @__PURE__ */ new Map();
-		for (const record of records) {
-			const group = String(readField(record, rule.groupBy));
-			const id = String(readField(record, rule.withinOrder.field));
-			const bucket = byGroup.get(group);
-			if (bucket) bucket.push(id);
-			else byGroup.set(group, [id]);
-		}
-		for (const ids of byGroup.values()) {
-			ids.sort();
-			if (rule.withinOrder.dir === "desc") ids.reverse();
-		}
-		const groups = [...byGroup.keys()].sort();
-		const chosen = [];
-		let cursor = 0;
-		while (chosen.length < rule.take && groups.some((g) => byGroup.get(g).length > 0)) {
-			const group = groups[cursor % groups.length];
-			const ids = byGroup.get(group);
-			if (ids.length > 0) chosen.push(ids.shift());
-			cursor += 1;
-		}
-		return chosen;
-	}
-	const base = options.bases?.[rule.base];
-	if (!base) throw new ValidationError(`runSelectionRule: filter-of base '${rule.base}' was not provided`);
-	const index = new Map(records.map((r) => [String(readField(r, options.idField)), r]));
-	const sorted = [...base.filter((id) => {
-		const record = index.get(id) ?? options.idFields?.(id);
-		if (!record) throw new ValidationError(`runSelectionRule: base id '${id}' has no record and no idFields derivation`);
-		return evaluatePredicate(rule.keep, record);
-	})].sort();
-	if (rule.order.dir === "desc") sorted.reverse();
-	return sorted;
-}
-function evaluateSetExpr(expr, rows, armField, idField) {
-	if (expr.kind === "rows-where") {
-		const ids = /* @__PURE__ */ new Set();
-		for (const row of rows) {
-			if (String(readField(row, armField)) !== expr.arm) continue;
-			if (evaluatePredicate(expr.event, row)) ids.add(String(readField(row, idField)));
-		}
-		return ids;
-	}
-	if (expr.of.length === 0) throw new ValidationError("computeEstimand: empty intersect");
-	const [first, ...rest] = expr.of.map((e) => evaluateSetExpr(e, rows, armField, idField));
-	const out = /* @__PURE__ */ new Set();
-	for (const id of first) if (rest.every((s) => s.has(id))) out.add(id);
-	return out;
-}
-/**
-* Read one registered outcome field as a number.
-*
-* A binary outcome reaches evidence as `true` or `false`. Its mean is the pass
-* rate and the mean of its paired differences is the risk difference, so
-* `true` reads as 1 and `false` as 0 — the same quantity a caller would
-* otherwise encode by hand, and the same reading in every interpreter here.
-* Every other type, and a non-finite number, is a measurement defect: it
-* rejects instead of poisoning the mean with `NaN` or a coerced zero.
-*/
-function readNumericOutcome(raw, context, field, where) {
-	if (typeof raw === "boolean") return raw ? 1 : 0;
-	if (typeof raw === "number" && Number.isFinite(raw)) return raw;
-	throw new ValidationError(`${context}: value field '${field}' is not a finite number or a boolean on ${where}`);
-}
-/** Compute an estimand over evidence rows. Pure; reads only registered fields. */
-function computeEstimand(estimand, rows) {
-	switch (estimand.kind) {
-		case "rate": {
-			const numerator = rows.filter((r) => evaluatePredicate(estimand.event, r)).length;
-			if (rows.length === 0) throw new ValidationError("computeEstimand: rate over zero rows");
-			return {
-				value: numerator / rows.length,
-				numerator,
-				denominator: rows.length
-			};
-		}
-		case "rate-at-least-once": {
-			const byGroup = /* @__PURE__ */ new Map();
-			for (const row of rows) {
-				const group = String(readField(row, estimand.groupBy));
-				const hit = evaluatePredicate(estimand.event, row);
-				byGroup.set(group, (byGroup.get(group) ?? false) || hit);
-			}
-			if (byGroup.size === 0) throw new ValidationError("computeEstimand: rate-at-least-once over zero groups");
-			const numerator = [...byGroup.values()].filter(Boolean).length;
-			return {
-				value: numerator / byGroup.size,
-				numerator,
-				denominator: byGroup.size
-			};
-		}
-		case "paired-mean-diff": {
-			const byPair = /* @__PURE__ */ new Map();
-			for (const row of rows) {
-				const arm = String(readField(row, estimand.armField));
-				if (arm !== estimand.treatment && arm !== estimand.control) continue;
-				const pair = String(readField(row, estimand.pairBy));
-				const value = readNumericOutcome(readField(row, estimand.value), "computeEstimand paired-mean-diff", estimand.value, `pair '${pair}'`);
-				const slot = byPair.get(pair) ?? {};
-				if (arm === estimand.treatment) slot.treatment = value;
-				else slot.control = value;
-				byPair.set(pair, slot);
-			}
-			if (byPair.size === 0) throw new ValidationError("computeEstimand: paired-mean-diff over zero pairs");
-			let sum = 0;
-			for (const slot of byPair.values()) sum += (slot.treatment ?? 0) - (slot.control ?? 0);
-			return {
-				value: sum / byPair.size,
-				numerator: sum,
-				denominator: byPair.size
-			};
-		}
-		case "set-ratio": {
-			const numeratorSet = evaluateSetExpr(estimand.numerator, rows, estimand.armField, estimand.idField);
-			const denominatorSet = evaluateSetExpr(estimand.denominator, rows, estimand.armField, estimand.idField);
-			if (denominatorSet.size === 0) throw new ValidationError("computeEstimand: set-ratio denominator set is empty");
-			return {
-				value: numeratorSet.size / denominatorSet.size,
-				numerator: numeratorSet.size,
-				denominator: denominatorSet.size
-			};
-		}
-	}
-}
-/**
-* Execute an interval spec.
-*
-* Cluster-bootstrap resamples whole clusters of the per-row `value` field and
-* takes percentile bounds of the pooled mean. Clopper-Pearson computes the
-* exact binomial interval and requires `successes`/`trials` evidence instead
-* of rows.
-*/
-function computeInterval(spec, evidence) {
-	if (spec.kind === "cluster-bootstrap") {
-		if (evidence.kind !== "rows") throw new ValidationError("computeInterval: cluster-bootstrap requires row evidence");
-		const clusters = /* @__PURE__ */ new Map();
-		for (const row of evidence.rows) {
-			const cluster = String(readField(row, spec.clusterBy));
-			const value = readNumericOutcome(readField(row, evidence.value), "computeInterval cluster-bootstrap", evidence.value, `cluster '${cluster}'`);
-			const bucket = clusters.get(cluster);
-			if (bucket) bucket.push(value);
-			else clusters.set(cluster, [value]);
-		}
-		const clusterValues = [...clusters.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, values]) => values);
-		if (clusterValues.length < 2) throw new ValidationError(`computeInterval: cluster-bootstrap needs >= 2 clusters, got ${clusterValues.length}`);
-		const rng = mulberry32(spec.seed);
-		const means = new Array(spec.resamples);
-		for (let draw = 0; draw < spec.resamples; draw++) {
-			let sum = 0;
-			let count = 0;
-			for (let pick = 0; pick < clusterValues.length; pick++) {
-				const cluster = clusterValues[Math.floor(rng() * clusterValues.length)];
-				for (const value of cluster) sum += value;
-				count += cluster.length;
-			}
-			means[draw] = sum / count;
-		}
-		means.sort((a, b) => a - b);
-		const alpha = 1 - spec.level;
-		const lowerIndex = Math.floor(alpha / 2 * spec.resamples);
-		const upperIndex = Math.min(spec.resamples - 1, Math.ceil((1 - alpha / 2) * spec.resamples) - 1);
-		return {
-			lower: means[lowerIndex],
-			upper: means[Math.max(lowerIndex, upperIndex)],
-			level: spec.level
-		};
-	}
-	if (evidence.kind !== "binomial") throw new ValidationError("computeInterval: clopper-pearson requires binomial evidence");
-	const { successes, trials } = evidence;
-	if (!Number.isInteger(successes) || !Number.isInteger(trials) || trials <= 0 || successes < 0) throw new ValidationError(`computeInterval: clopper-pearson needs 0 <= successes <= trials, got ${successes}/${trials}`);
-	if (successes > trials) throw new ValidationError(`computeInterval: clopper-pearson successes ${successes} exceed trials ${trials}`);
-	const alpha = 1 - spec.level;
-	return {
-		lower: successes === 0 ? 0 : binomialQuantile(successes, trials, alpha / 2, "lower"),
-		upper: successes === trials ? 1 : binomialQuantile(successes, trials, alpha / 2, "upper"),
-		level: spec.level
-	};
-}
-/**
-* Clopper-Pearson bound by bisection on the binomial tail. The lower bound is
-* the p with P(X >= successes | p) = alpha; the upper is the p with
-* P(X <= successes | p) = alpha. Deterministic, no special functions.
-*/
-function binomialQuantile(successes, trials, alpha, side) {
-	const tail = (p) => {
-		let sum = 0;
-		for (let k = 0; k <= trials; k++) {
-			if (!(side === "lower" ? k >= successes : k <= successes)) continue;
-			sum += Math.exp(logBinomialPmf(k, trials, p));
-		}
-		return sum;
-	};
-	let lo = 0;
-	let hi = 1;
-	for (let iter = 0; iter < 100; iter++) {
-		const mid = (lo + hi) / 2;
-		if (tail(mid) < alpha) if (side === "lower") lo = mid;
-		else hi = mid;
-		else if (side === "lower") hi = mid;
-		else lo = mid;
-	}
-	return (lo + hi) / 2;
-}
-function logBinomialPmf(k, n, p) {
-	if (p <= 0) return k === 0 ? 0 : Number.NEGATIVE_INFINITY;
-	if (p >= 1) return k === n ? 0 : Number.NEGATIVE_INFINITY;
-	return logChoose(n, k) + k * Math.log(p) + (n - k) * Math.log(1 - p);
-}
-function logChoose(n, k) {
-	return logFactorial(n) - logFactorial(k) - logFactorial(n - k);
-}
-const LOG_FACTORIAL_CACHE = [0];
-function logFactorial(n) {
-	for (let i = LOG_FACTORIAL_CACHE.length; i <= n; i++) LOG_FACTORIAL_CACHE[i] = LOG_FACTORIAL_CACHE[i - 1] + Math.log(i);
-	return LOG_FACTORIAL_CACHE[n];
-}
-function evaluateCondition(condition, evidence) {
-	switch (condition.kind) {
-		case "interval-excludes-zero": {
-			const interval = evidence.intervals[condition.interval];
-			if (!interval) throw new ValidationError(`evaluateCondition: interval '${condition.interval}' is not in the evidence`);
-			return (interval.lower > 0 || interval.upper < 0) && (condition.sign === "positive" ? interval.lower > 0 : interval.upper < 0);
-		}
-		case "interval-includes-zero": {
-			const interval = evidence.intervals[condition.interval];
-			if (!interval) throw new ValidationError(`evaluateCondition: interval '${condition.interval}' is not in the evidence`);
-			return interval.lower <= 0 && interval.upper >= 0;
-		}
-		case "quantity-threshold": {
-			const value = evidence.quantities[condition.quantity];
-			if (value === void 0) throw new ValidationError(`evaluateCondition: quantity '${condition.quantity}' is not in the evidence`);
-			return compareValues(value, condition.op, condition.value);
-		}
-		case "obligation-met": return evidence.obligationsMet[condition.obligation] === true;
-		case "all": return condition.of.every((c) => evaluateCondition(c, evidence));
-		case "any": return condition.of.some((c) => evaluateCondition(c, evidence));
-		case "not": return !evaluateCondition(condition.of, evidence);
-	}
-}
-function executeDecisionRule(rule, evidence) {
-	if (rule.kind === "report-only") return {
-		verdict: "report-only",
-		report: [...rule.estimands, ...rule.intervals]
-	};
-	for (const branch of rule.branches) if (evaluateCondition(branch.when, evidence)) return {
-		verdict: branch.verdict,
-		report: branch.report
-	};
-	throw new DecisionTableNotTotalError("executeDecisionRule: decision table is not total — no branch matched the evidence");
-}
-/**
-* Replicate-flip counting over graded states. A state whose replicates split
-* between pass and fail is flipping; its flip rate is the minority share.
-*/
-function evaluateOracleDeterminismGate(id, gate, repsByState) {
-	const evidence = {};
-	let passed = true;
-	for (const [state, reps] of Object.entries(repsByState)) {
-		const passes = reps.filter(Boolean).length;
-		const flipRate = reps.length === 0 ? 0 : Math.min(passes, reps.length - passes) / reps.length;
-		evidence[state] = {
-			passes,
-			replicates: reps.length,
-			flipRate
-		};
-		if (flipRate > gate.maxFlipRate) passed = false;
-	}
-	return {
-		id,
-		passed,
-		evidence
-	};
-}
-/**
-* Join two population snapshots on `joinOn` and compare the registered fields.
-* Only rows present in both snapshots are compared; a presence change is a
-* different failure and needs its own gate.
-*/
-function evaluatePopulationReproducibilityGate(id, gate, populations) {
-	const rightByKey = new Map(populations.right.map((r) => [String(readField(r, gate.joinOn)), r]));
-	const changed = [];
-	for (const left of populations.left) {
-		const key = String(readField(left, gate.joinOn));
-		const right = rightByKey.get(key);
-		if (!right) continue;
-		const moved = gate.compare.filter((f) => readField(left, f) !== readField(right, f));
-		if (moved.length > 0) changed.push(`${key} ${moved.map((f) => `${f}:${String(readField(left, f))}->${String(readField(right, f))}`).join(" ")}`);
-	}
-	return {
-		id,
-		passed: changed.length <= gate.maxChangedRows,
-		evidence: changed
-	};
-}
-/** The registered claim about provenance must hold on the provenance record. */
-function evaluateProvenanceGate(id, gate, provenance) {
-	const passed = evaluatePredicate(gate.claim, provenance);
-	return {
-		id,
-		passed,
-		evidence: { claimHolds: passed }
-	};
-}
-/** Final path segment equality between the pinned and the served identity. */
-function evaluateIdentityGate(id, _gate, identities) {
-	const basename = (s) => s.split("/").pop() ?? s;
-	const passed = basename(identities.pinned) === basename(identities.served);
-	return {
-		id,
-		passed,
-		evidence: {
-			pinned: identities.pinned,
-			served: identities.served,
-			matched: passed
-		}
-	};
-}
-/**
-* The design's power curve must reach the registered target at some grid
-* effect. The curve must cover the registered effect grid exactly — a curve
-* computed on a different grid is different evidence and is refused.
-*/
-function evaluatePowerFloorGate(id, gate, curve) {
-	const byEffect = new Map(curve.map((point) => [point.effect, point.power]));
-	const missing = gate.effectGrid.filter((effect) => !byEffect.has(effect));
-	if (missing.length > 0) throw new ValidationError(`evaluatePowerFloorGate: curve does not cover registered effects [${missing.join(", ")}]`);
-	const powers = gate.effectGrid.map((effect) => byEffect.get(effect));
-	const maxPower = Math.max(...powers);
-	return {
-		id,
-		passed: maxPower >= gate.target,
-		evidence: {
-			target: gate.target,
-			maxPower,
-			curve: gate.effectGrid.map((effect) => ({
-				effect,
-				power: byEffect.get(effect)
-			}))
-		}
-	};
-}
-function evaluateHaltRule(halt, gates) {
-	const seen = new Map(gates.map((g) => [g.id, g]));
-	const missing = halt.when.gates.filter((id) => !seen.has(id));
-	if (missing.length > 0) throw new ValidationError(`evaluateHaltRule: halt references gates that were not evaluated: [${missing.join(", ")}]`);
-	const failed = halt.when.gates.filter((id) => !seen.get(id).passed);
-	return failed.length > 0 ? {
-		fired: true,
-		action: halt.action,
-		failedGates: failed
-	} : {
-		fired: false,
-		action: null,
-		failedGates: []
-	};
-}
-/**
-* Execute the uniform-pass schedule against measured pass costs. Pass 1 always
-* runs; each later pass runs only when the cumulative spend plus the last
-* measured pass cost stays at or under the registered ceiling. The registered
-* ledger is the pre-spend the ceiling counts.
-*/
-function runUniformPassBudget(rule, measuredPassCosts) {
-	let cumulative = rule.ledger.reduce((sum, entry) => sum + entry.usd, 0);
-	const decisions = [];
-	let uniformN = 0;
-	for (let pass = 1; pass <= rule.maxPasses; pass++) {
-		if (pass === 1) {
-			if (measuredPassCosts[0] === void 0) break;
-			cumulative += measuredPassCosts[0];
-			uniformN = 1;
-			continue;
-		}
-		const projected = measuredPassCosts[pass - 2];
-		if (projected === void 0) break;
-		const go = cumulative + projected <= rule.ceilingUsd;
-		decisions.push({
-			pass,
-			cumulativeBefore: cumulative,
-			projected,
-			go
-		});
-		if (!go || measuredPassCosts[pass - 1] === void 0) break;
-		cumulative += measuredPassCosts[pass - 1];
-		uniformN = pass;
-	}
-	return {
-		decisions,
-		uniformN
-	};
-}
-/**
-* Walk the registered n-ladder and pick the first affordable step. When no
-* step fits the ceiling, the rule refuses and reports the projection instead
-* of shrinking the row set — "never subset rows" is the registered invariant.
-*/
-function projectNLadderBudget(rule, measured) {
-	const projections = rule.steps.map((n) => {
-		const projectedUsd = measured.unitCostUsd * measured.rows * n;
-		return {
-			n,
-			projectedUsd,
-			affordable: projectedUsd <= rule.ceilingUsd
-		};
-	});
-	const first = projections.find((p) => p.affordable);
-	if (first) return {
-		chosenN: first.n,
-		projections,
-		refusal: null
-	};
-	return {
-		chosenN: null,
-		projections,
-		refusal: {
-			onExhaust: rule.onExhaust,
-			reason: `no ladder step fits the ${rule.ceilingUsd} USD ceiling at ${measured.rows} rows x ${measured.unitCostUsd} USD per unit`
-		}
-	};
-}
-/**
-* Classify one rollout event under the registered reissue policy. A carrier
-* event within the issue budget is reissued; a model outcome always stands;
-* a carrier event past `maxIssues` is exhausted and reported, never retried.
-*/
-function classifyReissue(policy, event, issuesSoFar) {
-	if (!policy.carrierEvents.includes(event)) return "stands";
-	return issuesSoFar < policy.maxIssues ? "reissue" : "exhausted";
-}
-//#endregion
 //#region src/experiment/budget.ts
 /**
 * Matched-budget verification between arms, as a refusal object.
@@ -805,6 +300,7 @@ function conditionRefs(condition) {
 */
 function defineExperiment(spec) {
 	const problems = [];
+	const claim = spec.claim === void 0 ? void 0 : defineEvaluationClaim(spec.claim);
 	if (!spec.id || spec.id.trim().length === 0) problems.push("id is empty");
 	if (spec.arms.length === 0) problems.push("at least one arm is required");
 	const armIds = /* @__PURE__ */ new Set();
@@ -819,6 +315,15 @@ function defineExperiment(spec) {
 	const gateNames = new Set(Object.keys(spec.gates ?? {}));
 	const selectionNames = new Set(Object.keys(spec.selections ?? {}));
 	const sealedSubsetNames = new Set(Object.keys(spec.sealedSubsets ?? {}));
+	for (const [name, interval] of Object.entries(spec.intervals ?? {})) problems.push(...intervalSpecProblems(interval).map((problem) => `interval '${name}': ${problem}`));
+	for (const [name, gate] of Object.entries(spec.gates ?? {})) {
+		if (gate.kind !== "power-floor") continue;
+		problems.push(...powerFloorProblems(gate).map((problem) => `gate '${name}': ${problem}`));
+		if (claim?.minimumEffect !== void 0 && gate.minimumEffect !== claim.minimumEffect) problems.push(`gate '${name}' minimumEffect differs from the evaluation claim`);
+	}
+	if (claim?.generalization === "new-units") {
+		for (const [name, interval] of Object.entries(spec.intervals ?? {})) if (interval?.kind === "cluster-bootstrap" && interval.clusterBy !== claim.independentUnit) problems.push(`interval '${name}' must resample '${claim.independentUnit}' from the evaluation claim`);
+	}
 	const checkCondition = (condition, where) => {
 		const refs = conditionRefs(condition);
 		for (const name of refs.intervals) if (!intervalNames.has(name)) problems.push(`${where} reads unregistered interval '${name}'`);
@@ -853,7 +358,10 @@ function defineExperiment(spec) {
 		for (const partition of spec.admission.partitions ?? []) if (!stageIds.has(partition.from)) problems.push(`admission partition '${partition.id}' draws from unknown stage '${partition.from}'`);
 	}
 	if (problems.length > 0) throw new ValidationError(`defineExperiment('${spec.id}'): ${problems.join("; ")}`);
-	return deepFreeze(structuredClone(spec));
+	return deepFreeze(structuredClone({
+		...spec,
+		...claim ? { claim } : {}
+	}));
 }
 function deepFreeze(value) {
 	if (value !== null && typeof value === "object") {
@@ -865,7 +373,7 @@ function deepFreeze(value) {
 /** Validate, canonicalize, and hash a spec into its registration. */
 async function sealExperiment(spec, options = {}) {
 	const validated = defineExperiment(spec);
-	const digest = specDigest(validated, "sha256-rfc8785");
+	const digest = specDigest(validated);
 	return {
 		spec: validated,
 		digest,
@@ -881,46 +389,39 @@ async function sealExperiment(spec, options = {}) {
 * There is no way to change what is decided without producing a new digest.
 */
 async function amendExperiment(sealed, amendment) {
-	await assertSealIntact(sealed);
-	const validated = defineExperiment(amendment.spec);
-	const digest = specDigest(validated, "sha256-rfc8785");
+	const captured = structuredClone(sealed);
+	const requested = structuredClone(amendment);
+	await assertSealIntact(captured);
+	const validated = defineExperiment(requested.spec);
+	const digest = specDigest(validated);
 	return {
 		spec: validated,
 		digest,
 		algo: "sha256-rfc8785",
-		sealedAt: sealed.sealedAt,
-		initialDigest: sealed.initialDigest,
-		amendments: [...sealed.amendments, {
-			at: amendment.at ?? (/* @__PURE__ */ new Date()).toISOString(),
-			reason: amendment.reason,
-			blind: [...amendment.blind],
+		sealedAt: captured.sealedAt,
+		initialDigest: captured.initialDigest,
+		amendments: [...captured.amendments, {
+			at: requested.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+			reason: requested.reason,
+			blind: [...requested.blind],
 			digest
 		}]
 	};
 }
-/** True when the sealed digest still matches the spec it carries, under the
-*  scheme the seal declares. */
+/** True when the supported seal matches its canonical spec. */
 async function verifySealedExperiment(sealed) {
-	return specDigest(sealed.spec, sealed.algo) === sealed.digest;
-}
-/**
-* Serialize a spec under `algo` and digest it. `'sha256-content'` is read-only
-* — it exists so a seal written by an earlier release still verifies, and no
-* path that WRITES a digest may pass it.
-*/
-function specDigest(spec, algo) {
-	const serialized = algo === "sha256-rfc8785" ? canonicalString(spec) : JSON.stringify(sortKeysDeep(spec));
-	return createHash("sha256").update(serialized, "utf8").digest("hex");
+	if (sealed.algo !== "sha256-rfc8785") return false;
+	try {
+		return specDigest(sealed.spec) === sealed.digest;
+	} catch {
+		return false;
+	}
 }
-function sortKeysDeep(value) {
-	if (value === null || typeof value !== "object") return value;
-	if (Array.isArray(value)) return value.map(sortKeysDeep);
-	const out = {};
-	for (const key of Object.keys(value).sort()) out[key] = sortKeysDeep(value[key]);
-	return out;
+function specDigest(spec) {
+	return hashCanonical(spec).slice(7);
 }
 async function assertSealIntact(sealed) {
-	if (!await verifySealedExperiment(sealed)) throw new SealIntegrityError(`sealed experiment '${sealed.spec.id}' digest ${sealed.digest} does not match its spec — the registration was tampered with`);
+	if (!await verifySealedExperiment(sealed)) throw new SealIntegrityError(`sealed experiment '${sealed.spec.id}' has an unsupported digest scheme or its digest does not match its canonical spec`);
 }
 /**
 * Verify the seal and return executors bound to it. This is the module's only
@@ -928,14 +429,20 @@ async function assertSealIntact(sealed) {
 * rule that is cannot run differently.
 */
 async function openSealedExperiment(sealed) {
-	await assertSealIntact(sealed);
-	const spec = sealed.spec;
+	const captured = structuredClone(sealed);
+	await assertSealIntact(captured);
+	const spec = defineExperiment(captured.spec);
+	const frozenSeal = deepFreeze({
+		...captured,
+		spec
+	});
 	const need = (value, what) => {
 		if (value === void 0) throw new ValidationError(`experiment '${spec.id}' registered no ${what}`);
 		return value;
 	};
 	return {
-		sealed,
+		sealed: frozenSeal,
+		units: (records) => summarizeEvaluationUnits(need(spec.claim, "evaluation claim"), records),
 		decide: (evidence) => executeDecisionRule(spec.decision, evidence),
 		admit: (records) => executeAdmissionRule(need(spec.admission, "admission rule"), records),
 		select: (name, records, options) => {
@@ -968,7 +475,27 @@ async function openSealedExperiment(sealed) {
 		},
 		matchedBudgets: (arms) => verifyMatchedBudgets(need(spec.matchedBudget, "matched-budget rule"), arms),
 		estimate: (name, rows) => computeEstimand(need(spec.estimands?.[name], `estimand '${name}'`), rows),
-		interval: (name, evidence) => computeInterval(need(spec.intervals?.[name], `interval '${name}'`), evidence)
+		interval: (name, evidence) => {
+			const interval = need(spec.intervals?.[name], `interval '${name}'`);
+			const claim = spec.claim;
+			let units;
+			if (claim && evidence.kind === "rows") units = summarizeEvaluationUnits(claim, evidence.rows);
+			else if (claim?.generalization === "new-units" && evidence.kind === "binomial") {
+				if (evidence.unitIds === void 0 || evidence.unitIds.length !== evidence.trials || new Set(evidence.unitIds).size !== evidence.trials || evidence.unitIds.some((id) => typeof id !== "string" || !id.trim() || id.trim() !== id)) throw new ValidationError("claimed binomial interval needs one unique unitId per independent trial");
+				units = {
+					observations: evidence.trials,
+					independentUnits: evidence.trials,
+					units: evidence.unitIds.map((id) => ({
+						id,
+						observations: 1
+					}))
+				};
+			}
+			return {
+				...computeInterval(interval, evidence),
+				...units ? { units } : {}
+			};
+		}
 	};
 }
 //#endregion
@@ -1173,25 +700,33 @@ function renderEvidenceIndex(raws) {
 var DesignRefusalError = class extends ValidationError {};
 /**
 * Simulate the power of a whole-cluster percentile-bootstrap design and refuse
-* a structure that cannot reach the target at any registered effect.
+* a structure that cannot reach target power at the declared minimum effect.
 */
 function clusteredPower(options) {
 	const clusterSizes = options.clusterSizes;
 	if (clusterSizes.length === 0 || clusterSizes.some((n) => !Number.isInteger(n) || n <= 0)) throw new ValidationError(`clusteredPower: clusterSizes must be positive integers, got [${clusterSizes.join(", ")}]`);
 	if (options.effects.length === 0) throw new ValidationError("clusteredPower: effects grid is empty");
+	if (options.effects.some((effect) => !Number.isFinite(effect) || effect < 0 || effect > 1) || new Set(options.effects).size !== options.effects.length) throw new ValidationError("clusteredPower: effects must be unique finite values in [0,1]");
+	if (!Number.isFinite(options.minimumEffect) || options.minimumEffect <= 0 || options.minimumEffect > 1) throw new ValidationError("clusteredPower: minimumEffect must be in (0,1]");
+	if (!options.effects.includes(options.minimumEffect)) throw new ValidationError("clusteredPower: effects must contain minimumEffect exactly; no interpolation is assumed");
 	if (!Number.isInteger(options.seed)) throw new ValidationError(`clusteredPower: seed must be an integer, got ${options.seed}`);
 	const trials = options.trials ?? 2e3;
 	const resamples = options.resamples ?? 4e3;
 	if (!Number.isInteger(trials) || trials <= 0 || !Number.isInteger(resamples) || resamples <= 0) throw new ValidationError(`clusteredPower: trials and resamples must be positive integers, got ${trials}/${resamples}`);
 	const confidence = options.confidence ?? .95;
-	if (confidence <= 0 || confidence >= 1) throw new ValidationError(`clusteredPower: confidence must be in (0,1), got ${confidence}`);
+	if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) throw new ValidationError(`clusteredPower: confidence must be in (0,1), got ${confidence}`);
 	const alpha = options.alpha ?? .05;
 	const targetPower = options.targetPower ?? .8;
+	if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) throw new ValidationError("clusteredPower: alpha must be in (0,1)");
+	if (!Number.isFinite(targetPower) || targetPower <= 0 || targetPower > 1) throw new ValidationError("clusteredPower: targetPower must be in (0,1]");
 	const baseWinRate = options.baseWinRate ?? .1;
 	const baseLossRate = options.baseLossRate ?? .1;
+	if (!Number.isFinite(baseWinRate) || !Number.isFinite(baseLossRate) || baseWinRate < 0 || baseLossRate < 0 || baseWinRate + baseLossRate > 1) throw new ValidationError("clusteredPower: base win/loss rates must be nonnegative and sum to at most 1");
+	if (baseWinRate !== baseLossRate) throw new ValidationError("clusteredPower: the zero-effect model requires equal baseWinRate and baseLossRate");
 	const noisy = /* @__PURE__ */ new Map();
 	for (const cluster of options.noisyClusters ?? []) {
-		if (cluster.index < 0 || cluster.index >= clusterSizes.length) throw new ValidationError(`clusteredPower: noisy cluster index ${cluster.index} outside [0,${clusterSizes.length - 1}]`);
+		if (!Number.isInteger(cluster.index) || cluster.index < 0 || cluster.index >= clusterSizes.length) throw new ValidationError(`clusteredPower: noisy cluster index ${cluster.index} outside [0,${clusterSizes.length - 1}]`);
+		if (noisy.has(cluster.index) || !Number.isFinite(cluster.flipRate) || cluster.flipRate < 0 || cluster.flipRate > 1) throw new ValidationError("clusteredPower: noisy clusters need unique indices and flipRate in [0,1]");
 		noisy.set(cluster.index, cluster.flipRate);
 	}
 	const clusterCount = clusterSizes.length;
@@ -1209,12 +744,10 @@ function clusteredPower(options) {
 		noisy
 	}));
 	const maxPower = Math.max(...curve.map((point) => point.power));
+	const powerAtMinimumEffect = curve.find((point) => point.effect === options.minimumEffect).power;
 	const reasons = [];
 	if (!signFlipFloor.certifiableAtAlpha) reasons.push(`${clusterCount} clusters cannot certify any effect size, including 1.0: the exact whole-cluster sign-flip test's smallest two-sided p is 2^(1-${clusterCount}) = ${signFlipFloor.twoSidedP} > alpha ${alpha}; at least ${signFlipFloor.minClustersForAlpha} clusters are needed`);
-	if (maxPower < targetPower) {
-		const best = curve.reduce((a, b) => b.power > a.power ? b : a);
-		reasons.push(`simulated power tops out at ${maxPower.toFixed(3)} (effect ${best.effect}) across the registered grid — below the ${targetPower} target at every effect`);
-	}
+	if (powerAtMinimumEffect < targetPower) reasons.push(`simulated power ${powerAtMinimumEffect.toFixed(3)} at minimum worthwhile effect ${options.minimumEffect} is below target ${targetPower}; maximum grid power ${maxPower.toFixed(3)} does not establish adequacy at that effect`);
 	const adequate = reasons.length === 0;
 	return {
 		clusterCount,
@@ -1224,6 +757,8 @@ function clusteredPower(options) {
 		seed: options.seed,
 		confidence,
 		targetPower,
+		minimumEffect: options.minimumEffect,
+		powerAtMinimumEffect,
 		curve,
 		maxPower,
 		signFlipFloor,
@@ -1231,7 +766,7 @@ function clusteredPower(options) {
 		refusal: adequate ? null : {
 			verdict: "underpowered",
 			reasons,
-			recommendation: `Do not spend on this structure. Add independent clusters (>= ${Math.max(signFlipFloor.minClustersForAlpha, clusterCount)}) or register a design whose simulated power reaches ${targetPower}, then re-run clusteredPower.`
+			recommendation: `Do not spend on this structure. Add independent clusters (>= ${Math.max(signFlipFloor.minClustersForAlpha, clusterCount)}) or register a design whose simulated power reaches ${targetPower} at effect ${options.minimumEffect}, then re-run clusteredPower.`
 		}
 	};
 }
@@ -1253,9 +788,10 @@ function computeSignFlipFloor(clusterCount, alpha) {
 	};
 }
 /**
-* One effect point. Per row the paired contrast is +1 with probability
-* min(baseWin + effect, 1), -1 with the base loss rate (capped by what
-* remains), else 0. Noisy clusters draw win and loss independently at their
+* One effect point. Loss probability is min(baseLoss, (1-effect)/2) and
+* win probability is loss probability plus effect. Their difference equals
+* effect, including near the probability boundary. Noisy clusters draw win
+* and loss independently at their
 * flip rate. Each trial computes a whole-cluster percentile bootstrap of the
 * pooled row mean; the trial counts toward power when the interval excludes
 * zero.
@@ -1277,8 +813,8 @@ function simulateEffect(effect, config) {
 				const loss = rng() < flipRate ? 1 : 0;
 				sum += win - loss;
 			} else {
-				const winRate = Math.min(1, config.baseWinRate + effect);
-				const lossRate = Math.min(1 - winRate, config.baseLossRate);
+				const lossRate = Math.min(config.baseLossRate, (1 - effect) / 2);
+				const winRate = lossRate + effect;
 				const u = rng();
 				sum += u < winRate ? 1 : u < winRate + lossRate ? -1 : 0;
 			}
@@ -1313,6 +849,6 @@ function mixSeed(seed, effect) {
 	return (seed ^ Math.round(effect * 1000003) * 2654435769) >>> 0 | 0;
 }
 //#endregion
-export { BOOTSTRAP_GATE_MIN_N, DesignRefusalError, EVIDENCE_AUTHORITY_KINDS, EVIDENCE_RECEIPT_VERSION, EVIDENCE_STATES, ExperimentTracker, FunnelIntegrityError, INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, MatchedBudgetError, SealIntegrityError, amendExperiment, assertDesignAdequate, assertFunnelReconciles, assertMatchedBudgets, benjaminiHochberg, bonferroni, buildEvidenceVector, buildFunnel, classifyReissue, clusteredPower, comparePairedArms, composeFunnels, computeEstimand, computeInterval, createCampaignEvidenceReceipt, createEvidenceReceipt, defineExperiment, eProcess, evaluateCondition, evaluateHaltRule, evaluateHypothesis, evaluateIdentityGate, evaluateOracleDeterminismGate, evaluatePopulationReproducibilityGate, evaluatePowerFloorGate, evaluatePredicate, evaluateProvenanceGate, evidenceRegistryRecordSchema, executeAdmissionRule, executeDecisionRule, fileExperimentStore, hashJson, heldoutSignificance, holm, inMemoryExperimentStore, isIndependentEvidence, manifestContentDigest, mcnemar, mcnemarPower, mcnemarRequiredN, mulberry32, openSealedExperiment, pairArms, pairHoldout, pairRunRecords, pairedBootstrap, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, paretoPolicy, paretoSignificanceGate, parseEvidenceRegistryRecord, powerPreflight, projectNLadderBudget, readField, renderEvidenceIndex, renderFunnelTable, requiredPairedSampleSize, requiredSampleSize, runSelectionRule, runUniformPassBudget, sealExperiment, sequentialCrossingHorizon, sequentialDecide, sequentialPairedGate, signManifest, validateEvidenceRegistry, verifyEvidenceReceipt, verifyManifest, verifyMatchedBudgets, verifySealedExperiment, wilson };
+export { BOOTSTRAP_GATE_MIN_N, DesignRefusalError, EVIDENCE_AUTHORITY_KINDS, EVIDENCE_RECEIPT_VERSION, EVIDENCE_STATES, ExperimentTracker, FinalEvidenceConflictError, FinalEvidenceError, FunnelIntegrityError, INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, MatchedBudgetError, SealIntegrityError, amendExperiment, assertDesignAdequate, assertFunnelReconciles, assertMatchedBudgets, benjaminiHochberg, bonferroni, buildEvidenceVector, buildFunnel, classifyReissue, clusteredPower, comparePairedArms, composeFunnels, computeEstimand, computeInterval, createCampaignEvidenceReceipt, createEvidenceReceipt, defineEvaluationClaim, defineExperiment, eProcess, evaluateCondition, evaluateHaltRule, evaluateHypothesis, evaluateIdentityGate, evaluateOracleDeterminismGate, evaluatePopulationReproducibilityGate, evaluatePowerFloorGate, evaluatePredicate, evaluateProvenanceGate, evidenceRegistryRecordSchema, executeAdmissionRule, executeDecisionRule, fileExperimentStore, hashJson, heldoutSignificance, holm, inMemoryExperimentStore, isIndependentEvidence, manifestContentDigest, mcnemar, mcnemarPower, mcnemarRequiredN, mulberry32, openFinalEvidenceLedger, openSealedExperiment, pairArms, pairHoldout, pairRunRecords, pairedBootstrap, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, paretoPolicy, paretoSignificanceGate, parseEvidenceRegistryRecord, powerPreflight, projectNLadderBudget, readField, renderEvidenceIndex, renderFunnelTable, requiredPairedSampleSize, requiredSampleSize, runSelectionRule, runUniformPassBudget, sealExperiment, sequentialCrossingHorizon, sequentialDecide, sequentialPairedGate, signManifest, summarizeEvaluationUnits, validateEvidenceRegistry, verifyEvidenceReceipt, verifyManifest, verifyMatchedBudgets, verifySealedExperiment, wilson };
 
 //# sourceMappingURL=index.js.map