@tangle-network/agent-eval 0.216.1 → 0.218.1

package/dist/{spans-BHAUXMGN.d.ts → spans-CVngGij3.d.ts}

@@ -1,4 +1,4 @@
-import { s as RedactionReport } from "./redact-mtCCcT8z.js";
+import { o as RedactionReport } from "./redact-DXdlFb_U.js";
 import { SpanKind } from "@tangle-network/agent-trace-contract";
 //#region src/diagnosis/spans.d.ts
 type DiagnosisSpanStatus = 'OK' | 'ERROR' | 'UNSET';
@@ -57,4 +57,4 @@ declare function ingestSpans(raw: readonly unknown[], options: {
 declare function epochMillis(value: unknown): number | null;
 //#endregion
 export { isContentAttribute as a, ingestSpans as i, IngestReport as n, epochMillis as r, DiagnosisSpan as t };
-//# sourceMappingURL=spans-BHAUXMGN.d.ts.map
+//# sourceMappingURL=spans-CVngGij3.d.ts.map

package/dist/{spans-BHAUXMGN.d.ts.map → spans-CVngGij3.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"spans-BHAUXMGN.d.ts","names":[],"sources":["../src/diagnosis/spans.ts"],"mappings":";;;KAuBY;UAEK;EACf;EACA;EACA;EACA;EACA,MAAM;EACN;EACA;EACA,QAAQ;EACR;EACA;EACA;;;;;;;EAOA;EACA,YAAY;;UAGG;EACf;EACA;;EAEA;;EAEA;;EAEA;EACA,SAAS;;EAET;;iBA0Bc,mBAAmB;;;;;;;iBAUnB,YACd,yBACA;EAAW;;EACR,OAAO;EAAiB,QAAQ;;;;;;;iBAgHrB,YAAY"}
+{"version":3,"file":"spans-CVngGij3.d.ts","names":[],"sources":["../src/diagnosis/spans.ts"],"mappings":";;;KAuBY;UAEK;EACf;EACA;EACA;EACA;EACA,MAAM;EACN;EACA;EACA,QAAQ;EACR;EACA;EACA;;;;;;;EAOA;EACA,YAAY;;UAGG;EACf;EACA;;EAEA;;EAEA;;EAEA;EACA,SAAS;;EAET;;iBA0Bc,mBAAmB;;;;;;;iBAUnB,YACd,yBACA;EAAW;;EACR,OAAO;EAAiB,QAAQ;;;;;;;iBAgHrB,YAAY"}

package/dist/{statistical-heldout-CYpGaoDH.d.ts → statistical-heldout-BHfLZHrm.d.ts}

@@ -1,7 +1,7 @@
-import { a as RunRecord } from "./run-record-C1E24G2A.js";
-import { a as PairedPromotionDecision, d as PairedBootstrapResult, i as PairedMcNemarEvidence, r as PairedDecisionStatistic, t as PairedDecisionMethod, u as PairedBootstrapOptions } from "./paired-promotion-decision-DPKz8ZnF.js";
+import { a as RunRecord } from "./run-record-CaxbLq6Y.js";
+import { a as PairedPromotionDecision, i as PairedMcNemarEvidence, l as PairedBootstrapOptions, r as PairedDecisionStatistic, t as PairedDecisionMethod, u as PairedBootstrapResult } from "./paired-promotion-decision-CQMJ5xGN.js";
 import { r as LedgerHash } from "./canonical-CFpojCN5.js";
-import { R as Scenario, a as CampaignResult, b as GenerationRecord, h as GateContext, j as MutableSurface, p as Gate, v as GateResult, w as JudgeScore } from "./types-Cq8mSbq8.js";
+import { R as Scenario, a as CampaignResult, b as GenerationRecord, h as GateContext, j as MutableSurface, p as Gate, v as GateResult, w as JudgeScore } from "./types-DtkO1G9L.js";
 import { z } from "zod";
 //#region src/statistics/paired-binary.d.ts
 /** A binomial proportion estimate with a confidence interval. */
@@ -24,32 +24,6 @@ interface ProportionInterval {
  * 0 for compatibility, not as a measured failure rate; retain n alongside it.
  */
 declare function wilson(successes: number, n: number, confidence?: number): ProportionInterval;
-/**
- * Are these per-item outcomes binary (every value exactly 0 or 1)?
- *
- * The discriminator a promotion gate needs before choosing a paired statistic.
- * On binary outcomes the paired delta vector lives in {-1, 0, +1} and is
- * normally dominated by zeros (both arms solve, or both arms miss, most items),
- * so its MEDIAN is pinned at exactly 0 no matter how large the real shift in
- * success rate is — and a bootstrap CI on that median collapses to [0, 0].
- * A gate keying on `ci.low > threshold` is then structurally unable to see
- * either a gain or a regression. Detect this shape and switch to the
- * paired-binary estimators ({@link mcnemar}, {@link pairedRiskDifference})
- * instead of silently answering "no" forever.
- *
- * Empty input is NOT binary: there is no evidence of the outcome's shape, and
- * defaulting an empty vector into the binary branch would pick a statistic on
- * no data at all.
- *
- * NOT the right discriminator for a gate. It recognises the literal {0, 1}
- * encoding and nothing else, so a pass/fail dimension emitted on 0-100 — which
- * judges in this codebase do routinely — reads as non-binary, and a single
- * partial-credit score in an otherwise pass/fail vector flips it to false while
- * leaving the median just as blind. Gates want {@link pairedBinaryScale} (any
- * two-point encoding). This predicate remains for callers that specifically
- * mean "literally 0/1".
- */
-declare function isBinaryOutcomeVector(values: ArrayLike<number>): boolean;
 /** Result of a McNemar paired-binary significance test. */
 interface McNemarResult {
   /** Total paired observations. */
@@ -211,26 +185,6 @@ interface ScoreRiskDifferenceResult {
  * 0/1 (or boolean) arrays, control first. Throws on unequal lengths.
  */
 declare function pairedRiskDifferenceScore(control: ArrayLike<number | boolean>, treatment: ArrayLike<number | boolean>, confidence?: number): ScoreRiskDifferenceResult;
-/**
- * The common positive level `s` such that EVERY value across both paired arms is
- * exactly 0 or `s` — i.e. the outcome is pass/fail, whatever encoding it arrived
- * in. Returns null when the outcomes are not two-point, when the two arms use
- * different levels, or when no positive value was observed at all (all-zero
- * arms: the level is not identified, and there is nothing to decide anyway).
- *
- * This is the scale-aware successor to {@link isBinaryOutcomeVector}, which only
- * recognises literal {0, 1}. Judges in this codebase emit dimensions on 0-100 as
- * well as [0,1] (see `detectScale` in `campaign/gates/statistical-heldout.ts`),
- * so a pass/fail dimension routinely arrives as {0, 100} and a {0,1}-only test
- * silently sends it down the median path that cannot see it. Any positive level
- * is accepted, not just 1 and 100: for a two-point {0, s} outcome the mean paired
- * delta is exactly s·(b − c)/n, so the binary estimators apply after dividing by
- * s and rescaling the result back into the caller's native units.
- *
- * Non-finite values ⇒ null: an unusable outcome must not be classified as a
- * clean pass/fail shape.
- */
-declare function pairedBinaryScale(before: ArrayLike<number>, after: ArrayLike<number>): number | null;
 /**
  * Unbiased pass@k for code generation (Chen et al. 2021, "Evaluating Large
  * Language Models Trained on Code"). Given `n` independent samples for one
@@ -995,20 +949,11 @@ declare function signManifest(m: HypothesisManifest): Promise<SignedManifest>;
  * the manifest itself declares.
  */
 declare function verifyManifest(m: SignedManifest): Promise<boolean>;
-/**
- * Evaluate a pre-registered hypothesis against observed results.
- * Mechanical — no re-interpretation permitted.
- */
-declare function evaluateHypothesis(manifest: SignedManifest, observed: {
-  n: number;
-  effect: number;
-  pValue: number;
-}): Promise<HypothesisResult>;
 //#endregion
 //#region src/campaign/gates/sequential.d.ts
-type SequentialDecision = 'promote' | 'continue' | 'undecided-at-maxN';
+type SequentialGateDecision = 'promote' | 'continue' | 'undecided-at-maxN';
 interface SequentialObservation {
-  decision: SequentialDecision;
+  decision: SequentialGateDecision;
   /** Current e-value (the betting wealth) against H0. */
   eValue: number;
   /** Paired deltas consumed so far. */
@@ -1059,7 +1004,7 @@ interface SequentialPairedGateOptions {
  *  gate rebuilt with `resume` from this value continues exactly where the
  *  snapshot was taken. */
 type SequentialStreamState = EProcessState & {
-  decision: SequentialDecision;
+  decision: SequentialGateDecision;
 };
 interface SequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario> extends Gate<TArtifact, TScenario> {
   /** Streaming entry point: feed one paired independent-unit delta
@@ -1285,10 +1230,6 @@ interface DimensionRegression {
   /** Configured scenarios with no paired dimension measurement at all. */
   missingScenarioIds: string[];
 }
-/** Detect the native scale of a set of scores: 0-100 when any magnitude clears
- *  1.5, else [0,1]. Used to auto-scale the regression tolerance so a default
- *  expressed for [0,1] is not silently a no-op on a 0-100 dimension. */
-declare function detectScale(values: number[]): 1 | 100;
 /**
  * Report required-dimension evidence after full pairing and optional unit means.
  * A bootstrap floor breach or a shared paired test supporting a drop marks
@@ -1309,5 +1250,5 @@ declare function dimensionRegressions(candidate: Map<string, Record<string, Judg
   minProductiveRuns?: number;
 }): DimensionRegression[];
 //#endregion
-export { paretoSignificanceGate as $, PairArmsOptions as A, EProcess as At, PowerPreflight as B, isBinaryOutcomeVector as Bt, hashJson as C, FinalEvidenceError as Ct, ComparePairedArmsOptions as D, FinalEvidenceRecord as Dt, verifyManifest as E, FinalEvidenceOutcome as Et, PairedCorrectness as F, ExactRiskDifferenceResult as Ft, BuildEvidenceVectorOptions as G, pairedRiskDifferenceScore as Gt, powerPreflight as H, pairedBinaryScale as Ht, PairedMetricDelta as I, McNemarResult as It, ParetoSignificanceGateOptions as J, EvidenceVector as K, passAtK as Kt, comparePairedArms as L, ProportionInterval as Lt, PairRunRecordsResult as M, EProcessState as Mt, PairedArmRow as N, EProcessStep as Nt, MatchedPair as O, FinalEvidenceReservation as Ot, PairedArmsComparison as P, eProcess as Pt, paretoPolicy as Q, pairArms as R, RiskDifferenceResult as Rt, evaluateHypothesis as S, FinalEvidenceConflictError as St, signManifest as T, FinalEvidenceMeasurement as Tt, AxisEvidence as U, pairedRiskDifference as Ut, PowerPreflightOptions as V, mcnemar as Vt, AxisVerdict as W, pairedRiskDifferenceExact as Wt, PromotionPolicy as X, PromotionObjective as Y, buildEvidenceVector as Z, sequentialPairedGate as _, AttestationProvenance as _t, detectScale as a, createCampaignEvidenceReceipt as at, SignedManifest as b, attest as bt, pairHoldout as c, EvidenceAuthority as ct, SequentialDecision as d, EvidenceReceipt as dt, Objective as et, SequentialObservation as f, EvidenceReceiptVerification as ft, sequentialDecide as g, ATTESTATION_ALGORITHM as gt, SequentialStreamState as h, verifyEvidenceReceipt as ht, PairedHoldout as i, CampaignEvidenceContext as it, PairArmsResult as j, EProcessOptions as jt, MatchedRunRecordPair as k, openFinalEvidenceLedger as kt, SequentialDecideFn as l, EvidenceAuthorityKind as lt, SequentialPairedGateOptions as m, isIndependentEvidence as mt, HeldoutSignificance as n, dominates as nt, dimensionRegressions as o, CreateEvidenceReceiptInput as ot, SequentialPairedGate as p, createEvidenceReceipt as pt, ObjectiveSource as q, wilson as qt, HeldoutSignificanceOptions as r, paretoFrontier as rt, heldoutSignificance as s, EVIDENCE_RECEIPT_VERSION as st, DimensionRegression as t, ParetoResult as tt, SequentialDecideOptions as u, EvidenceBinding as ut, HypothesisManifest as v, AttestationVerification as vt, manifestContentDigest as w, FinalEvidenceLedger as wt, SignedManifestAlgo as x, verifyAttestation as xt, HypothesisResult as y, AttestedReport as yt, pairRunRecords as z, ScoreRiskDifferenceResult as zt };
-//# sourceMappingURL=statistical-heldout-CYpGaoDH.d.ts.map
+export { ParetoResult as $, PairRunRecordsResult as A, EProcessStep as At, powerPreflight as B, pairedRiskDifferenceScore as Bt, signManifest as C, FinalEvidenceOutcome as Ct, MatchedRunRecordPair as D, EProcess as Dt, MatchedPair as E, openFinalEvidenceLedger as Et, comparePairedArms as F, RiskDifferenceResult as Ft, ObjectiveSource as G, AxisVerdict as H, wilson as Ht, pairArms as I, ScoreRiskDifferenceResult as It, PromotionPolicy as J, ParetoSignificanceGateOptions as K, pairRunRecords as L, mcnemar as Lt, PairedArmsComparison as M, ExactRiskDifferenceResult as Mt, PairedCorrectness as N, McNemarResult as Nt, PairArmsOptions as O, EProcessOptions as Ot, PairedMetricDelta as P, ProportionInterval as Pt, Objective as Q, PowerPreflight as R, pairedRiskDifference as Rt, manifestContentDigest as S, FinalEvidenceMeasurement as St, ComparePairedArmsOptions as T, FinalEvidenceReservation as Tt, BuildEvidenceVectorOptions as U, AxisEvidence as V, passAtK as Vt, EvidenceVector as W, paretoPolicy as X, buildEvidenceVector as Y, paretoSignificanceGate as Z, HypothesisManifest as _, attest as _t, dimensionRegressions as a, EvidenceAuthority as at, SignedManifestAlgo as b, FinalEvidenceError as bt, SequentialDecideFn as c, EvidenceReceipt as ct, SequentialObservation as d, isIndependentEvidence as dt, dominates as et, SequentialPairedGate as f, verifyEvidenceReceipt as ft, sequentialPairedGate as g, AttestedReport as gt, sequentialDecide as h, AttestationVerification as ht, PairedHoldout as i, CreateEvidenceReceiptInput as it, PairedArmRow as j, eProcess as jt, PairArmsResult as k, EProcessState as kt, SequentialDecideOptions as l, EvidenceReceiptVerification as lt, SequentialStreamState as m, AttestationProvenance as mt, HeldoutSignificance as n, CampaignEvidenceContext as nt, heldoutSignificance as o, EvidenceAuthorityKind as ot, SequentialPairedGateOptions as p, ATTESTATION_ALGORITHM as pt, PromotionObjective as q, HeldoutSignificanceOptions as r, createCampaignEvidenceReceipt as rt, pairHoldout as s, EvidenceBinding as st, DimensionRegression as t, paretoFrontier as tt, SequentialGateDecision as u, createEvidenceReceipt as ut, HypothesisResult as v, verifyAttestation as vt, verifyManifest as w, FinalEvidenceRecord as wt, hashJson as x, FinalEvidenceLedger as xt, SignedManifest as y, FinalEvidenceConflictError as yt, PowerPreflightOptions as z, pairedRiskDifferenceExact as zt };
+//# sourceMappingURL=statistical-heldout-BHfLZHrm.d.ts.map

package/dist/statistical-heldout-BHfLZHrm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistical-heldout-BHfLZHrm.d.ts","names":["_$__evidence_receipt0.EvidenceReceipt"],"sources":["../src/statistics/paired-binary.ts","../src/statistics/sequential-eprocess.ts","../src/experiment/final-evidence.ts","../src/attestation.ts","../src/experiment/evidence-receipt.ts","../src/experiment/campaign-evidence.ts","../src/pareto.ts","../src/campaign/gates/promotion-policy.ts","../src/campaign/gates/power-preflight.ts","../src/paired-arms.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":"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"}

package/dist/{statistical-heldout-42NlCNDe.js → statistical-heldout-Bksv92Th.js}

@@ -1,5 +1,5 @@
-import { i as pairedBootstrap } from "./mean-DHoMiudD.js";
-import { t as decidePairedPromotion } from "./paired-promotion-decision-DsAPYGCm.js";
+import { i as pairedBootstrap } from "./mean-BbA_JCzW.js";
+import { t as decidePairedPromotion } from "./paired-promotion-decision-D0SHb-ZL.js";
 //#region src/campaign/gates/statistical-heldout.ts
 /**
 * Held-out inference pairs execution cells and judge identities before taking
@@ -253,4 +253,4 @@ function dimensionRegressions(candidate, baseline, scenarioIds, criticalDimensio
 //#endregion
 export { heldoutSignificance as a, dimensionRegressions as i, aggregatePairedHoldout as n, pairHoldout as o, detectScale as r, TIE_WARN_FRACTION as t };
 
-//# sourceMappingURL=statistical-heldout-42NlCNDe.js.map
+//# sourceMappingURL=statistical-heldout-Bksv92Th.js.map

package/dist/statistical-heldout-Bksv92Th.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistical-heldout-Bksv92Th.js","names":[],"sources":["../src/campaign/gates/statistical-heldout.ts"],"sourcesContent":["/**\n * Held-out inference pairs execution cells and judge identities before taking\n * means within registered independent units. Repetitions can improve a unit's\n * precision without increasing n. Ungrouped inference concerns independently\n * sampled execution cells conditional on a fixed scenario roster.\n *\n * The shared paired decision rule selects the estimator and statistical test.\n * Dimension reports retain missing coverage so required safety checks cannot\n * pass through absent evidence. Thresholds use the judge's native score scale.\n */\n\nimport {\n  decidePairedPromotion,\n  type PairedDecisionMethod,\n  type PairedDecisionStatistic,\n  type PairedMcNemarEvidence,\n  type PairedPromotionDecision,\n} from '../../paired-promotion-decision'\nimport {\n  DECISION_PAIRED_DELTA_STATISTIC,\n  type PairedBootstrapResult,\n  pairedBootstrap,\n} from '../../statistics'\nimport type { JudgeScore } from '../types'\n\n/** Tie fraction at/above which a gate annotates its verdict with the tie share.\n *  Tie-domination of the median bites structurally at >= 0.5 (the median is then\n *  0 by construction); 0.4 is a softer warn threshold that flags a run APPROACHING\n *  that regime, so an operator sees it before the median goes fully blind. */\nexport const TIE_WARN_FRACTION = 0.4\n\nexport interface PairedHoldout {\n  /** Baseline scalar per paired cell (same order as `after`/`cellIds`). */\n  before: number[]\n  /** Candidate scalar per paired cell. */\n  after: number[]\n  /** The full cellIds (`scenario:rep`) that paired, in order. */\n  cellIds: string[]\n}\n\n/** Campaign cell IDs append a numeric repetition after the scenario's full ID. */\nfunction scenarioIdFromCellId(cellId: string): string {\n  const separator = cellId.lastIndexOf(':')\n  const repetition = cellId.slice(separator + 1)\n  if (\n    separator < 1 ||\n    cellId.trim() !== cellId ||\n    !/^(0|[1-9]\\d*)$/.test(repetition) ||\n    !Number.isSafeInteger(Number(repetition))\n  ) {\n    throw new Error(`pairHoldout: malformed cellId '${cellId}'; expected scenarioId:rep`)\n  }\n  return cellId.slice(0, separator)\n}\n\n/** Preserve cell pairing before taking equal-weight independent-unit means. */\nexport function aggregatePairedHoldout(\n  paired: PairedHoldout,\n  independentUnitByScenarioId?: ReadonlyMap<string, string>,\n): { before: number[]; after: number[]; unitIds: string[] } {\n  if (\n    paired.before.length !== paired.after.length ||\n    paired.before.length !== paired.cellIds.length\n  ) {\n    throw new Error('aggregatePairedHoldout: scores and cellIds must have the same length')\n  }\n  if (new Set(paired.cellIds).size !== paired.cellIds.length) {\n    throw new Error('aggregatePairedHoldout: duplicate cellIds cannot count as new observations')\n  }\n  if (\n    paired.before.some((value) => !Number.isFinite(value)) ||\n    paired.after.some((value) => !Number.isFinite(value))\n  ) {\n    throw new Error('aggregatePairedHoldout: paired scores must be finite')\n  }\n  if (independentUnitByScenarioId === undefined) {\n    return { before: [...paired.before], after: [...paired.after], unitIds: [...paired.cellIds] }\n  }\n  const scenarioIds = paired.cellIds.map(scenarioIdFromCellId)\n  const groups = new Map<string, { before: number; after: number; n: number }>()\n  for (let i = 0; i < paired.cellIds.length; i++) {\n    const scenarioId = scenarioIds[i]!\n    const unitId = independentUnitByScenarioId.get(scenarioId)\n    if (typeof unitId !== 'string' || unitId.length === 0 || unitId.trim() !== unitId) {\n      throw new Error(\n        `aggregatePairedHoldout: missing independent unit for scenario '${scenarioId}'`,\n      )\n    }\n    const group = groups.get(unitId) ?? { before: 0, after: 0, n: 0 }\n    group.before += paired.before[i]!\n    group.after += paired.after[i]!\n    group.n += 1\n    groups.set(unitId, group)\n  }\n  const unitIds = [...groups.keys()].sort()\n  return {\n    before: unitIds.map((id) => groups.get(id)!.before / groups.get(id)!.n),\n    after: unitIds.map((id) => groups.get(id)!.after / groups.get(id)!.n),\n    unitIds,\n  }\n}\n\n/**\n * Pair candidate vs baseline holdout observations by FULL cellId. `select`\n * pulls the scalar from a cell's judge reports (composite, or a named\n * dimension); a cell contributes the mean of `select` across its judges. Cells\n * whose scenario is not in `scenarioIds`, or where `select` is undefined for\n * every judge on both sides, are skipped. The selected judge IDs must agree\n * within each pair. Throws when the two maps disagree on holdout cell IDs — a\n * load-bearing invariant: the baseline + winner holdout campaigns run the same\n * scenarios with the same seed base, so their cellIds MUST align; a mismatch\n * means a silent pairing bug, not a soft fallback.\n */\nexport function pairHoldout(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  select: (s: JudgeScore) => number | undefined,\n): PairedHoldout {\n  const cellValues = (\n    byCell: Map<string, Record<string, JudgeScore>>,\n    cellId: string,\n  ): Map<string, number> => {\n    const scores = byCell.get(cellId)\n    const values = new Map<string, number>()\n    if (!scores) return values\n    for (const [judgeId, s] of Object.entries(scores)) {\n      if (s.failed === true) {\n        throw new Error(`pairHoldout: cell '${cellId}' contains a failed judge score`)\n      }\n      const v = select(s)\n      if (typeof v === 'number' && !Number.isFinite(v)) {\n        throw new Error(`pairHoldout: cell '${cellId}' contains a non-finite selected score`)\n      }\n      if (typeof v === 'number') values.set(judgeId, v)\n    }\n    return values\n  }\n\n  const inScope = (cellId: string) => scenarioIds.has(scenarioIdFromCellId(cellId))\n  const candCells = [...candidate.keys()].filter(inScope).sort()\n  const baseCells = [...baseline.keys()].filter(inScope).sort()\n  // Alignment invariant — the holdout campaigns share scenarios + seed, so the\n  // cell sets must be identical. Differ ⇒ a real pairing bug; fail loud.\n  if (candCells.length !== baseCells.length || candCells.some((c, i) => c !== baseCells[i])) {\n    throw new Error(\n      `pairHoldout: candidate/baseline holdout cells do not align — ` +\n        `candidate=[${candCells.join(',')}] baseline=[${baseCells.join(',')}]. ` +\n        `Both holdout campaigns must run the same scenarios with the same seed base.`,\n    )\n  }\n\n  const before: number[] = []\n  const after: number[] = []\n  const cellIds: string[] = []\n  for (const cellId of candCells) {\n    const b = cellValues(baseline, cellId)\n    const a = cellValues(candidate, cellId)\n    // A scalar absent on both sides means that dimension was not scored. A\n    // one-sided absence is asymmetric evidence loss, never a row to discard.\n    if (b.size === 0 && a.size === 0) continue\n    if (b.size === 0 || a.size === 0) {\n      throw new Error(`pairHoldout: cell '${cellId}' has a selected score on only one arm`)\n    }\n    if (b.size !== a.size || [...b.keys()].some((id) => !a.has(id))) {\n      throw new Error(`pairHoldout: cell '${cellId}' selected judge IDs do not align`)\n    }\n    const judgeIds = [...b.keys()].sort()\n    before.push(meanSelectedScores(judgeIds.map((id) => b.get(id)!)))\n    after.push(meanSelectedScores(judgeIds.map((id) => a.get(id)!)))\n    cellIds.push(cellId)\n  }\n  return { before, after, cellIds }\n}\n\nfunction meanSelectedScores(values: number[]): number {\n  const first = values[0]!\n  // Summing identical fractional scores can round their mean outside the\n  // declared binary support. An agreeing judge set preserves its exact value.\n  return values.every((value) => value === first)\n    ? first\n    : values.reduce((sum, value) => sum + value, 0) / values.length\n}\n\nexport interface HeldoutSignificance {\n  paired: PairedHoldout\n  /**\n   * The paired bootstrap on the requested statistic (MEAN by default — see the\n   * tie note on `heldoutSignificance`).\n   *\n   * DIAGNOSTIC, not necessarily the interval the verdict keyed on. On a\n   * two-point (pass/fail) outcome the decision routes to Tango's score interval\n   * instead, because a percentile bootstrap of the mean over a three-atom\n   * lattice is not a valid interval at a nonzero margin. Read\n   * `decision.low`/`decision.high` for the interval that actually decided, and\n   * `decisionStatistic` for which one it is.\n   */\n  bootstrap: PairedBootstrapResult\n  /** The MEDIAN paired-delta bootstrap, reported as a diagnostic. When many\n   *  scenarios are tied (both sides solve them), the median is pinned near 0\n   *  regardless of the mean lift — comparing the two exposes tie-domination. */\n  medianBootstrap: PairedBootstrapResult\n  /**\n   * The full promotion decision: which estimator the outcome's shape admits,\n   * the interval it produced, McNemar's exact veto on the two-point path, and\n   * whether the interval was zero-width (no evidence in either direction). The\n   * single source of `significant`.\n   */\n  decision: PairedPromotionDecision\n  /** Which paired estimator the verdict was decided on. */\n  decisionStatistic: PairedDecisionStatistic\n  /** McNemar's exact evidence on the two-point path; null otherwise. */\n  mcnemar: PairedMcNemarEvidence | null\n  /** Fraction of paired observations that are exact ties (|delta| < 1e-9). A\n   *  high tie fraction is WHY a median-based gate would have missed a real lift;\n   *  it is the observability the tie fix adds. */\n  tieFraction: number\n  /** Number of paired observation units, after configured aggregation. */\n  n: number\n  /** Original matched execution cells, before aggregation. */\n  pairedCellN: number\n  observationUnit: 'registered' | 'cell'\n  /** Registered unit IDs, or cell IDs on the ungrouped path. */\n  unitIds: string[]\n  /** Effective minimum for the requested target and chosen estimator. */\n  minimumRequired: number\n  /** Statistical method that carried the decision. */\n  decisionMethod: PairedDecisionMethod\n  /** Exact one-sided p-value on the small-sample path; otherwise null. */\n  pValue: number | null\n  /** True iff n >= minimumRequired, the DECIDING interval has nonzero width,\n   *  its lower bound clears the threshold, and McNemar's exact test does not\n   *  veto at a non-negative threshold. */\n  significant: boolean\n  /** Set when n < minimumRequired — too little evidence to claim significance. */\n  fewRuns: boolean\n}\n\nexport interface HeldoutSignificanceOptions {\n  deltaThreshold?: number\n  minProductiveRuns?: number\n  confidence?: number\n  resamples?: number\n  /** Fixed by default for a deterministic, reproducible gate verdict. */\n  seed?: number\n  statistic?: 'mean' | 'median'\n  /** Group full cell pairs into equal-weight independent units before inference. */\n  independentUnitByScenarioId?: ReadonlyMap<string, string>\n}\n\n/**\n * Significance of the held-out composite lift: ship only when the lower bound\n * of the interval the outcome's shape ADMITS exceeds `deltaThreshold` (default\n * 0 ⇒ \"confidently positive\"). Interpret `deltaThreshold` in the judge's native\n * scale.\n *\n * The decision is delegated whole to {@link decidePairedPromotion}, the one\n * copy of the rule (`src/paired-promotion-decision.ts`), which `HeldOutGate`\n * also calls. That module's header carries the measurements; the short version\n * is three guards a bare `bootstrap.low > threshold` does not have:\n *\n *   - a two-point (pass/fail) outcome decides on Tango's SCORE interval, the\n *     only paired-binary construction that stays valid at a nonzero margin;\n *   - McNemar's exact test VETOES at any non-negative threshold;\n *   - a ZERO-WIDTH interval is refused rather than promoted, in either\n *     direction — [0,0] clears every negative threshold and [g,g] clears every\n *     threshold below g, and both are an absence of evidence, not a result.\n *\n * Measured on this function before those guards landed, at a nominal 5 %:\n * 14.60 % false promotion at n = 40 on a paired-binary noninferiority boundary,\n * and 88.50 % at n = 6 under a bounded asymmetric null whose true mean paired\n * delta is exactly 0.\n *\n * Continuous mean targets require bootstrap eligibility. Explicit median\n * targets can use the exact sign test at its confidence-dependent minimum.\n */\nexport function heldoutSignificance(\n  paired: PairedHoldout,\n  opts: HeldoutSignificanceOptions = {},\n): HeldoutSignificance {\n  const deltaThreshold = opts.deltaThreshold ?? 0\n  const confidence = opts.confidence ?? 0.95\n  const resamples = opts.resamples ?? 2000\n  const seed = opts.seed ?? 1337\n  // DEFAULT to the MEAN paired delta, not the median. The median is destroyed by\n  // TIES: whenever both baseline and candidate solve a holdout scenario (a common\n  // case once the agent is decent — and INCREASINGLY common as you add holdout\n  // scenarios for statistical power), that scenario contributes delta 0. When\n  // >=50% of paired cells are ties the median is pinned at 0 regardless of a large,\n  // consistent lift on the rest, and the gate holds a genuinely better candidate.\n  // (Measured live, supervisor-lab run 6: 40 cells, 20 ties, MEAN +0.177, MEDIAN 0\n  // → false hold. Doubling the holdout for \"power\" made it WORSE by adding ties.)\n  // The mean equals the reported aggregate lift, ties correctly contribute 0\n  // without dominating, and it is the textbook paired-comparison estimator; the\n  // median is kept as a reported diagnostic. Callers wanting outlier-robustness at\n  // the cost of tie-blindness can still pass `statistic: 'median'`.\n  const statistic = opts.statistic ?? 'mean'\n  const observations = aggregatePairedHoldout(paired, opts.independentUnitByScenarioId)\n  const decision = decidePairedPromotion(observations.before, observations.after, {\n    confidence,\n    resamples,\n    statistic,\n    seed,\n    threshold: deltaThreshold,\n    minPairs: opts.minProductiveRuns,\n  })\n  // `decision.bootstrap` is null exactly when the score interval decided, so\n  // the requested-statistic bootstrap is computed here for the diagnostic\n  // field. Same two bootstraps as before on every path.\n  const bootstrap =\n    decision.bootstrap ??\n    pairedBootstrap(observations.before, observations.after, {\n      confidence,\n      resamples,\n      statistic,\n      seed,\n    })\n  const medianBootstrap =\n    statistic === 'median'\n      ? bootstrap\n      : pairedBootstrap(observations.before, observations.after, {\n          confidence,\n          resamples,\n          statistic: 'median',\n          seed,\n        })\n  const n = observations.before.length\n  let ties = 0\n  for (let i = 0; i < n; i += 1) {\n    const after = observations.after[i]!\n    const before = observations.before[i]!\n    if (Math.abs(after - before) < 1e-9) ties += 1\n  }\n  const tieFraction = n === 0 ? 0 : ties / n\n  return {\n    paired,\n    bootstrap,\n    medianBootstrap,\n    decision,\n    decisionStatistic: decision.statistic,\n    mcnemar: decision.mcnemar,\n    tieFraction,\n    n,\n    pairedCellN: paired.cellIds.length,\n    observationUnit: opts.independentUnitByScenarioId === undefined ? 'cell' : 'registered',\n    unitIds: observations.unitIds,\n    minimumRequired: decision.minimumPairs,\n    decisionMethod: decision.method,\n    pValue: decision.pValue,\n    significant: decision.promote,\n    fewRuns: !decision.sufficient,\n  }\n}\n\nexport interface DimensionRegression {\n  dimension: string\n  /** Paired bootstrap on (candidate − baseline). DIAGNOSTIC on a pass/fail\n   *  dimension, where `ci` carries the interval that decided instead. */\n  bootstrap: PairedBootstrapResult\n  /** Which paired statistic `bootstrap.low` is the lower bound of. `'mean'`\n   *  unless the caller asked for the median. `bootstrap.median` still carries\n   *  the median point estimate either way. */\n  bootstrapStatistic: 'median' | 'mean'\n  /** The interval `regressed` was decided on, in the dimension's native units. */\n  ci: { low: number; high: number }\n  /** Which estimator produced `ci`. */\n  decisionStatistic: PairedDecisionStatistic\n  /** McNemar's exact evidence on a pass/fail dimension; null otherwise. */\n  mcnemar: PairedMcNemarEvidence | null\n  /** `ci` has zero width — no evidence in either direction. */\n  indeterminate: boolean\n  /** The bootstrap lower bound is below negative tolerance, or the shared\n   *  paired test supports a drop exceeding tolerance. Missing coverage and\n   *  insufficient observations are reported separately. */\n  regressed: boolean\n  tolerance: number\n  n: number\n  pairedCellN: number\n  observationUnit: 'registered' | 'cell'\n  /** Statistical minimum for the configured independent observation unit. */\n  minimumRequired: number\n  fewRuns: boolean\n  /** Both arms lack this dimension on these otherwise matched execution cells. */\n  missingCellIds: string[]\n  /** Configured scenarios with no paired dimension measurement at all. */\n  missingScenarioIds: string[]\n}\n\n/** Detect the native scale of a set of scores: 0-100 when any magnitude clears\n *  1.5, else [0,1]. Used to auto-scale the regression tolerance so a default\n *  expressed for [0,1] is not silently a no-op on a 0-100 dimension. */\nexport function detectScale(values: number[]): 1 | 100 {\n  return values.some((v) => Math.abs(v) > 1.5) ? 100 : 1\n}\n\n/**\n * Report required-dimension evidence after full pairing and optional unit means.\n * A bootstrap floor breach or a shared paired test supporting a drop marks\n * regression. These two criteria are distinct; `ci` records the shared\n * estimator and `bootstrap` records the floor interval. Missing observations\n * and insufficient n remain explicit for the caller's evidence policy.\n * The default tolerance is 0.05 on [0,1] and 5 on a detected 0-100 scale.\n */\nexport function dimensionRegressions(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  criticalDimensions: string[],\n  opts: {\n    tolerance?: number\n    confidence?: number\n    resamples?: number\n    seed?: number\n    /** Paired statistic the CI is computed on. Default `'mean'` — see\n     *  {@link DECISION_PAIRED_DELTA_STATISTIC} for why the median is not. */\n    statistic?: 'mean' | 'median'\n    independentUnitByScenarioId?: ReadonlyMap<string, string>\n    minProductiveRuns?: number\n  } = {},\n): DimensionRegression[] {\n  const out: DimensionRegression[] = []\n  const expectedCellIds = [...baseline.keys()]\n    .filter((cellId) => scenarioIds.has(scenarioIdFromCellId(cellId)))\n    .sort()\n  for (const dim of criticalDimensions) {\n    const paired = pairHoldout(candidate, baseline, scenarioIds, (s) => s.dimensions[dim])\n    if (paired.before.length === 0) continue // dimension not scored on this judge\n    const observations = aggregatePairedHoldout(paired, opts.independentUnitByScenarioId)\n    const measuredCells = new Set(paired.cellIds)\n    const measuredScenarios = new Set(paired.cellIds.map(scenarioIdFromCellId))\n    const tolerance = opts.tolerance ?? 0.05 * detectScale([...paired.before, ...paired.after])\n    const bootstrapStatistic = opts.statistic ?? DECISION_PAIRED_DELTA_STATISTIC\n    const shared = {\n      confidence: opts.confidence ?? 0.95,\n      resamples: opts.resamples ?? 2000,\n      statistic: bootstrapStatistic,\n      seed: opts.seed ?? 1337,\n      minPairs: opts.minProductiveRuns,\n    }\n    const guard = decidePairedPromotion(observations.before, observations.after, shared)\n    const regression = decidePairedPromotion(observations.after, observations.before, {\n      ...shared,\n      threshold: tolerance,\n    })\n    const bootstrap =\n      guard.bootstrap ?? pairedBootstrap(observations.before, observations.after, shared)\n    out.push({\n      dimension: dim,\n      bootstrap,\n      bootstrapStatistic,\n      ci: { low: guard.low, high: guard.high },\n      decisionStatistic: guard.statistic,\n      mcnemar: guard.mcnemar,\n      indeterminate: guard.indeterminate,\n      // Fires on EITHER burden of proof — see `floorBreached` in\n      // `promotion-policy.ts` for the same rule and the reasoning. The CI arm\n      // is the contract this interface and `default-production-gate`'s reason\n      // string both state (\"CI.low < -tolerance\"), read off the DECIDING\n      // interval; the exact-test arm adds the small-sample path where the\n      // bootstrap interval is descriptive only.\n      // The credible-worst-case arm stays on the BOOTSTRAP — see the same\n      // decision in `floorBreached` (`promotion-policy.ts`). On a pass/fail\n      // dimension the score interval is ±z²/(n+z²) even when every pair is\n      // concordant, so reading the floor off it would flag an unchanged safety\n      // dimension as regressed at any realistic n. The PROVEN-drop arm does use\n      // the shared rule, which is what closes the fail-open hole that mattered:\n      // a genuine pass/fail regression is now judged on an interval valid at\n      // the nonzero `tolerance`, instead of a bootstrap that is pinned wherever\n      // ties dominate.\n      regressed: bootstrap.low < -tolerance || regression.promote,\n      tolerance,\n      n: observations.before.length,\n      pairedCellN: paired.cellIds.length,\n      observationUnit: opts.independentUnitByScenarioId === undefined ? 'cell' : 'registered',\n      minimumRequired: guard.minimumPairs,\n      fewRuns: !guard.sufficient,\n      missingCellIds: expectedCellIds.filter((cellId) => !measuredCells.has(cellId)),\n      missingScenarioIds: [...scenarioIds].filter((id) => !measuredScenarios.has(id)).sort(),\n    })\n  }\n  return out\n}\n"],"mappings":"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"}

package/dist/{steps-Bg5-KVx1.d.ts → steps-DlepJPwD.d.ts}

@@ -40,40 +40,6 @@ interface RecordedTrajectoryStep {
   /** Null when the step recorded no observation (terminal submit steps). */
   readonly observation: string | null;
 }
-/** Recorded returncode of a step, or null when the observation carries none. */
-declare function parseRecordedReturncode(observation: string | null): number | null;
-/** Text between the observation's <output> tags, or the raw observation when
- *  the tags are absent. */
-declare function parseObservationOutput(observation: string | null): string;
-/**
- * Stable failure-signature candidate: the first error line, or a shell
- * command-not-found suffix. Null when neither exists — a verdict then falls
- * back to returncode-only matching and says so.
- * Pass an explicit signature to override (compiler quote glyphs vary with
- * locale, so a hand-picked ASCII substring is often more robust).
- */
-declare function deriveFailureSignature(observation: string | null): string | null;
-/** mini-SWE's end-of-run submit convention: the agent echoes this sentinel
- *  and dumps the diff. A label on this step marks a bad SUBMIT DECISION, not a
- *  failed command — there is no executable failure to reproduce, so it is
- *  never a counterfactual replay target. */
-declare const SUBMIT_ACTION_SIGNATURE = "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT";
-declare function isSubmitAction(action: string): boolean;
-/**
- * True when the action is the sentinel echo and nothing else.
- *
- * The distinction decides whether a step may be dropped. An agent is told to
- * issue the sentinel alone, and 5.7% of recorded runs end on a command that
- * writes files or edits them and then echoes it. Dropping such a step because
- * it holds the sentinel would remove the run's last state change from the
- * replay, so the recorded end state and the replayed one would differ.
- */
-declare function isSubmitOnlyAction(action: string): boolean;
-declare function isElidedField(value: string | null | undefined): boolean;
-/** Substring the timeout notice always carries, whatever the command was. */
-declare const TIMEOUT_OBSERVATION_MARKER = "timed out and has been killed";
-/** Opening of the notice the scaffold writes when a turn held no single action. */
-declare const FORMAT_ERROR_OBSERVATION_PREFIX = "Please always provide EXACTLY ONE action in triple backticks, found ";
 /**
  * What a recorded observation is.
  *
@@ -86,10 +52,6 @@ declare const FORMAT_ERROR_OBSERVATION_PREFIX = "Please always provide EXACTLY O
  */
 type RecordedObservationKind = 'command-result' | 'timeout' | 'format-error' | 'elided' | 'absent' | 'unreadable';
 declare function classifyObservation(observation: string | null): RecordedObservationKind;
-/** True when the recording shows the environment killed this step at its
- *  wall-clock bound. Such a step carries no returncode, so no replay can
- *  confirm or contradict it. */
-declare function isRecordedTimeout(observation: string | null): boolean;
 /**
  * One turn as the published trajectory dump holds it.
  *
@@ -180,22 +142,6 @@ type RecordedFinalOutcome = {
  * that executed nothing, so the last step is the last command the run ran.
  */
 declare function finalRecordedOutcome(steps: readonly RecordedTrajectoryStep[]): RecordedFinalOutcome | null;
-/**
- * Steps whose recorded exit a replay cannot check.
- *
- * A killed step counts: the recording holds no exit status to compare a replay
- * against, so agreement on it cannot be measured either way.
- */
-declare function unreadableExitCount(steps: readonly RecordedTrajectoryStep[]): number;
-/**
- * Throw unless every recorded command survived the dump.
- *
- * A replay executes `steps` verbatim, so one elision marker in an action means
- * the replay runs the literal two-to-four characters of the marker instead of
- * the command the run executed. The guard is here so a replayer needs one call
- * rather than a field check it can forget.
- */
-declare function assertReplayableTrajectory(decoded: DecodedTrajectory): void;
 //#endregion
-export { isSubmitOnlyAction as _, RecordedTrajectoryStep as a, unreadableExitCount as b, TIMEOUT_OBSERVATION_MARKER as c, decodeRecordedTurns as d, deriveFailureSignature as f, isSubmitAction as g, isRecordedTimeout as h, RecordedObservationKind as i, assertReplayableTrajectory as l, isElidedField as m, FORMAT_ERROR_OBSERVATION_PREFIX as n, RecordedTrajectoryTurn as o, finalRecordedOutcome as p, RecordedFinalOutcome as r, SUBMIT_ACTION_SIGNATURE as s, DecodedTrajectory as t, classifyObservation as u, parseObservationOutput as v, parseRecordedReturncode as y };
-//# sourceMappingURL=steps-Bg5-KVx1.d.ts.map
+export { RecordedTrajectoryTurn as a, finalRecordedOutcome as c, RecordedTrajectoryStep as i, RecordedFinalOutcome as n, classifyObservation as o, RecordedObservationKind as r, decodeRecordedTurns as s, DecodedTrajectory as t };
+//# sourceMappingURL=steps-DlepJPwD.d.ts.map

package/dist/steps-DlepJPwD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps-DlepJPwD.d.ts","names":[],"sources":["../src/trajectory-replay/steps.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmCiB;;WAEN;WACA;;WAEA;;;;;;;;;;;;KAqGC;iBAQI,oBAAoB,6BAA6B;;;;;;;UAwBhD;WACN;WACA;WACA;aAA4B;;WAC5B;;UAGM;;WAEN,gBAAgB;;WAEhB;;;;;;;;;WASA;;WAEA;;WAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCK,oBAAoB,gBAAgB,2BAA2B;;;;;;;;;KAyCnE;WACG;WAA6B;;WAC7B;;WACA;WAA6B,QAAQ;;;;;;;;iBAQpC,qBACd,gBAAgB,2BACf"}

package/dist/{store-C4avFjIi.d.ts → store-B3nWRy3B.d.ts}

@@ -1,4 +1,4 @@
-import { b as SpanKind, f as Run, g as RunStatus, i as EventKind, m as RunLayer, n as BudgetLedgerEntry, t as Artifact, v as Span, w as TraceEvent } from "./schema-2g7trUwH.js";
+import { S as TraceEvent, _ as Span, f as Run, h as RunStatus, i as EventKind, m as RunLayer, n as BudgetLedgerEntry, t as Artifact, y as SpanKind } from "./schema-D6EVKzTB.js";
 //#region src/trace/store.d.ts
 interface RunFilter {
   scenarioId?: string;
@@ -114,4 +114,4 @@ declare class FileSystemTraceStore implements TraceStore {
 }
 //#endregion
 export { RunFilter as a, InMemoryTraceStore as i, FileSystemTraceStore as n, SpanFilter as o, FileSystemTraceStoreOptions as r, TraceStore as s, EventFilter as t };
-//# sourceMappingURL=store-C4avFjIi.d.ts.map
+//# sourceMappingURL=store-B3nWRy3B.d.ts.map

package/dist/{store-C4avFjIi.d.ts.map → store-B3nWRy3B.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"store-C4avFjIi.d.ts","names":["_$__schema0.RunLayer"],"sources":["../src/trace/store.ts"],"mappings":";;UAuBiB;EACf;EACA;EACA,SAAS;EACT;EACA;EACA;IAAQ;IAAa;;EACrB;EACA;EACA;EACA,QAPSA;;UAUM;EACf;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,OAAO;EACP;EACA;;UAGe;EACf,UAAU,KAAK,MAAM;EACrB,UAAU,eAAe,OAAO,QAAQ,OAAO;EAC/C,WAAW,MAAM,OAAO;EACxB,WAAW,gBAAgB,OAAO,QAAQ,QAAQ;EAClD,YAAY,OAAO,aAAa;EAChC,eAAe,UAAU,WAAW;EACpC,kBAAkB,OAAO,oBAAoB;EAE7C,OAAO,gBAAgB,QAAQ;EAC/B,SAAS,SAAS,YAAY,QAAQ;EACtC,MAAM,SAAS,aAAa,QAAQ;EACpC,OAAO,SAAS,cAAc,QAAQ;EACtC,OAAO,gBAAgB,QAAQ;EAC/B,UAAU,gBAAgB,QAAQ;;cAKvB,8BAA8B;UACjC;UACA;UACA;UACA;UACA;EAEF,UAAU,KAAK,MAAM;EAKrB,UAAU,eAAe,OAAO,QAAQ,OAAO;EAM/C,WAAW,MAAM,OAAO;EAIxB,WAAW,gBAAgB,OAAO,QAAQ,QAAQ;EAMlD,YAAY,OAAO,aAAa;EAIhC,eAAe,UAAU,WAAW;EAIpC,kBAAkB,OAAO,oBAAoB;EAI7C,OAAO,gBAAgB,QAAQ;EAK/B,SAAS,SAAQ,YAAiB,QAAQ;EAI1C,MAAM,SAAQ,aAAkB,QAAQ;EAIxC,OAAO,SAAQ,cAAmB,QAAQ;EAI1C,OAAO,gBAAgB,QAAQ;EAI/B,UAAU,gBAAgB,QAAQ;;UA0CzB;EACf;;EAEA;;cAGW,gCAAgC;UACnC;UACA;;UAEA;;;UAGA;;;UAGA;;;;;;;;UAQA;EAER,YAAY,SAAS;UAKP;UAKA;UAwBA;UA8BA;UAqBN;UAOM;EAkHR,UAAU,KAAK,MAAM;EAGrB,UAAU,eAAe,OAAO,QAAQ,OAAO;EAM/C,WAAW,MAAM,OAAO;EAGxB,WAAW,gBAAgB,OAAO,QAAQ,QAAQ;EAIlD,YAAY,OAAO,aAAa;EAGhC,eAAe,UAAU,WAAW;EAGpC,kBAAkB,OAAO,oBAAoB;EAI7C,OAAO,gBAAgB,QAAQ;EAG/B,SAAS,SAAS,YAAY,QAAQ;EAGtC,MAAM,SAAS,aAAa,QAAQ;EAGpC,OAAO,SAAS,cAAc,QAAQ;EAGtC,OAAO,gBAAgB,QAAQ;EAG/B,UAAU,gBAAgB,QAAQ"}
+{"version":3,"file":"store-B3nWRy3B.d.ts","names":["_$__schema0.RunLayer"],"sources":["../src/trace/store.ts"],"mappings":";;UAuBiB;EACf;EACA;EACA,SAAS;EACT;EACA;EACA;IAAQ;IAAa;;EACrB;EACA;EACA;EACA,QAPSA;;UAUM;EACf;EACA;EACA,OAAO;EACP;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,OAAO;EACP;EACA;;UAGe;EACf,UAAU,KAAK,MAAM;EACrB,UAAU,eAAe,OAAO,QAAQ,OAAO;EAC/C,WAAW,MAAM,OAAO;EACxB,WAAW,gBAAgB,OAAO,QAAQ,QAAQ;EAClD,YAAY,OAAO,aAAa;EAChC,eAAe,UAAU,WAAW;EACpC,kBAAkB,OAAO,oBAAoB;EAE7C,OAAO,gBAAgB,QAAQ;EAC/B,SAAS,SAAS,YAAY,QAAQ;EACtC,MAAM,SAAS,aAAa,QAAQ;EACpC,OAAO,SAAS,cAAc,QAAQ;EACtC,OAAO,gBAAgB,QAAQ;EAC/B,UAAU,gBAAgB,QAAQ;;cAKvB,8BAA8B;UACjC;UACA;UACA;UACA;UACA;EAEF,UAAU,KAAK,MAAM;EAKrB,UAAU,eAAe,OAAO,QAAQ,OAAO;EAM/C,WAAW,MAAM,OAAO;EAIxB,WAAW,gBAAgB,OAAO,QAAQ,QAAQ;EAMlD,YAAY,OAAO,aAAa;EAIhC,eAAe,UAAU,WAAW;EAIpC,kBAAkB,OAAO,oBAAoB;EAI7C,OAAO,gBAAgB,QAAQ;EAK/B,SAAS,SAAQ,YAAiB,QAAQ;EAI1C,MAAM,SAAQ,aAAkB,QAAQ;EAIxC,OAAO,SAAQ,cAAmB,QAAQ;EAI1C,OAAO,gBAAgB,QAAQ;EAI/B,UAAU,gBAAgB,QAAQ;;UA0CzB;EACf;;EAEA;;cAGW,gCAAgC;UACnC;UACA;;UAEA;;;UAGA;;;UAGA;;;;;;;;UAQA;EAER,YAAY,SAAS;UAKP;UAKA;UAwBA;UA8BA;UAqBN;UAOM;EAkHR,UAAU,KAAK,MAAM;EAGrB,UAAU,eAAe,OAAO,QAAQ,OAAO;EAM/C,WAAW,MAAM,OAAO;EAGxB,WAAW,gBAAgB,OAAO,QAAQ,QAAQ;EAIlD,YAAY,OAAO,aAAa;EAGhC,eAAe,UAAU,WAAW;EAGpC,kBAAkB,OAAO,oBAAoB;EAI7C,OAAO,gBAAgB,QAAQ;EAG/B,SAAS,SAAS,YAAY,QAAQ;EAGtC,MAAM,SAAS,aAAa,QAAQ;EAGpC,OAAO,SAAS,cAAc,QAAQ;EAGtC,OAAO,gBAAgB,QAAQ;EAG/B,UAAU,gBAAgB,QAAQ"}

package/dist/{store-otlp-DJ9dtA5x.js → store-otlp-BteDAbHK.js}

@@ -1,5 +1,5 @@
-import { n as CaptureIntegrityError } from "./errors-DVZiqS7K.js";
-import { A as spanEpochMillis, C as TraceFileTooLargeError, D as extractOtlpAttributes, E as compareSpanTime, S as TraceFileMissingError, _ as SpanNotFoundError, b as TraceAnalysisValidationError, c as bindSpanSourceReader, d as compileSearchRegex, f as truncateForBudget, g as TRACE_ANALYSIS_LIMITS, k as projectOtlpFlatLine, m as DEFAULT_TRACE_ANALYST_BUDGETS, p as validateInteger, u as traceSpanSchema, v as TraceAnalysisLimitError, w as TraceNotFoundError, x as TraceFileMalformedError } from "./kind-factory-BobI5Jy3.js";
+import { n as CaptureIntegrityError } from "./errors-BcOs5MKW.js";
+import { D as projectOtlpFlatLine, O as spanEpochMillis, S as TraceNotFoundError, T as extractOtlpAttributes, b as TraceFileMissingError, d as truncateForBudget, f as validateInteger, g as TraceAnalysisLimitError, h as SpanNotFoundError, l as traceSpanSchema, m as TRACE_ANALYSIS_LIMITS, p as DEFAULT_TRACE_ANALYST_BUDGETS, s as bindSpanSourceReader, u as compileSearchRegex, v as TraceAnalysisValidationError, w as compareSpanTime, x as TraceFileTooLargeError, y as TraceFileMalformedError } from "./kind-factory-Gy4fXixd.js";
 import { readFile, stat } from "node:fs/promises";
 //#region src/trace-analyst/shared-abortable-task.ts
 function createSharedAbortableTask(factory) {
@@ -795,4 +795,4 @@ function otlpTextToTraceAnalysisStore(text, opts = {}) {
 //#endregion
 export { spanRecordsToTraceAnalysisStore as a, otlpTextToTraceAnalysisStore as i, DEFAULT_MAX_TRACE_FILE_BYTES as n, OtlpFileTraceStore as r, BufferTraceStore as t };
 
-//# sourceMappingURL=store-otlp-DJ9dtA5x.js.map
+//# sourceMappingURL=store-otlp-BteDAbHK.js.map