@tangle-network/agent-eval 0.136.0 → 0.138.0

package/dist/{index-B4Fjfo5U.d.ts → index-D0cxAdaV.d.ts}

@@ -1,85 +1,38 @@
-import { c as ValidationError, t as AgentEvalError } from "./errors-CEk209JS.js";
-import { t as DefaultVerdict } from "./verdict-Dps8_okt.js";
-import { c as CostLedgerHandle, m as CostReceipt } from "./cost-ledger-fGS_u_O1.js";
-import { a as RunRecord, s as RunSplitTag } from "./run-record-DcObtIGh.js";
-import { l as RawProviderSink } from "./raw-provider-sink-BU29Sh8h.js";
-import { A as ChatClient } from "./types-Cc3qbqzj.js";
-import "./types-DVjczBM9.js";
-import { A as LabeledScenarioWrite, D as LabeledScenarioSampleArgs, E as LabeledScenarioRecord, O as LabeledScenarioSource, R as Scenario, S as JudgeConfig, T as LabelTrust, a as CampaignResult, b as GenerationRecord, d as DispatchContext, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, p as Gate, u as ComponentSurface, w as JudgeScore } from "./types-DiWLru6Z.js";
-import { rn as PlanCampaignRunOptions, sn as CampaignStorage, tn as CampaignRunPlan } from "./skillopt-optimization-method-CwSYkv35.js";
-import { n as AnalyzeTracesOptions, r as AnalyzeTracesResult, t as AnalyzeTracesInput } from "./analyst-BkTS3C58.js";
-import { E as RiskDifferenceResult, _ as McNemarResult, d as EProcessState, v as PairedBootstrapOptions, y as PairedBootstrapResult } from "./statistics-CKOqre5S.js";
-import { A as PairedMcNemarEvidence, D as PairedDecisionMethod, j as PairedPromotionDecision, k as PairedDecisionStatistic } from "./summary-report-CPMINBqs.js";
-import { D as LedgerHash, m as LedgerTrustedHeadRemoval, p as LedgerTrustedHead } from "./index-DuhJaaiH.js";
+import { l as ValidationError, t as AgentEvalError } from "./errors-DkfjIDvD.js";
+import { T as RunPaidCallInput, m as CostReceipt } from "./cost-ledger-B1D3COAc.js";
+import { a as RunRecord, s as RunSplitTag } from "./run-record-DwHMk1Ai.js";
+import { f as AnalystUsageReceipt, i as AnalystFinding, l as AnalystRunResult, x as TraceAnalysisStore } from "./types-BtJhn8v6.js";
+import { _ as AnalystIssueExpectation, a as AnalystBenchmarkLabelState, t as AnalystBenchmarkCase } from "./benchmark-DlQgU_XI.js";
+import { A as LabeledScenarioWrite, D as LabeledScenarioSampleArgs, E as LabeledScenarioRecord, O as LabeledScenarioSource, R as Scenario, S as JudgeConfig, T as LabelTrust, a as CampaignResult, b as GenerationRecord, d as DispatchContext, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, p as Gate, u as ComponentSurface, w as JudgeScore } from "./types-zFYez3PK.js";
+import { rn as PlanCampaignRunOptions, sn as CampaignStorage, tn as CampaignRunPlan } from "./skillopt-optimization-method-CzfnA8O-.js";
+import { E as RiskDifferenceResult, _ as McNemarResult, d as EProcessState, v as PairedBootstrapOptions, y as PairedBootstrapResult } from "./statistics-mf70aXKp.js";
+import { A as PairedMcNemarEvidence, D as PairedDecisionMethod, j as PairedPromotionDecision, k as PairedDecisionStatistic } from "./summary-report-BKinV4yD.js";
+import { n as CompletionVerdict, o as ProducedState, r as CorrectnessChecker, t as CompletionRequirement } from "./completion-verifier-B4-IMYcS.js";
+import { D as LedgerHash, m as LedgerTrustedHeadRemoval, p as LedgerTrustedHead } from "./index-DEb46kc6.js";
 import { AgentProfile, AgentProfile as AgentProfile$1, HarnessType, HarnessType as HarnessType$1 } from "@tangle-network/agent-interface";
 //#region src/campaign/analyst-surface.d.ts
-/**
- * A labeled trace scenario: a FIXED trace corpus plus the failure modes a
- * competent analyst MUST surface from it. The labels are ground truth — the
- * objective failures that actually occurred — which is what makes optimizing
- * the analyst prompt against them meaningful rather than circular.
- */
-interface AnalystScenario extends Scenario {
-  kind: 'analyst-surface';
-  /** OTLP-JSONL path or an in-memory store of the traces to analyze. */
-  source: AnalyzeTracesOptions['source'];
-  /** The domain question handed to the analyst (framing lives here, not in
-   *  the surface under optimization). */
-  question: string;
-  /**
-   * Ground-truth failure modes a good analyst must identify. A finding "hits"
-   * a mode when it contains ANY of the mode's case-insensitive cues. Derive
-   * these from objective signal (failed task + which step broke), never from
-   * the analyst's own prior output.
-   */
-  expectedFailureModes: Array<{
-    id: string;
-    cues: string[];
-  }>;
-  /**
-   * Cues that mark a finding as HALLUCINATED / out-of-scope for this corpus —
-   * naming a tool, error, or failure that did not occur. Presence penalizes
-   * precision. Optional; omit to score recall only.
-   */
-  forbiddenCues?: string[];
-}
-/** The analyst's output for one scenario — the artifact the judge scores. */
-interface AnalystArtifact {
-  answer: string;
-  findings: string[];
-  /** The hardcoded-prompt version the analyst reported (provenance only; the
-   *  optimized surface overrides the actual prompt text used). */
-  actorPromptVersion: string;
-}
-interface BuildAnalystSurfaceDispatchOptions {
-  /**
-   * Everything `analyzeTraces` needs EXCEPT `actorDescription` (supplied by the
-   * surface under optimization) and `source` (supplied by the scenario). `ai`
-   * (the AxAIService) is required for a live run.
-   */
-  analystOptions: Omit<AnalyzeTracesOptions, 'actorDescription' | 'source'>;
-  /** Test seam: defaults to the real `analyzeTraces`. */
-  analyze?: (input: AnalyzeTracesInput, options: AnalyzeTracesOptions) => Promise<AnalyzeTracesResult>;
-}
-/**
- * Build the `dispatchWithSurface(surface, scenario, ctx)` the improvement loop
- * calls: run the analyst with `surface` as its actorDescription over the
- * scenario's trace corpus and return its findings.
- */
-declare function buildAnalystSurfaceDispatch(opts: BuildAnalystSurfaceDispatchOptions): (surface: MutableSurface, scenario: AnalystScenario, ctx: DispatchContext) => Promise<AnalystArtifact>;
-interface FailureModeRecallJudgeOptions {
-  /** Weight on recall when precision is also scored (forbiddenCues present).
-   *  Default 0.5 (equal). Recall-only when no forbiddenCues exist. */
-  recallWeight?: number;
-}
-/**
- * Deterministic, ground-truth judge for analyst findings. Composite =
- * recall of the scenario's `expectedFailureModes` (optionally blended with a
- * precision term that penalizes findings tripping `forbiddenCues`). No LLM —
- * the score is a function of the labels, so the analyst prompt is optimized
- * toward surfacing real failures, not toward a judge it can flatter.
- */
-declare function failureModeRecallJudge(opts?: FailureModeRecallJudgeOptions): JudgeConfig<AnalystArtifact, AnalystScenario>;
+interface TraceAnalystScenario extends Scenario {
+  kind: 'trace-analyst';
+  traceStore: TraceAnalysisStore;
+  labelState: AnalystBenchmarkLabelState;
+  expectedIssues: readonly AnalystIssueExpectation[];
+  labeledEvidence?: AnalystBenchmarkCase['labeledEvidence'];
+}
+interface TraceAnalystArtifact {
+  findings: readonly AnalystFinding[];
+  usage?: AnalystUsageReceipt;
+  run?: AnalystRunResult;
+}
+interface BuildTraceAnalystSurfaceDispatchOptions {
+  analyze(input: {
+    actorDescription: string;
+    traceStore: TraceAnalysisStore;
+    runId: string;
+    signal: AbortSignal;
+  }): Promise<TraceAnalystArtifact>;
+}
+declare function buildTraceAnalystSurfaceDispatch(options: BuildTraceAnalystSurfaceDispatchOptions): (surface: MutableSurface, scenario: TraceAnalystScenario, context: DispatchContext) => Promise<TraceAnalystArtifact>;
+declare function traceAnalystQualityJudge(): JudgeConfig<TraceAnalystArtifact, TraceAnalystScenario>;
 //#endregion
 //#region src/paired-arms.d.ts
 /** One arm observation of one work item. Structural on purpose: callers
@@ -1117,241 +1070,6 @@ declare class FsLabeledScenarioStore implements LabeledScenarioStore {
  */
 declare function neutralizeText(content: string): string;
 //#endregion
