@tangle-network/agent-eval 0.144.6 → 0.144.7

package/dist/experiment/index.js

@@ -0,0 +1,1108 @@
+import { c as ValidationError, n as CaptureIntegrityError } from "../errors-D-LKuDhb.js";
+import { a as verifyManifest, i as signManifest, n as evaluateHypothesis, r as hashJson, t as canonicalize } from "../pre-registration-DakwTRXk.js";
+import { A as pairedRiskDifference, B as requiredSampleSize, C as mulberry32, E as pairedBootstrap, G as wilson, M as pairedRiskDifferenceScore, S as mcnemarRequiredN, b as mcnemar, c as bonferroni, h as holm, j as pairedRiskDifferenceExact, k as pairedMde, m as eProcess, s as benjaminiHochberg, t as BOOTSTRAP_GATE_MIN_N, x as mcnemarPower, z as requiredPairedSampleSize } from "../statistics-ByxzSiOM.js";
+import { n as pairArms, r as pairRunRecords, t as comparePairedArms } from "../paired-arms-iZ08VFMN.js";
+import { o as inMemoryExperimentStore, r as fileExperimentStore, s as clusteredPairedBinary, t as ExperimentTracker } from "../experiment-tracker-CnRICnMl.js";
+import { c as heldoutSignificance, i as powerPreflight, l as pairHoldout, n as paretoPolicy, r as paretoSignificanceGate, t as buildEvidenceVector } from "../promotion-policy-CrLrmys8.js";
+import { n as sequentialPairedGate, t as sequentialDecide } from "../sequential-D-BLJBKU.js";
+import { n as pairedEvalueSequence } from "../sequential-Br0mAPHA.js";
+//#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;
+}
+/** 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 = readField(row, estimand.value);
+				if (typeof value !== "number") throw new ValidationError(`computeEstimand: paired-mean-diff value field '${estimand.value}' is not a number on 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 = readField(row, evidence.value);
+			if (typeof value !== "number") throw new ValidationError(`computeInterval: value field '${evidence.value}' is not a number in 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.
+*
+* A paired contrast is only meaningful when both arms spent comparable
+* resources; "realized prompt and completion tokens must agree within 5%" is
+* a registered rule, so its verification returns a verdict artifact — the
+* refusal lives inside the result, never in prose beside it.
+*/
+/** Arms whose realized budgets diverge past the registered tolerance. */
+var MatchedBudgetError = class extends CaptureIntegrityError {};
+/**
+* Compare realized per-arm spend under the registered tolerance. Requires at
+* least two arms — a single arm has nothing to match against. Negative or
+* non-finite token counts are refused as evidence corruption, not compared.
+*/
+function verifyMatchedBudgets(rule, arms) {
+	if (arms.length < 2) throw new MatchedBudgetError(`verifyMatchedBudgets: need >= 2 arms to match budgets, got ${arms.length}`);
+	for (const arm of arms) if (!Number.isFinite(arm.realizedTokens) || arm.realizedTokens < 0) throw new MatchedBudgetError(`verifyMatchedBudgets: arm '${arm.armId}' has invalid realized tokens ${arm.realizedTokens}`);
+	const sorted = [...arms].sort((a, b) => a.realizedTokens - b.realizedTokens);
+	const min = sorted[0];
+	const max = sorted[sorted.length - 1];
+	const maxRelativeGap = max.realizedTokens === 0 ? 0 : (max.realizedTokens - min.realizedTokens) / max.realizedTokens;
+	const matched = maxRelativeGap <= rule.tolerance;
+	return {
+		rule,
+		arms: [...arms],
+		maxRelativeGap,
+		widestPair: [min.armId, max.armId],
+		matched,
+		refusal: matched ? null : {
+			onFail: rule.onFail,
+			reason: `realized ${rule.measure} diverge ${(maxRelativeGap * 100).toFixed(1)}% between '${min.armId}' (${min.realizedTokens}) and '${max.armId}' (${max.realizedTokens}) — registered tolerance is ${(rule.tolerance * 100).toFixed(1)}%; the contrast is refused`
+		}
+	};
+}
+/** Throw the refusal for callers that gate the contrast on it. */
+function assertMatchedBudgets(rule, arms) {
+	const verdict = verifyMatchedBudgets(rule, arms);
+	if (verdict.refusal) throw new MatchedBudgetError(verdict.refusal.reason);
+	return verdict;
+}
+//#endregion
+//#region src/experiment/funnel.ts
+/**
+* The denominator chain as a first-class object.
+*
+* A benchmark whose denominator is not auditable is not a benchmark. Every
+* stage names what entered, what it removed, and what survived, so
+* `input = surviving + sum(excluded)` reads off the table instead of being
+* trusted. A stage that gains rows is refused at construction — a funnel is
+* monotone by definition, and a non-monotone one is a broken denominator,
+* not a formatting choice.
+*
+* The object is its own JSON render; `renderFunnelTable` is the text render.
+* `executeAdmissionRule` produces one by running a sealed {@link AdmissionRule}
+* over evidence records.
+*/
+/** A funnel stage gained rows, double-counted them, or failed to reconcile. */
+var FunnelIntegrityError = class extends CaptureIntegrityError {};
+/**
+* Build a funnel from counts and refuse anything non-monotone.
+*
+* Refusals: a negative count, a stage that gains rows (excluded < 0 is the
+* only way to gain — `remaining = entering - excluded` by construction, so a
+* gain cannot be smuggled in through `remaining`), named exclusions that do
+* not sum to the stage total, and a partition drawing from an unknown stage
+* or exceeding what that stage excluded.
+*/
+function buildFunnel(input) {
+	if (!Number.isInteger(input.input) || input.input < 0) throw new FunnelIntegrityError(`funnel input must be a non-negative integer, got ${input.input}`);
+	let entering = input.input;
+	const stages = [];
+	for (const stage of input.stages) {
+		if (!Number.isInteger(stage.excluded)) throw new FunnelIntegrityError(`funnel stage '${stage.id}' excluded count must be an integer, got ${stage.excluded}`);
+		if (stage.excluded < 0) throw new FunnelIntegrityError(`funnel stage '${stage.id}' gains ${-stage.excluded} rows — a funnel stage can only remove rows`);
+		if (stage.excluded > entering) throw new FunnelIntegrityError(`funnel stage '${stage.id}' excludes ${stage.excluded} rows but only ${entering} entered`);
+		if (stage.exclusions) {
+			const sum = Object.values(stage.exclusions).reduce((a, b) => a + b, 0);
+			if (sum !== stage.excluded) throw new FunnelIntegrityError(`funnel stage '${stage.id}' names exclusions summing to ${sum} but excludes ${stage.excluded}`);
+		}
+		const remaining = entering - stage.excluded;
+		stages.push({
+			id: stage.id,
+			entering,
+			excluded: stage.excluded,
+			remaining,
+			...stage.exclusions ? { exclusions: { ...stage.exclusions } } : {},
+			...stage.waives ? { waives: [...stage.waives] } : {}
+		});
+		entering = remaining;
+	}
+	const byStage = new Map(stages.map((s) => [s.id, s]));
+	const partitions = (input.partitions ?? []).map((partition) => {
+		const source = byStage.get(partition.from);
+		if (!source) throw new FunnelIntegrityError(`funnel partition '${partition.id}' draws from unknown stage '${partition.from}'`);
+		if (partition.count < 0 || partition.count > source.excluded) throw new FunnelIntegrityError(`funnel partition '${partition.id}' counts ${partition.count} rows but stage '${partition.from}' excluded ${source.excluded}`);
+		return {
+			id: partition.id,
+			from: partition.from,
+			count: partition.count,
+			pooling: "never"
+		};
+	});
+	const funnel = {
+		population: input.population,
+		input: input.input,
+		stages,
+		surviving: entering,
+		partitions
+	};
+	assertFunnelReconciles(funnel);
+	return funnel;
+}
+/** A chain that does not add up is a broken denominator, so this throws. */
+function assertFunnelReconciles(funnel) {
+	const excluded = funnel.stages.reduce((sum, stage) => sum + stage.excluded, 0);
+	if (funnel.input !== funnel.surviving + excluded) throw new FunnelIntegrityError(`funnel '${funnel.population}' does not reconcile: input ${funnel.input} != surviving ${funnel.surviving} + excluded ${excluded}`);
+	let entering = funnel.input;
+	for (const stage of funnel.stages) {
+		if (stage.entering !== entering || stage.remaining !== stage.entering - stage.excluded) throw new FunnelIntegrityError(`funnel '${funnel.population}' stage '${stage.id}' does not chain: entering ${stage.entering} (expected ${entering}), remaining ${stage.remaining}`);
+		if (stage.remaining > stage.entering) throw new FunnelIntegrityError(`funnel '${funnel.population}' stage '${stage.id}' gains rows: ${stage.entering} -> ${stage.remaining}`);
+		entering = stage.remaining;
+	}
+}
+/**
+* Run a sealed admission rule over evidence records. Each stage keeps the rows
+* its predicate accepts; partitions draw from the rows their source stage
+* dropped. The result embeds the funnel, so the denominator chain and the
+* surviving rows can never disagree.
+*/
+function executeAdmissionRule(rule, records) {
+	let current = [...records];
+	const droppedAt = /* @__PURE__ */ new Map();
+	const stageInputs = [];
+	for (const stage of rule.stages) {
+		const kept = [];
+		const dropped = [];
+		for (const record of current) if (evaluatePredicate(stage.keep, record)) kept.push(record);
+		else dropped.push(record);
+		droppedAt.set(stage.id, dropped);
+		stageInputs.push({
+			id: stage.id,
+			excluded: dropped.length,
+			...stage.waives ? { waives: stage.waives } : {}
+		});
+		current = kept;
+	}
+	const partitionRows = {};
+	const partitionCounts = [];
+	for (const partition of rule.partitions ?? []) {
+		const source = droppedAt.get(partition.from);
+		if (!source) throw new FunnelIntegrityError(`admission partition '${partition.id}' draws from unknown stage '${partition.from}'`);
+		const rows = source.filter((record) => evaluatePredicate(partition.keep, record));
+		partitionRows[partition.id] = rows;
+		partitionCounts.push({
+			id: partition.id,
+			from: partition.from,
+			count: rows.length
+		});
+	}
+	return {
+		funnel: buildFunnel({
+			population: rule.population,
+			input: records.length,
+			stages: stageInputs,
+			partitions: partitionCounts
+		}),
+		survivors: current,
+		partitionRows
+	};
+}
+/**
+* Chain two funnels whose boundary agrees: the second funnel's input must be
+* exactly the first funnel's survivors. Anything else is a gap or an
+* injection, and both are refused.
+*/
+function composeFunnels(first, second) {
+	if (second.input !== first.surviving) throw new FunnelIntegrityError(`cannot compose funnels: '${first.population}' survives ${first.surviving} rows but '${second.population}' starts from ${second.input}`);
+	return buildFunnel({
+		population: first.population,
+		input: first.input,
+		stages: [...first.stages, ...second.stages].map((stage) => ({
+			id: stage.id,
+			excluded: stage.excluded,
+			...stage.exclusions ? { exclusions: stage.exclusions } : {},
+			...stage.waives ? { waives: stage.waives } : {}
+		})),
+		partitions: [...first.partitions, ...second.partitions].map((partition) => ({
+			id: partition.id,
+			from: partition.from,
+			count: partition.count
+		}))
+	});
+}
+/**
+* Text render of the chain. One row per stage; the reconciliation line at the
+* bottom restates `input = surviving + excluded` so a reader can check the
+* arithmetic without a tool.
+*/
+function renderFunnelTable(funnel) {
+	const rows = funnel.stages.map((stage) => [
+		stage.id + (stage.waives?.length ? ` (waives: ${stage.waives.join(", ")})` : ""),
+		String(stage.entering),
+		String(stage.excluded),
+		String(stage.remaining)
+	]);
+	const header = [
+		"stage",
+		"entering",
+		"excluded",
+		"remaining"
+	];
+	const widths = header.map((h, col) => Math.max(h.length, ...rows.map((r) => r[col].length)));
+	const line = (cells) => cells.map((cell, col) => cell.padEnd(widths[col])).join("  ");
+	const out = [
+		`population: ${funnel.population}`,
+		`input: ${funnel.input}`,
+		line(header),
+		line(widths.map((w) => "-".repeat(w))),
+		...rows.map((r) => line(r))
+	];
+	const excluded = funnel.stages.reduce((sum, stage) => sum + stage.excluded, 0);
+	out.push(`surviving: ${funnel.surviving}  (input ${funnel.input} = surviving ${funnel.surviving} + excluded ${excluded})`);
+	for (const partition of funnel.partitions) out.push(`partition ${partition.id}: ${partition.count} rows from '${partition.from}' — reported separately, never pooled`);
+	return out.join("\n");
+}
+//#endregion
+//#region src/experiment/define.ts
+/**
+* Define, seal, and execute experiments whose every rule is registered data.
+*
+* `defineExperiment` validates the cross-references inside a spec and freezes
+* it. `sealExperiment` canonicalizes and hashes the whole tree — arms, row
+* admission, selection, estimands, intervals, decision rule, gates, halt,
+* budget — into one digest that lands on every downstream artifact. Changing
+* what is decided requires a new digest: an amendment is a re-seal with a
+* reason and blindness attestations, and the digest history is the audit
+* trail.
+*
+* `openSealedExperiment` is the only execution surface. It verifies the seal
+* and returns executors bound to the sealed spec; none of them takes a
+* parameter for alpha, threshold, metric, or stopping rule, so
+* registered-vs-ran drift is unrepresentable rather than checked.
+*/
+/** A sealed experiment whose digest no longer matches its spec. */
+var SealIntegrityError = class extends ValidationError {};
+function conditionRefs(condition) {
+	switch (condition.kind) {
+		case "interval-excludes-zero":
+		case "interval-includes-zero": return {
+			intervals: [condition.interval],
+			quantities: [],
+			obligations: []
+		};
+		case "quantity-threshold": return {
+			intervals: [],
+			quantities: [condition.quantity],
+			obligations: []
+		};
+		case "obligation-met": return {
+			intervals: [],
+			quantities: [],
+			obligations: [condition.obligation]
+		};
+		case "all":
+		case "any": {
+			const nested = condition.of.map(conditionRefs);
+			return {
+				intervals: nested.flatMap((r) => r.intervals),
+				quantities: nested.flatMap((r) => r.quantities),
+				obligations: nested.flatMap((r) => r.obligations)
+			};
+		}
+		case "not": return conditionRefs(condition.of);
+	}
+}
+/**
+* Validate every cross-reference inside a spec and freeze it.
+*
+* A decision condition may only read a registered interval, a registered
+* estimand, or a registered obligation; a halt rule may only reference
+* registered gates; a filter-of base must resolve to a registered selection
+* or sealed subset. Anything else is refused here, before sealing.
+*/
+function defineExperiment(spec) {
+	const problems = [];
+	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();
+	for (const arm of spec.arms) {
+		if (armIds.has(arm.id)) problems.push(`duplicate arm id '${arm.id}'`);
+		armIds.add(arm.id);
+	}
+	if (!spec.arms.some((arm) => arm.role === "treatment")) problems.push("at least one arm must have role treatment");
+	const intervalNames = new Set(Object.keys(spec.intervals ?? {}));
+	const estimandNames = new Set(Object.keys(spec.estimands ?? {}));
+	const obligationIds = new Set((spec.obligations ?? []).map((o) => o.id));
+	const gateNames = new Set(Object.keys(spec.gates ?? {}));
+	const selectionNames = new Set(Object.keys(spec.selections ?? {}));
+	const sealedSubsetNames = new Set(Object.keys(spec.sealedSubsets ?? {}));
+	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}'`);
+		for (const name of refs.quantities) if (!estimandNames.has(name)) problems.push(`${where} reads unregistered quantity '${name}'`);
+		for (const name of refs.obligations) if (!obligationIds.has(name)) problems.push(`${where} reads unregistered obligation '${name}'`);
+	};
+	if (spec.decision.kind === "table") {
+		if (spec.decision.branches.length === 0) problems.push("decision table has no branches");
+		spec.decision.branches.forEach((branch, index) => {
+			checkCondition(branch.when, `decision branch ${index} ('${branch.verdict}')`);
+		});
+	} else {
+		for (const name of spec.decision.estimands) if (!estimandNames.has(name)) problems.push(`report-only decision names unregistered estimand '${name}'`);
+		for (const name of spec.decision.intervals) if (!intervalNames.has(name)) problems.push(`report-only decision names unregistered interval '${name}'`);
+	}
+	if (spec.decision.kind === "table" && spec.obligations) {
+		const verdicts = new Set(spec.decision.branches.map((b) => b.verdict));
+		for (const obligation of spec.obligations) for (const verdict of obligation.appliesToVerdicts) if (!verdicts.has(verdict)) problems.push(`obligation '${obligation.id}' applies to verdict '${verdict}' which no branch produces`);
+	}
+	if (spec.halt) {
+		for (const gate of spec.halt.when.gates) if (!gateNames.has(gate)) problems.push(`halt rule references unregistered gate '${gate}'`);
+	}
+	for (const [name, selection] of Object.entries(spec.selections ?? {})) if (selection.kind === "filter-of") {
+		if (!selectionNames.has(selection.base) && !sealedSubsetNames.has(selection.base)) problems.push(`selection '${name}' filters unregistered base '${selection.base}' (not a selection or sealed subset)`);
+	}
+	if (spec.admission) {
+		const stageIds = /* @__PURE__ */ new Set();
+		for (const stage of spec.admission.stages) {
+			if (stageIds.has(stage.id)) problems.push(`duplicate admission stage id '${stage.id}'`);
+			stageIds.add(stage.id);
+		}
+		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));
+}
+function deepFreeze(value) {
+	if (value !== null && typeof value === "object") {
+		for (const key of Object.keys(value)) deepFreeze(value[key]);
+		Object.freeze(value);
+	}
+	return value;
+}
+/** Validate, canonicalize, and hash a spec into its registration. */
+async function sealExperiment(spec, options = {}) {
+	const validated = defineExperiment(spec);
+	const digest = await hashJson(validated);
+	return {
+		spec: validated,
+		digest,
+		algo: "sha256-content",
+		sealedAt: options.sealedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		initialDigest: digest,
+		amendments: []
+	};
+}
+/**
+* Amend a sealed experiment. The current seal is verified first, the new spec
+* is validated and re-hashed, and the amendment appends to the digest chain.
+* 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 = await hashJson(validated);
+	return {
+		spec: validated,
+		digest,
+		algo: "sha256-content",
+		sealedAt: sealed.sealedAt,
+		initialDigest: sealed.initialDigest,
+		amendments: [...sealed.amendments, {
+			at: amendment.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+			reason: amendment.reason,
+			blind: [...amendment.blind],
+			digest
+		}]
+	};
+}
+/** True when the sealed digest still matches the spec it carries. */
+async function verifySealedExperiment(sealed) {
+	return await hashJson(sealed.spec) === sealed.digest;
+}
+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`);
+}
+/**
+* Verify the seal and return executors bound to it. This is the module's only
+* execution surface: a rule that is not in the sealed spec cannot run, and a
+* rule that is cannot run differently.
+*/
+async function openSealedExperiment(sealed) {
+	await assertSealIntact(sealed);
+	const spec = sealed.spec;
+	const need = (value, what) => {
+		if (value === void 0) throw new ValidationError(`experiment '${spec.id}' registered no ${what}`);
+		return value;
+	};
+	return {
+		sealed,
+		decide: (evidence) => executeDecisionRule(spec.decision, evidence),
+		admit: (records) => executeAdmissionRule(need(spec.admission, "admission rule"), records),
+		select: (name, records, options) => {
+			return runSelectionRule(need(spec.selections?.[name], `selection '${name}'`), records, {
+				idField: options.idField,
+				bases: spec.sealedSubsets
+			});
+		},
+		gate: (name, evidence) => {
+			const gate = need(spec.gates?.[name], `gate '${name}'`);
+			if (gate.kind !== evidence.kind) throw new ValidationError(`gate '${name}' is registered as ${gate.kind} but received ${evidence.kind} evidence`);
+			switch (gate.kind) {
+				case "oracle-determinism": return evaluateOracleDeterminismGate(name, gate, evidence.repsByState);
+				case "population-reproducibility": return evaluatePopulationReproducibilityGate(name, gate, evidence);
+				case "provenance-assertion": return evaluateProvenanceGate(name, gate, evidence.provenance);
+				case "identity": return evaluateIdentityGate(name, gate, evidence);
+				case "power-floor": return evaluatePowerFloorGate(name, gate, evidence.curve);
+			}
+		},
+		halt: (gates) => evaluateHaltRule(need(spec.halt, "halt rule"), gates),
+		runUniformPassBudget: (measuredPassCosts) => {
+			const budget = need(spec.budget, "budget rule");
+			if (budget.kind !== "uniform-pass") throw new ValidationError(`experiment '${spec.id}' registered a ${budget.kind} budget, not uniform-pass`);
+			return runUniformPassBudget(budget, measuredPassCosts);
+		},
+		projectNLadderBudget: (measured) => {
+			const budget = need(spec.budget, "budget rule");
+			if (budget.kind !== "n-ladder") throw new ValidationError(`experiment '${spec.id}' registered a ${budget.kind} budget, not n-ladder`);
+			return projectNLadderBudget(budget, measured);
+		},
+		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)
+	};
+}
+//#endregion
+//#region src/experiment/power.ts
+/**
+* Design-time power for task-clustered paired designs, with a refusal verdict.
+*
+* The failure this prevents (measured): a pre-registered kill test fixed a
+* task-clustered bootstrap over 14 rows in 4 task clusters. Simulated at the
+* registered seed, the design's power topped out at 0.69 — at a per-row
+* effect of 1.0. "Four clusters cannot certify any effect size, including
+* 1.0" was learned by running the experiment; this module computes it before
+* a dollar is spent.
+*
+* Two floors, one simulation:
+*  - Closed form, zero spend: with C independent clusters the exact
+*    whole-cluster sign-flip test can never produce a two-sided p below
+*    2^(1-C). C=4 gives 0.125; C=3 gives 0.25 — both above a 0.05 alpha, so
+*    those designs are refused at ANY effect size, before simulation.
+*  - Seeded simulation: per-row paired contrasts drawn under a registered
+*    effect model, a whole-cluster percentile bootstrap on each trial, power =
+*    the fraction of trials whose interval excludes zero.
+*
+* The refusal is a verdict INSIDE the returned artifact (the powerPreflight
+* shape, made cluster-aware); `assertDesignAdequate` turns it into a throw for
+* callers that want configuration-time failure.
+*/
+/** A design refused at configuration time, before any spend. */
+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.
+*/
+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 (!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}`);
+	const alpha = options.alpha ?? .05;
+	const targetPower = options.targetPower ?? .8;
+	const baseWinRate = options.baseWinRate ?? .1;
+	const baseLossRate = options.baseLossRate ?? .1;
+	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}]`);
+		noisy.set(cluster.index, cluster.flipRate);
+	}
+	const clusterCount = clusterSizes.length;
+	const totalRows = clusterSizes.reduce((a, b) => a + b, 0);
+	const signFlipFloor = computeSignFlipFloor(clusterCount, alpha);
+	const curve = [];
+	for (const effect of options.effects) curve.push(simulateEffect(effect, {
+		clusterSizes,
+		seed: options.seed,
+		trials,
+		resamples,
+		confidence,
+		baseWinRate,
+		baseLossRate,
+		noisy
+	}));
+	const maxPower = Math.max(...curve.map((point) => point.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`);
+	}
+	const adequate = reasons.length === 0;
+	return {
+		clusterCount,
+		totalRows,
+		trials,
+		resamples,
+		seed: options.seed,
+		confidence,
+		targetPower,
+		curve,
+		maxPower,
+		signFlipFloor,
+		adequate,
+		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.`
+		}
+	};
+}
+/** Throw the refusal for callers that want configuration-time failure. */
+function assertDesignAdequate(result) {
+	if (result.refusal) throw new DesignRefusalError(`design refused (underpowered): ${result.refusal.reasons.join("; ")}`);
+}
+function computeSignFlipFloor(clusterCount, alpha) {
+	const twoSidedP = 2 ** (1 - clusterCount);
+	const oneSidedP = 2 ** -clusterCount;
+	let minClusters = 1;
+	while (2 ** (1 - minClusters) > alpha) minClusters += 1;
+	return {
+		twoSidedP,
+		oneSidedP,
+		alpha,
+		certifiableAtAlpha: twoSidedP <= alpha,
+		minClustersForAlpha: minClusters
+	};
+}
+/**
+* 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
+* 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.
+*/
+function simulateEffect(effect, config) {
+	const rng = mulberry32(mixSeed(config.seed, effect));
+	const clusterCount = config.clusterSizes.length;
+	let excludes = 0;
+	const widths = new Array(config.trials);
+	const sums = new Array(clusterCount);
+	const means = new Array(config.resamples);
+	for (let trial = 0; trial < config.trials; trial++) {
+		for (let cluster = 0; cluster < clusterCount; cluster++) {
+			const size = config.clusterSizes[cluster];
+			const flipRate = config.noisy.get(cluster);
+			let sum = 0;
+			for (let row = 0; row < size; row++) if (flipRate !== void 0) {
+				const win = rng() < flipRate ? 1 : 0;
+				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 u = rng();
+				sum += u < winRate ? 1 : u < winRate + lossRate ? -1 : 0;
+			}
+			sums[cluster] = sum;
+		}
+		for (let draw = 0; draw < config.resamples; draw++) {
+			let pooledSum = 0;
+			let pooledRows = 0;
+			for (let pick = 0; pick < clusterCount; pick++) {
+				const index = Math.floor(rng() * clusterCount);
+				pooledSum += sums[index];
+				pooledRows += config.clusterSizes[index];
+			}
+			means[draw] = pooledSum / pooledRows;
+		}
+		means.sort((a, b) => a - b);
+		const tail = 1 - config.confidence;
+		const lower = means[Math.floor(tail / 2 * config.resamples)];
+		const upper = means[Math.max(Math.floor(tail / 2 * config.resamples), Math.min(config.resamples - 1, Math.ceil((1 - tail / 2) * config.resamples) - 1))];
+		widths[trial] = upper - lower;
+		if (lower > 0 || upper < 0) excludes += 1;
+	}
+	widths.sort((a, b) => a - b);
+	return {
+		effect,
+		power: excludes / config.trials,
+		medianCiWidth: widths[Math.floor(config.trials / 2)]
+	};
+}
+/** Fold the effect into the seed so every grid point draws an independent stream. */
+function mixSeed(seed, effect) {
+	return (seed ^ Math.round(effect * 1000003) * 2654435769) >>> 0 | 0;
+}
+//#endregion
+export { BOOTSTRAP_GATE_MIN_N, DecisionTableNotTotalError, DesignRefusalError, ExperimentTracker, FunnelIntegrityError, MatchedBudgetError, SealIntegrityError, amendExperiment, assertDesignAdequate, assertFunnelReconciles, assertMatchedBudgets, benjaminiHochberg, bonferroni, buildEvidenceVector, buildFunnel, canonicalize, classifyReissue, clusteredPairedBinary, clusteredPower, comparePairedArms, composeFunnels, computeEstimand, computeInterval, defineExperiment, eProcess, evaluateCondition, evaluateHaltRule, evaluateHypothesis, evaluateIdentityGate, evaluateOracleDeterminismGate, evaluatePopulationReproducibilityGate, evaluatePowerFloorGate, evaluatePredicate, evaluateProvenanceGate, executeAdmissionRule, executeDecisionRule, fileExperimentStore, hashJson, heldoutSignificance, holm, inMemoryExperimentStore, mcnemar, mcnemarPower, mcnemarRequiredN, mulberry32, openSealedExperiment, pairArms, pairHoldout, pairRunRecords, pairedBootstrap, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, paretoPolicy, paretoSignificanceGate, powerPreflight, projectNLadderBudget, readField, renderFunnelTable, requiredPairedSampleSize, requiredSampleSize, runSelectionRule, runUniformPassBudget, sealExperiment, sequentialDecide, sequentialPairedGate, signManifest, verifyManifest, verifyMatchedBudgets, verifySealedExperiment, wilson };
+
+//# sourceMappingURL=index.js.map