-//#region src/artifact-validator.d.ts
-/**
- * Artifact validators.
- *
- * Generic "score a produced artifact" primitive. Tax uses it for PDF form
- * correctness, research for sourced briefs, browser for task assertions, coding
- * for social posts. One interface, many validators; all plug into
- * `BenchmarkRunner` the same way.
- *
- * A validator receives an `Artifact` (file on disk, JSON blob, text, binary)
- * plus a `ValidationContext` (scenario id, the turns that produced it) and
- * returns a `ValidationResult` with pass/fail + 0..1 score + structured
- * issues.
- */
-interface Artifact {
-  /** Logical kind — validators type-guard on this */
-  kind: 'file' | 'json' | 'text' | 'binary' | string;
-  /** Filesystem-style path, optional */
-  path?: string;
-  /** String content for text/json/file kinds */
-  content?: string;
-  /** Binary content (if kind === 'binary') */
-  bytes?: Uint8Array;
-  /** Caller-supplied metadata (mimeType, sha256, size, etc.) */
-  metadata?: Record<string, unknown>;
-}
-interface ValidationContext {
-  scenarioId: string;
-  turnIndex?: number;
-  /** Prior artifacts for multi-artifact scenarios */
-  priorArtifacts?: Artifact[];
-  /** Free-form hints the validator uses for domain-specific checks */
-  hints?: Record<string, unknown>;
-}
-interface ValidationIssue {
-  severity: 'error' | 'warning' | 'info';
-  message: string;
-  /** Optional path into the artifact (e.g. JSON path or byte offset) */
-  locus?: string;
-}
-interface ValidationResult {
-  pass: boolean;
-  /** 0–1 normalized score. Validators should be monotonic in pass-ness. */
-  score: number;
-  issues: ValidationIssue[];
-  /** Diagnostic payload for reporters */
-  evidence?: Record<string, unknown>;
-}
-interface ArtifactValidator {
-  /** Stable identifier for the validator; appears in reports. */
-  name: string;
-  /** Optional description for human-facing reports. */
-  description?: string;
-  /** Called once per artifact; validators are expected to be pure + idempotent. */
-  validate(artifact: Artifact, context: ValidationContext): Promise<ValidationResult>;
-}
-/**
- * Run every validator on the same artifact; aggregate pass as AND, score as
- * (weighted) mean, issues concatenated. Weights default to 1 each.
- */
-declare function composeValidators(validators: ArtifactValidator[], options?: {
-  name?: string;
-  weights?: number[];
-}): ArtifactValidator;
-/** Pass if the artifact body matches a provided regex. */
-declare function regexMatch(name: string, pattern: RegExp): ArtifactValidator;
-/** Pass if JSON parses and every required key is present. */
-declare function jsonHasKeys(name: string, requiredPaths: string[]): ArtifactValidator;
-/** Pass if min ≤ byte length ≤ max. */
-declare function byteLengthRange(name: string, min: number, max: number): ArtifactValidator;
-/** Pass if the artifact contains every required substring (case-insensitive by default). */
-declare function containsAll(name: string, required: string[], options?: {
-  caseSensitive?: boolean;
-}): ArtifactValidator;
-//#endregion
-//#region src/completion-verifier.d.ts
-/** What kind of produced state can satisfy a requirement structurally. */
-type SatisfiedBy = 'artifact' | 'proposal' | 'tool-call' | 'any';
-interface CompletionRequirement {
-  /** Stable id from the task gold (e.g. a persona's `expected_requirements[].req_id`). */
-  reqId: string;
-  /** Human-readable description of the required deliverable. */
-  title: string;
-  /** Optional kind/category hint, matched against a produced item's kind. */
-  category?: string;
-  /** What produced state satisfies this requirement. Defaults to 'any'. */
-  satisfiedBy?: SatisfiedBy;
-}
-interface TaskGold {
-  taskId: string;
-  requirements: CompletionRequirement[];
-}
-interface ProducedProposal {
-  id: string;
-  title: string;
-  status: 'pending' | 'approved' | 'rejected';
-  /** Optional persisted body — when present, enables a correctness check. */
-  content?: string;
-}
-/** Everything observable about what a run actually produced. */
-interface ProducedState {
-  /** Persisted vault artifacts. Reuses the shared `Artifact` shape. */
-  artifacts: Artifact[];
-  /** Proposals / filings the agent created. */
-  proposals: ProducedProposal[];
-  /** Names of tools the agent invoked. */
-  toolCalls: string[];
-}
-interface RequirementCheck {
-  reqId: string;
-  title: string;
-  /** A produced item of the right kind matched the requirement, non-empty. */
-  structurallyPresent: boolean;
-  /**
-   * Whether the matched item actually fulfils the requirement. `null` when
-   * not structurally present, when the matched item carries no content
-   * to assess, or when the correctness check itself failed (`unmeasured`).
-   */
-  correct: boolean | null;
-  /** structurallyPresent && !unmeasured && correct !== false. */
-  satisfied: boolean;
-  /**
-   * Set when the correctness check itself errored (LLM call failure or an
-   * unparseable response after retry). The requirement's fulfilment is
-   * UNKNOWN — `correct` stays null, `satisfied` is false, and
-   * `completionVerdict` excludes the row from `completionRate`'s
-   * denominator. Never folded into a zero: a synthetic zero is
-   * indistinguishable from a real failure (see `JudgeParseError`).
-   */
-  unmeasured?: true;
-  /** Why the correctness check could not be measured (present iff `unmeasured`). */
-  unmeasuredReason?: string;
-  /** Human-readable evidence for the verdict. */
-  evidence: string[];
-}
-/** Extends the substrate verdict spine: `valid` = `fullyComplete` and
- *  `score` = `completionRate` — derived in `completionVerdict()`, the one
- *  place those equalities hold by construction. */
-interface CompletionVerdict extends DefaultVerdict {
-  taskId: string;
-  requirements: RequirementCheck[];
-  /** satisfied / MEASURABLE requirements (unmeasured rows leave the denominator). */
-  completionRate: number;
-  /** Every measurable requirement satisfied (false when anything is unmeasured). */
-  fullyComplete: boolean;
-  /** Requirements whose correctness check errored — reported, never scored as zero. */
-  unmeasuredCount: number;
-}
-/**
- * Construct a `CompletionVerdict` from the per-requirement checks, deriving
- * `completionRate` / `fullyComplete` and the spine fields (`valid` =
- * `fullyComplete`, `score` = `completionRate`) in one place. Throws on zero
- * requirements — a verdict over nothing is a misconfiguration, mirroring
- * `verifyCompletion`'s gold-spec guard.
- */
-declare function completionVerdict(input: {
-  taskId: string;
-  requirements: RequirementCheck[];
-}): CompletionVerdict;
-/**
- * Decides whether a produced item's content actually fulfils a requirement.
- * Injected so the structural verifier stays pure and unit-testable; the
- * production implementation is `createLlmCorrectnessChecker`.
- */
-type CorrectnessChecker = (requirement: CompletionRequirement, content: string) => Promise<{
-  correct: boolean;
-  reason: string;
-}>;
-/**
- * Verify whether a run completed the task. `checkCorrectness` is injected —
- * `createLlmCorrectnessChecker` for production, a deterministic stub in tests.
- *
- * Throws on a gold spec with no requirements: an eval task that requires
- * nothing is a misconfiguration, not a vacuously-complete task.
- */
-declare function verifyCompletion(gold: TaskGold, state: ProducedState, checkCorrectness: CorrectnessChecker): Promise<CompletionVerdict>;
-interface LlmCorrectnessCheckerOpts {
-  model?: string;
-  /** Optional ledger for direct use. */
-  costLedger?: CostLedgerHandle;
-  costPhase?: string;
-  costTags?: Record<string, string>;
-  signal?: AbortSignal;
-  /** Max chars of artifact content sent to the checker. */
-  maxContentChars?: number;
-  /**
-   * Checker LLM calls per requirement before giving up (parse failures and
-   * call errors both consume attempts). The failure then surfaces as an
-   * `unmeasured` requirement, never a zero.
-   */
-  maxAttempts?: number;
-  /**
-   * Forensic capture of every checker request/response/error — without it a
-   * checker failure is unauditable (the agent-turn raws never contain the
-   * checker's own calls). Same sink contract as `LlmClient`.
-   */
-  rawSink?: RawProviderSink;
-}
-/**
- * Parse the correctness checker's model response. Tolerates a response
- * truncated mid-JSON (max_tokens cap) by auto-closing the prefix — the
- * verdict boolean usually lands in the first few tokens, so a recovered
- * prefix with a boolean `correct` is a real measurement, not a guess.
- * Fails loud (JudgeParseError) when no boolean verdict is recoverable.
- */
-declare function parseCorrectnessResponse(raw: string): {
-  correct: boolean;
-  reason: string;
-};
-/**
- * Production `CorrectnessChecker` — one LLM call per matched artifact,
- * deterministic (temperature 0), structured JSON out. Judges fulfilment
- * only: a plan, a gesture, or a description of what should be done does not
- * fulfil a requirement — the artifact must BE the deliverable.
- */
-declare function createLlmCorrectnessChecker(chat: ChatClient, opts?: LlmCorrectnessCheckerOpts): CorrectnessChecker;
-/**
- * Deterministic `CorrectnessChecker` — the no-LLM counterpart to
- * `createLlmCorrectnessChecker`. A produced item fulfils a requirement when its
- * content is substantive (≥ `minContentLength` chars) AND recalls ≥ `minRecall`
- * of the requirement title's significant tokens. No network.
- *
- * Polarity-blind: token recall credits a negation that contains the
- * requirement's tokens ("I will NOT produce the comparison" recalls every token
- * of "produce the comparison"). The structural match stage is ALSO lexical, so
- * pairing the two collapses to a single gameable gate. Use this only as an
- * opt-in structural pre-filter or for tasks whose requirements have no polarity
- * to invert; for produced-state grading the correctness checker MUST be semantic
- * (`createLlmCorrectnessChecker`). See the anti-game fixtures in the test suite.
- */
-declare function createTokenRecallChecker(opts?: {
-  minRecall?: number;
-  minContentLength?: number;
-}): CorrectnessChecker;
-//#endregion
 //#region src/produced-state.d.ts
 /** A tool the agent invoked. */
 interface ToolCallEventLike {
@@ -2297,6 +2015,60 @@ interface TransientFailureOptions {
  */
 declare function isTransientTransportFailure(message: string | null | undefined, opts?: TransientFailureOptions): boolean;
 //#endregion
+//#region src/campaign/upstream-evaluators.d.ts
+interface PhoenixEvaluationResultLike {
+  score?: number;
+  label?: string;
+  explanation?: string;
+}
+interface PhoenixEvaluatorLike<TRecord extends Record<string, unknown>> {
+  name: string;
+  kind: 'LLM' | 'CODE';
+  optimizationDirection?: 'MAXIMIZE' | 'MINIMIZE' | 'NEUTRAL';
+  evaluate(record: TRecord, context: UpstreamEvaluationContext): Promise<PhoenixEvaluationResultLike>;
+}
+interface AutoevalsScoreLike {
+  name: string;
+  score: number | null;
+  metadata?: Record<string, unknown>;
+}
+type AutoevalsScorerLike<TInput extends Record<string, unknown>> = (input: TInput, context: UpstreamEvaluationContext) => AutoevalsScoreLike | Promise<AutoevalsScoreLike>;
+interface UpstreamEvaluationContext {
+  readonly signal: AbortSignal;
+  readonly callId?: string;
+}
+type PaidEvaluationOptions<TResult> = Pick<RunPaidCallInput<TResult>, 'maximumCharge' | 'receipt' | 'receiptFromError'> & {
+  model: string;
+};
+interface UpstreamJudgeOptions<TScenario extends Scenario> {
+  name?: string;
+  dimension?: string;
+  judgeVersion?: string;
+  appliesTo?: (scenario: TScenario) => boolean;
+  /** Convert the upstream score when its native scale is not higher-is-better. */
+  toComposite?: (score: number) => number;
+}
+declare function phoenixEvaluatorJudge<TRecord extends Record<string, unknown>, TArtifact, TScenario extends Scenario = Scenario>(evaluator: PhoenixEvaluatorLike<TRecord>, options: UpstreamJudgeOptions<TScenario> & {
+  mapInput(input: {
+    artifact: TArtifact;
+    scenario: TScenario;
+  }): TRecord;
+  paidCall?: PaidEvaluationOptions<PhoenixEvaluationResultLike>;
+}): JudgeConfig<TArtifact, TScenario>;
+declare function autoevalsScorerJudge<TInput extends Record<string, unknown>, TArtifact, TScenario extends Scenario = Scenario>(scorer: AutoevalsScorerLike<TInput>, options: UpstreamJudgeOptions<TScenario> & {
+  name: string;
+  mapInput(input: {
+    artifact: TArtifact;
+    scenario: TScenario;
+  }): TInput;
+} & ({
+  kind: 'CODE';
+  paidCall?: never;
+} | {
+  kind: 'LLM';
+  paidCall: PaidEvaluationOptions<AutoevalsScoreLike>;
+})): JudgeConfig<TArtifact, TScenario>;
+//#endregion
 //#region src/campaign/worktree/index.d.ts
 type GitOutput = string | Uint8Array;
 type GitEnvironment = Readonly<Record<string, string>>;
@@ -2365,5 +2137,5 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 //#endregion
-export { SearchSurfaceKind as $, SequentialPairedGateOptions as $n, CrossSurfacePairwiseEntry as $r, harnessAxisOf as $t, SearchCandidateSlot as A, FsLabeledScenarioStore as An, CrossSurfaceBestSingleSelection as Ar, userStoryScoreboard as At, SearchLedgerHash as B, DimensionRegression as Bn, CrossSurfaceDistribution as Br, assertRealAgentReceipts as Bt, SEARCH_LEDGER_SCHEMA as C, failureModeRecallJudge as Ci, ValidationResult as Cn, loadEvalFixtureScenarios as Cr, ScoreboardSummary as Ct, SearchCandidateDecidedEvent as D, jsonHasKeys as Dn, CrossSurfaceAdditionDecision as Dr, renderScoreboardMarkdown as Dt, SearchAttemptAccounting as E, containsAll as En, AnalyzeCrossSurfaceInteractionsInput as Er, makePlaybackDispatch as Et, SearchFailureReason as F, RolloutCall as Fn, CrossSurfaceCandidateOutcome as Fr, RunProfileMatrixResult as Ft, SearchOperationRecordedEvent as G, dimensionRegressions as Gn, CrossSurfaceInteractionEffect as Gr, CODING_HARNESSES as Gt, SearchLedgerTrustedHeadMode as H, HeldoutSignificanceOptions as Hn, CrossSurfaceEvidenceBreakdown as Hr, summarizeAgentReceiptIntegrity as Ht, SearchLedger as I, ScoredRollout as In, CrossSurfaceCandidateSummary as Ir, ScenarioRollup as It, SearchPlannedOperation as J, SequentialDecideFn as Jn, CrossSurfaceInteractionTask as Jr, ProfileAxisSpec as Jt, SearchPlan as K, heldoutSignificance as Kn, CrossSurfaceInteractionPath as Kr, HARNESS_NATIVE_MODEL as Kt, SearchLedgerAppendResult as L, UngroundedLiteralReport as Ln, CrossSurfaceComponent as Lr, runProfileMatrix as Lt, SearchCandidateSurface as M, LabeledScenarioStoreError as Mn, CrossSurfaceCandidate as Mr, ProfileMatrixError as Mt, SearchCompletedEvent as N, RolloutArgumentDiff as Nn, CrossSurfaceCandidateComparison as Nr, ProfileSummary as Nt, SearchCandidateLineage as O, regexMatch as On, CrossSurfaceAdditionRejectionReason as Or, scoreUserStory as Ot, SearchCostAccounting as P, RolloutArgumentDiffOptions as Pn, CrossSurfaceCandidateEvidence as Pr, RunProfileMatrixOptions as Pt, SearchSurfaceEvidence as Q, SequentialPairedGate as Qn, CrossSurfacePairIncompatibilityReason as Qr, expandProfileAxes as Qt, SearchLedgerEntry as R, classifyUngroundedLiterals as Rn, CrossSurfaceComponentEvidence as Rr, BackendIntegrityError as Rt, OpenSearchLedgerOptions as S, buildAnalystSurfaceDispatch as Si, ValidationIssue as Sn, loadEvalFixture as Sr, ScoreboardRow as St, SearchArtifactRef as T, composeValidators as Tn, analyzeCrossSurfaceInteractions as Tr, UserStoryVerdict as Tt, SearchModelIdentity as U, PairedHoldout as Un, CrossSurfaceIneligibilityReason as Ur, summarizeBackendIntegrity as Ut, SearchLedgerReplay as V, HeldoutSignificance as Vn, CrossSurfaceEligibility as Vr, assertRealBackend as Vt, SearchOperationKind as W, detectScale as Wn, CrossSurfaceInteractionAwareSelection as Wr, AgentProfile$1 as Wt, SearchSourceRef as X, SequentialDecision as Xn, CrossSurfacePairCompatibility as Xr, agentProfileId as Xt, SearchPlannedTask as Y, SequentialDecideOptions as Yn, CrossSurfaceNaiveStackSelection as Yr, agentProfileHash as Yt, SearchSurfaceEffect as Z, SequentialObservation as Zn, CrossSurfacePairEvidence as Zr, agentProfileModelId as Zt, surfaceHash as _, pairRunRecords as _i, parseCorrectnessResponse as _n, EvalFixtureScenario as _r, tangleTracesRoot as _t, WorktreeAdapterError as a, ComparePairedArmsOptions as ai, CompletionRequirement as an, SignedManifestAlgo as ar, SearchLedgerConflictError as at, acquireSingleRunLock as b, BuildAnalystSurfaceDispatchOptions as bi, ArtifactValidator as bn, PlanEvalFixtureRunOptions as br, PlaybackStep as bt, verifyCodeSurface as c, PairArmsOptions as ci, LlmCorrectnessCheckerOpts as cn, hashJson as cr, CampaignBreakdown as ct, assertCodeSurfaceIdentity as d, PairedArmRow as di, RequirementCheck as dn, NeutralizationGateOptions as dr, compareRankKeys as dt, CrossSurfaceRankedSingle as ei, ArtifactEventLike as en, sequentialDecide as er, SearchTaskAttemptedEvent as et, assertComponentSurface as f, PairedArmsComparison as fi, SatisfiedBy as fn, neutralizationGate as fr, DiscriminationScore as ft, surfaceContentHash as g, pairArms as gi, createTokenRecallChecker as gn, EvalFixtureRunPlan as gr, resolveRunDir as gt, renderSurfaceDiff as h, comparePairedArms as hi, createLlmCorrectnessChecker as hn, EvalFixtureLoadOptions as hr, selectDiscriminative as ht, WorktreeAdapter as i, CrossSurfaceTaskRow as ii, extractProducedState as in, SignedManifest as ir, validateSearchLedgerEvent as it, SearchCandidateSlotClosedEvent as j, FsLabeledScenarioStoreOptions as jn, CrossSurfaceBootstrapPolicy as jr, ProfileDispatchFn as jt, SearchCandidateRegisteredEvent as k, neutralizeText as kn, CrossSurfaceAttemptCompleteness as kr, scoreboardSummary as kt, TransientFailureOptions as l, PairArmsResult as li, ProducedProposal as ln, signManifest as lr, campaignBreakdown as lt, componentSurfaceIdentityMaterial as m, PairedMetricDelta as mi, completionVerdict as mn, EvalFixtureFile as mr, scoreDiscrimination as mt, GitWorktreeAdapterOptions as n, CrossSurfaceSelectionPolicy as ni, RuntimeEventLike as nn, HypothesisManifest as nr, SearchTokenAccounting as nt, gitWorktreeAdapter as o, MatchedPair as oi, CompletionVerdict as on, canonicalize as or, SearchLedgerError as ot, codeSurfaceIdentityMaterial as p, PairedCorrectness as pi, TaskGold as pn, EvalFixture as pr, ScenarioSignal as pt, SearchPlannedEvent as q, pairHoldout as qn, CrossSurfaceInteractionReport as qr, HarnessType$1 as qt, Worktree as r, CrossSurfaceSelections as ri, ToolCallEventLike as rn, HypothesisResult as rr, openSearchLedger as rt, resolveWorktreePath as s, MatchedRunRecordPair as si, CorrectnessChecker as sn, evaluateHypothesis as sr, SearchLedgerIntegrityError as st, CodeSurfaceVerification as t, CrossSurfaceRelativeCost as ti, ProposalEventLike as tn, sequentialPairedGate as tr, SearchTaskOutcome as tt, isTransientTransportFailure as u, PairRunRecordsResult as ui, ProducedState as un, verifyManifest as ur, campaignMeanComposite as ut, SingleRunLock as v, AnalystArtifact as vi, verifyCompletion as vn, EvalFixtureValidationMode as vr, PlaybackContext as vt, SearchAccountingAudit as w, byteLengthRange as wn, planEvalFixtureRun as wr, UserStory as wt, FileSearchLedger as x, FailureModeRecallJudgeOptions as xi, ValidationContext as xn, discoverEvalFixtures as xr, ScoreboardRenderOptions as xt, SingleRunLockOptions as y, AnalystScenario as yi, Artifact as yn, LoadEvalFixtureScenariosOptions as yr, PlaybackDriver as yt, SearchLedgerEvent as z, rolloutArgumentDiff as zn, CrossSurfaceCompositionStep as zr, BackendIntegrityReport as zt };
-//# sourceMappingURL=index-B4Fjfo5U.d.ts.map
+export { SearchPlannedEvent as $, EvalFixtureScenario as $n, pairRunRecords as $r, HarnessType$1 as $t, SearchAccountingAudit as A, SequentialDecideFn as An, CrossSurfaceInteractionTask as Ar, UserStory as At, SearchCostAccounting as B, SignedManifest as Bn, CrossSurfaceTaskRow as Br, RunProfileMatrixOptions as Bt, surfaceHash as C, HeldoutSignificance as Cn, CrossSurfaceEligibility as Cr, tangleTracesRoot as Ct, FileSearchLedger as D, dimensionRegressions as Dn, CrossSurfaceInteractionEffect as Dr, ScoreboardRenderOptions as Dt, acquireSingleRunLock as E, detectScale as En, CrossSurfaceInteractionAwareSelection as Er, PlaybackStep as Et, SearchCandidateRegisteredEvent as F, SequentialPairedGateOptions as Fn, CrossSurfacePairwiseEntry as Fr, scoreboardSummary as Ft, SearchLedgerEvent as G, signManifest as Gn, PairArmsResult as Gr, BackendIntegrityReport as Gt, SearchLedger as H, canonicalize as Hn, MatchedPair as Hr, ScenarioRollup as Ht, SearchCandidateSlot as I, sequentialDecide as In, CrossSurfaceRankedSingle as Ir, userStoryScoreboard as It, SearchLedgerTrustedHeadMode as J, neutralizationGate as Jn, PairedArmsComparison as Jr, summarizeAgentReceiptIntegrity as Jt, SearchLedgerHash as K, verifyManifest as Kn, PairRunRecordsResult as Kr, assertRealAgentReceipts as Kt, SearchCandidateSlotClosedEvent as L, sequentialPairedGate as Ln, CrossSurfaceRelativeCost as Lr, ProfileDispatchFn as Lt, SearchAttemptAccounting as M, SequentialDecision as Mn, CrossSurfacePairCompatibility as Mr, makePlaybackDispatch as Mt, SearchCandidateDecidedEvent as N, SequentialObservation as Nn, CrossSurfacePairEvidence as Nr, renderScoreboardMarkdown as Nt, OpenSearchLedgerOptions as O, heldoutSignificance as On, CrossSurfaceInteractionPath as Or, ScoreboardRow as Ot, SearchCandidateLineage as P, SequentialPairedGate as Pn, CrossSurfacePairIncompatibilityReason as Pr, scoreUserStory as Pt, SearchPlan as Q, EvalFixtureRunPlan as Qn, pairArms as Qr, HARNESS_NATIVE_MODEL as Qt, SearchCandidateSurface as R, HypothesisManifest as Rn, CrossSurfaceSelectionPolicy as Rr, ProfileMatrixError as Rt, surfaceContentHash as S, DimensionRegression as Sn, CrossSurfaceDistribution as Sr, resolveRunDir as St, SingleRunLockOptions as T, PairedHoldout as Tn, CrossSurfaceIneligibilityReason as Tr, PlaybackDriver as Tt, SearchLedgerAppendResult as U, evaluateHypothesis as Un, MatchedRunRecordPair as Ur, runProfileMatrix as Ut, SearchFailureReason as V, SignedManifestAlgo as Vn, ComparePairedArmsOptions as Vr, RunProfileMatrixResult as Vt, SearchLedgerEntry as W, hashJson as Wn, PairArmsOptions as Wr, BackendIntegrityError as Wt, SearchOperationKind as X, EvalFixtureFile as Xn, PairedMetricDelta as Xr, AgentProfile$1 as Xt, SearchModelIdentity as Y, EvalFixture as Yn, PairedCorrectness as Yr, summarizeBackendIntegrity as Yt, SearchOperationRecordedEvent as Z, EvalFixtureLoadOptions as Zn, comparePairedArms as Zr, CODING_HARNESSES as Zt, assertCodeSurfaceIdentity as _, RolloutCall as _n, CrossSurfaceCandidateOutcome as _r, compareRankKeys as _t, WorktreeAdapterError as a, harnessAxisOf as an, loadEvalFixtureScenarios as ar, SearchSurfaceKind as at, componentSurfaceIdentityMaterial as b, classifyUngroundedLiterals as bn, CrossSurfaceComponentEvidence as br, scoreDiscrimination as bt, verifyCodeSurface as c, RuntimeEventLike as cn, AnalyzeCrossSurfaceInteractionsInput as cr, SearchTokenAccounting as ct, PhoenixEvaluationResultLike as d, neutralizeText as dn, CrossSurfaceAttemptCompleteness as dr, SearchLedgerConflictError as dt, BuildTraceAnalystSurfaceDispatchOptions as ei, ProfileAxisSpec as en, EvalFixtureValidationMode as er, SearchPlannedOperation as et, PhoenixEvaluatorLike as f, FsLabeledScenarioStore as fn, CrossSurfaceBestSingleSelection as fr, SearchLedgerError as ft, isTransientTransportFailure as g, RolloutArgumentDiffOptions as gn, CrossSurfaceCandidateEvidence as gr, campaignMeanComposite as gt, TransientFailureOptions as h, RolloutArgumentDiff as hn, CrossSurfaceCandidateComparison as hr, campaignBreakdown as ht, WorktreeAdapter as i, traceAnalystQualityJudge as ii, expandProfileAxes as in, loadEvalFixture as ir, SearchSurfaceEvidence as it, SearchArtifactRef as j, SequentialDecideOptions as jn, CrossSurfaceNaiveStackSelection as jr, UserStoryVerdict as jt, SEARCH_LEDGER_SCHEMA as k, pairHoldout as kn, CrossSurfaceInteractionReport as kr, ScoreboardSummary as kt, AutoevalsScoreLike as l, ToolCallEventLike as ln, CrossSurfaceAdditionDecision as lr, openSearchLedger as lt, phoenixEvaluatorJudge as m, LabeledScenarioStoreError as mn, CrossSurfaceCandidate as mr, CampaignBreakdown as mt, GitWorktreeAdapterOptions as n, TraceAnalystScenario as ni, agentProfileId as nn, PlanEvalFixtureRunOptions as nr, SearchSourceRef as nt, gitWorktreeAdapter as o, ArtifactEventLike as on, planEvalFixtureRun as or, SearchTaskAttemptedEvent as ot, autoevalsScorerJudge as p, FsLabeledScenarioStoreOptions as pn, CrossSurfaceBootstrapPolicy as pr, SearchLedgerIntegrityError as pt, SearchLedgerReplay as q, NeutralizationGateOptions as qn, PairedArmRow as qr, assertRealBackend as qt, Worktree as r, buildTraceAnalystSurfaceDispatch as ri, agentProfileModelId as rn, discoverEvalFixtures as rr, SearchSurfaceEffect as rt, resolveWorktreePath as s, ProposalEventLike as sn, analyzeCrossSurfaceInteractions as sr, SearchTaskOutcome as st, CodeSurfaceVerification as t, TraceAnalystArtifact as ti, agentProfileHash as tn, LoadEvalFixtureScenariosOptions as tr, SearchPlannedTask as tt, AutoevalsScorerLike as u, extractProducedState as un, CrossSurfaceAdditionRejectionReason as ur, validateSearchLedgerEvent as ut, assertComponentSurface as v, ScoredRollout as vn, CrossSurfaceCandidateSummary as vr, DiscriminationScore as vt, SingleRunLock as w, HeldoutSignificanceOptions as wn, CrossSurfaceEvidenceBreakdown as wr, PlaybackContext as wt, renderSurfaceDiff as x, rolloutArgumentDiff as xn, CrossSurfaceCompositionStep as xr, selectDiscriminative as xt, codeSurfaceIdentityMaterial as y, UngroundedLiteralReport as yn, CrossSurfaceComponent as yr, ScenarioSignal as yt, SearchCompletedEvent as z, HypothesisResult as zn, CrossSurfaceSelections as zr, ProfileSummary as zt };
+//# sourceMappingURL=index-D0cxAdaV.d.ts.map

package/dist/index-D0cxAdaV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D0cxAdaV.d.ts","names":[],"sources":["../src/campaign/analyst-surface.ts","../src/paired-arms.ts","../src/campaign/cross-surface-types.ts","../src/campaign/cross-surface-interaction.ts","../src/campaign/fixtures.ts","../src/campaign/gates/neutralization-gate.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts","../src/campaign/grounded-reflection.ts","../src/campaign/labeled-store/fs-adapter.ts","../src/campaign/neutralize.ts","../src/produced-state.ts","../src/agent-profile.ts","../src/integrity/backend-integrity.ts","../src/campaign/presets/run-profile-matrix.ts","../src/campaign/presets/playback.ts","../src/campaign/run-dir.ts","../src/campaign/scenario-selection.ts","../src/campaign/score-utils.ts","../src/campaign/search-ledger-errors.ts","../src/campaign/search-ledger.ts","../src/campaign/single-run-lock.ts","../src/campaign/surface-identity.ts","../src/campaign/transient-failure.ts","../src/campaign/upstream-evaluators.ts","../src/campaign/worktree/index.ts"],"mappings":";;;;;;;;;;;;;UAWiB,6BAA6B;EAC5C;EACA,YAAY;EACZ,YAAY;EACZ,yBAAyB;EACzB,kBAAkB;;UAGH;EACf,mBAAmB;EACnB,QAAQ;EACR,MAAM;;UAGS;EACf,QAAQ;IACN;IACA,YAAY;IACZ;IACA,QAAQ;MACN,QAAQ;;iBAGE,iCACd,SAAS,2CAET,SAAS,gBACT,UAAU,sBACV,SAAS,oBACN,QAAQ;iBAgBG,4BAA4B,YAC1C,sBACA;;;;;UClBe;;;EAGf;;;;;EAKA;;EAEA;;EAEA;;EAEA,UAAU;;UAGK;;EAEf;;EAEA;;;UAIe;EACf;;;;EAIA;EACA,UAAU;EACV,WAAW;;UAGI;;EAEf,OAAO;;;EAGP,kBAAkB;;EAElB,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAqBL,SAAS,eAAe,gBAAgB,MAAM,kBAAkB;;UA8G/D;;EAEf;;EAEA;;EAEA,SAAS;;EAET,gBAAgB;;;UAID;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,aAAa;;EAEb;IAAY;IAAW;;;UAGR,iCAAiC;;;;EAIhD;;EAEA,YAAY;;UAGG;EACf;EACA;EACA;;;EAGA,aAAa;EACb,cAAc;;;;;;;;;;;;;;;iBAgBA,kBACd,eAAe,gBACf,MAAM,2BACL;UAmEc;EACf;EACA;EACA,UAAU;EACV,WAAW;;UAGI;EACf,OAAO;EACP,kBAAkB;EAClB,mBAAmB;;;;;;;;;iBAeL,eACd,uBAAuB,aACvB,wBAAwB,cACvB;;;;KCjXS;;UAGK;EACf;EACA;;EAEA;;;UAIe;EACf;EACA;EACA;EACA;;;UAIe;EACf;;EAEA;;EAEA;;;;;;;UAQe;EACf;EACA;;EAEA;EACA,cAAc;EACd;EACA;;;;;;EAMA,MAAM;EACN,mBAAmB;;EAEnB;;UAGe;EACf;EACA;EACA;;;UAIe;EACf;EACA;EACA;EACA;;EAEA,kCAAkC;;EAElC;;UAGe,qCACf,aAAa,sBAAsB;EAEnC,qBAAqB;EACrB,qBAAqB;EACrB,eAAe;EACf;;EAEA;;EAEA;;EAEA;;EAEA;EACA,WAAW;EACX,WAAW;;UAGI;EACf;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf,aAAa;EACb;EACA;EACA;EACA;;KAGU;UAWK;EACf;EACA,SAAS;;UAGM;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf,WAAW;EACX,SAAS;EACT,OAAO;EACP,OAAO,eAAe;EACtB,QAAQ;EACR,QAAQ;;EAER,sBAAsB;;EAEtB,aAAa;;UAGE;EACf;EACA;EACA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR,cAAc,eAAe;;UAGd;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;;EAEA;EACA;;UAGe;EACf,SAAS;EACT;EACA;EACA;EACA;EACA,eAAe;EACf,gBAAgB;;KAGN;UAYK;EACf;EACA,SAAS;EACT;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA,4BAA4B,iCAAiC;EAC7D,wBAAwB,eAAe;EACvC,QAAQ;EACR,QAAQ;EACR,aAAa;EACb,eAAe;;UAGA;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA,SAAS;;UAGM;;EAEf;EACA;;KAGU;UAaK;EACf;EACA;EACA;EACA;EACA;EACA,uBAAuB;EACvB;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA,YAAY;EACZ;;;UAIe;EACf;EACA;EACA;EACA;EACA,OAAO;;UAGQ;;EAEf;;EAEA;EACA;;EAEA;EACA;;EAEA,gBAAgB;;EAEhB,OAAO;;UAGQ;EACf,YAAY;EACZ,YAAY;EACZ,kBAAkB;;UAGH,8BACf,aAAa,sBAAsB;EAEnC;EACA;EACA;EACA;;EAEA,MAAM;EACN,iBAAiB;EACjB,iBAAiB;EACjB,YAAY;EACZ,UAAU;EACV,YAAY;;;;;;;;;iBCnRE,gCAAgC,aAAa,qBAC3D,OAAO,qCAAqC,QAC3C,8BAA8B;;;KC7CrB;UAEK;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;EACP;;UAGe,4BAA4B;EAC3C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;;EAEf,aAAa;;EAE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"}

package/dist/{index-DuhJaaiH.d.ts → index-DEb46kc6.d.ts}

@@ -1,4 +1,4 @@
-import { c as ValidationError } from "./errors-CEk209JS.js";
+import { l as ValidationError } from "./errors-DkfjIDvD.js";
 //#region src/ledger-core/atomic-file-lock.d.ts
 /** Crash-safe filesystem lock shared by campaign persistence and run exclusion. */
 interface AtomicFileLockOwner {
@@ -247,4 +247,4 @@ declare class FileLedgerJournal<Header extends object, Event extends LedgerEvent
 }
 //#endregion
 export { AtomicFileLock as A, withLedgerFileLock as C, LedgerHash as D, LedgerCanonicalizationError as E, AtomicFileLockUnavailable as F, probeAtomicFileLock as I, tryAcquireAtomicFileLock as L, AtomicFileLockError as M, AtomicFileLockOptions as N, canonicalString as O, AtomicFileLockOwner as P, tryWithLedgerFileLock as S, LEDGER_HASH_PATTERN as T, trustedHeadPathFor as _, LedgerChainFields as a, LedgerFileContext as b, LedgerJournalCodec as c, LedgerReplayResult as d, LedgerAnchoredEntry as f, readTrustedHeadFile as g, LedgerTrustedHeadSubject as h, LedgerAppendResult as i, AtomicFileLockAcquisition as j, hashCanonical as k, LedgerLineContext as l, LedgerTrustedHeadRemoval as m, FileLedgerJournalOptions as n, LedgerEntryOf as o, LedgerTrustedHead as p, LedgerAppendOptions as r, LedgerEventBase as s, FileLedgerJournal as t, LedgerProjector as u, verifyEntriesAgainstTrustedHead as v, writeLedgerFileAtomically as w, appendLedgerLine as x, FileLockResult as y };
-//# sourceMappingURL=index-DuhJaaiH.d.ts.map
+//# sourceMappingURL=index-DEb46kc6.d.ts.map

package/dist/index-DEb46kc6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DEb46kc6.d.ts","names":[],"sources":["../src/ledger-core/atomic-file-lock.ts","../src/ledger-core/canonical.ts","../src/ledger-core/journal-file.ts","../src/ledger-core/trusted-head.ts","../src/ledger-core/journal.ts"],"mappings":";;;UAiBiB;WACN;WACA;WACA;;UAGM;WACN,OAAO;EAChB;;KAGU;WACG;WAA0B;WAAyB,QAAQ;;WAC3D;WAA0B;;KAE7B;WACG;WAAyB,MAAM;IAC1C;UAEa;WACN;WACA;;cAGE,4BAA4B;WACrB;;;iBASJ,oBACd,SAAS,wBACR;;;;;;;iBAea,yBACd,SAAS,wBACR;;;KCjDS;;cAGC,qBAAmB;;cAGnB,oCAAoC;;;;iBAKjC,gBAAgB;iBAQhB,cAAc,iBAAiB;;;;;UCtB9B;;EAEf;EACA,eAAe,iBAAiB;IAAY;MAAoB;;;;iBAKlD,iBAAiB,cAAc,cAAc,SAAS;;;;iBA6CtD,0BACd,cACA,kBACA,SAAS;iBAqCK,mBAAmB,GAAG,cAAc,SAAS,mBAAmB,WAAW,IAAI;KAQnF,eAAe;EAAO;EAAgB,OAAO;;EAAQ;;iBAEjD,sBAAsB,GACpC,cACA,SAAS,mBACT,WAAW,IACV,eAAe;;;;UCnED;EACf;EACA,WAAW;;;UAII;EACf;EACA,WAAW;;;;iBAKG,mBAAmB;;;;;iBAWnB,oBACd,cACA,SAAS,oBACR;;;;;;;KA2ES;EACN;EAAe,MAAM;EAAmB;;EACxC;EAAe;EAAY;EAAoB;;EAC/C;EAAgB;;;UAsCL;;EAEf;;;EAGA;;;;;iBAMc,gCACd,kBAAkB,uBAClB,MAAM,mBACN,SAAS,mBACT,QAAQ;;;;UCjLO;EACf;;;;;UAMe,kBAAkB,cAAc;EAC/C;EACA,cAAc;EACd,OAAO;EACP,WAAW;;KAGD,cAAc,uBAAuB,cAAc,mBAAmB,SAChF,kBAAkB;UAEH;EACf;EACA;;;;;UAMe,gBAAgB,OAAO;EACtC,MAAM,OAAO,OAAO;EACpB,OAAO,SAAS,UAAU;;UAGX,mBACf,uBACA,cAAc,iBACd,oBACQ;;EAER,QAAQ;EACR,cAAc,kBAAkB;;;;EAIhC,WAAW,cAAc,SAAS,oBAAoB,cAAc,QAAQ;;EAE5E,iBAAiB,OAAO,cAAc,QAAQ,QAAQ;EACtD,mBAAmB,gBAAgB,cAAc,QAAQ,QAAQ;;UAGlD,mBAAmB,OAAO;EACzC,SAAS;EACT,YAAY;;UAGG,mBAAmB,OAAO;EACzC,OAAO;;EAEP;EACA,YAAY;;UAGG;;;;;;;;;;;;;;EAcf;;UAGe;;;;;;;EAOf;;;;cAiBW,kBAAkB,uBAAuB,cAAc,iBAAiB;WAC1E;;WAEA;mBACQ;mBACA;mBACA;EAEjB,YACE,cACA,OAAO,mBAAmB,QAAQ,OAAO,aACzC,UAAS;EASL,UAAU,QAAQ,mBAAmB,cAAc,QAAQ,QAAQ;EAMnE,OACJ,OAAO,OACP,UAAS,sBACR,QAAQ,mBAAmB,cAAc,QAAQ,QAAQ;;EA8CtD,eAAe,QAAQ;;;;EAWvB,kBAAkB,QAAQ;;;;;;;;EA4B1B,oBAAoB,QAAQ;;;;;;;;;;;;;UAoB1B;UAiBA;UAUA;UAgBA;UAgDA"}

package/dist/{index-C2fkZhv_.d.ts → index-sMN_hI4E.d.ts}

@@ -1,5 +1,5 @@
-import { u as RunTokenUsage } from "./run-record-DcObtIGh.js";
-import { l as RawProviderSink, o as ProviderRedactor } from "./raw-provider-sink-BU29Sh8h.js";
+import { u as RunTokenUsage } from "./run-record-DwHMk1Ai.js";
+import { _t as RawProviderSink, mt as ProviderRedactor } from "./types-5q2T25iW.js";
 //#region src/trace/extract-usage.d.ts
 type ExtractedUsage = RunTokenUsage;
 type SseUsageMode = 'cumulative' | 'delta';
@@ -65,4 +65,4 @@ interface CaptureFetchOptions {
 declare function captureFetchToRawSink(fetch: typeof globalThis.fetch, sink: RawProviderSink, ctx: CaptureFetchContext, opts?: CaptureFetchOptions): typeof globalThis.fetch;
 //#endregion
 export { ExtractedUsage as a, extractUsageFromResponse as c, ExtractUsageFromSseOptions as i, extractUsageFromSse as l, CaptureFetchOptions as n, SseUsageMode as o, captureFetchToRawSink as r, extractUsage as s, CaptureFetchContext as t };
-//# sourceMappingURL=index-C2fkZhv_.d.ts.map
+//# sourceMappingURL=index-sMN_hI4E.d.ts.map

package/dist/{index-C2fkZhv_.d.ts.map → index-sMN_hI4E.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-C2fkZhv_.d.ts","names":[],"sources":["../src/trace/extract-usage.ts","../src/trace/capture-fetch.ts"],"mappings":";;;KAgBY,iBAAiB;KACjB;UAEK;;EAEf,OAAO;;;;;;;iBAuDO,aAAa,gBAAgB;;;;;;iBA6C7B,oBACd,cACA,UAAS,6BACR;;;;;;;iBA4DmB,yBACpB,UAAU,UACV,aAAa,6BACZ,QAAQ;;;UCrKM;;;EAGf;;EAEA;;;EAGA;;EAEA;;EAEA;;UAGe;;EAEf,WAAW;;;EAGX;;;EAGA;;;;;;;;EAQA,WAAW,OAAO,gBAAgB,KAAK;;EAEvC,eAAe;;iBAkDD,sBACd,cAAc,WAAW,OACzB,MAAM,iBACN,KAAK,qBACL,OAAM,6BACE,WAAW"}
+{"version":3,"file":"index-sMN_hI4E.d.ts","names":[],"sources":["../src/trace/extract-usage.ts","../src/trace/capture-fetch.ts"],"mappings":";;;KAgBY,iBAAiB;KACjB;UAEK;;EAEf,OAAO;;;;;;;iBAuDO,aAAa,gBAAgB;;;;;;iBA6C7B,oBACd,cACA,UAAS,6BACR;;;;;;;iBA4DmB,yBACpB,UAAU,UACV,aAAa,6BACZ,QAAQ;;;UCrKM;;;EAGf;;EAEA;;;EAGA;;EAEA;;EAEA;;UAGe;;EAEf,WAAW;;;EAGX;;;EAGA;;;;;;;;EAQA,WAAW,OAAO,gBAAgB,KAAK;;EAEvC,eAAe;;iBAkDD,sBACd,cAAc,WAAW,OACzB,MAAM,iBACN,KAAK,qBACL,OAAM,6BACE,WAAW"}