@tangle-network/agent-eval 0.196.0 → 0.197.0

package/dist/{index-CpCIXObe.d.ts → index-CRsmcAGl.d.ts}

@@ -3,10 +3,10 @@ import { a as RunRecord, c as RunSplitTag, n as RunCostProvenance } from "./run-
 import "./types-CeDfCRXp.js";
 import "./statistical-heldout-BedVSZb2.js";
 import "./types-B2673PBj.js";
-import "./index-CigojbNH.js";
+import "./index-DJKZEldg.js";
 import { p as TraceSpanEvent } from "./client-BzL9niqi.js";
 import { d as InsightReport, t as AnalyzeRunsOptions } from "./analyze-runs-CPiKLJFs.js";
-import "./define-agent-eval-DwAaPvvH.js";
+import "./define-agent-eval-ulRlLvse.js";
 import "./default-registry-D2csUBBQ.js";
 import { AgentCandidateBenchmarkCellRef, AgentCandidateBenchmarkSuiteInputs, AgentCandidateBenchmarkTask, AgentCandidateBenchmarkTaskMaterial, AgentCandidateBundle, AgentCandidateEvaluationPolicy, AgentCandidateExperiment, AgentCandidateExperimentMaterial, AgentCandidateExperimentMeasurement, AgentImprovementCost, AgentImprovementMeasuredComparison, AgentProfileImprovementExperiment, AgentProfileImprovementExperimentMaterial, AgentProfileImprovementMeasuredComparison, AgentProfileImprovementMeasurement, AgentProfileImprovementRunCell, AgentProfileImprovementRunReceipt, AgentProfileImprovementSuiteInputs, AgentProfileImprovementTask, AgentProfileImprovementTaskMaterial, CandidateExecutionEvidence, Sha256Digest } from "@tangle-network/agent-interface";
 //#region src/contract/measured-comparison.d.ts
@@ -687,4 +687,4 @@ interface FromOtelSpansOptions {
 declare function fromOtelSpans(opts: FromOtelSpansOptions): RunRecord[];
 //#endregion
 export { FromRunRecordDirResult as $, CodeAgentSessionActionStatus as A, AgentTraceFile as B, fromOpenCodeSession as C, measuredComparisonFromCandidateExperiment as Ct, streamCodeAgentJsonlFile as D, sealCandidateExperiment as Dt, parseCodeAgentJsonlFile as E, sealCandidateBenchmarkTask as Et, CodeAgentSessionTerminalStatus as F, PartitionByAuthoringModelResult as G, AgentTraceRange as H, observeCodeAgentSession as I, EvalReportingSuiteInput as J, parseAgentTrace as K, AgentTraceContributor as L, CodeAgentSessionExecutionReceipt as M, CodeAgentSessionObservation as N, CodeAgentSessionAction as O, verifyCandidateExperiment as Ot, CodeAgentSessionSource as P, FromRunRecordDirOptions as Q, AgentTraceContributorType as R, fromKimiCodeSession as S, evaluatePairedMeasurements as St, parseCodeAgentJsonl as T, sealCandidateBenchmarkSuite as Tt, AgentTraceRecord as U, AgentTraceIndex as V, AuthoringProvenance as W, EvalReportingSuiteResult as X, EvalReportingSuiteOptions as Y, evalReportingSuite as Z, CodeAgentSessionIntakeResult as _, PairedMeasurement as _t, FromFeedbackTableOptions as a, RunAgentProfileImprovementExperimentOptions as at, fromClaudeCodeSession as b, RunCandidateExperimentOptions as bt, CodeAgentStoreObservation as c, runAgentProfileImprovementExperiment as ct, CodeAgentStoreScope as d, sealAgentProfileImprovementTask as dt, RunRecordRejection as et, CodeAgentStoreSession as f, verifyAgentProfileImprovementExperimentComparison as ft, CodeAgentSessionIntakeOptions as g, EvaluatePairedMeasurementsOptions as gt, CodeAgentSessionDiagnostic as h, CompareCandidateExperimentOptions as ht, FeedbackTableRow as i, CompareAgentProfileImprovementExperimentOptions as it, CodeAgentSessionActionSurface as j, CodeAgentSessionActionKind as k, verifyCandidateExperimentComparison as kt, CodeAgentStoreRejection as l, sealAgentProfileImprovementExperiment as lt, CodeAgentJsonlLine as m, CandidateExperimentRun as mt, fromOtelSpans as n, AgentProfileImprovementExperimentExecutionInput as nt, FromFeedbackTableResult as o, SealAgentProfileImprovementSuiteOptions as ot, observeCodeAgentStore as p, CandidateExperimentExecutionInput as pt, partitionRunsByAuthoringModel as q, FeedbackTableMeta as r, AgentProfileImprovementExperimentRun as rt, fromFeedbackTable as s, measuredComparisonFromAgentProfileImprovementExperiment as st, FromOtelSpansOptions as t, fromRunRecordDir as tt, CodeAgentStoreRejections as u, sealAgentProfileImprovementSuite as ut, CodeAgentSessionMetrics as v, PairedMeasurementAdapter as vt, fromPiSession as w, runCandidateExperiment as wt, fromCodexSession as x, SealCandidateBenchmarkSuiteOptions as xt, ParsedCodeAgentJsonl as y, PairedMeasurementEvaluation as yt, AgentTraceConversation as z };
-//# sourceMappingURL=index-CpCIXObe.d.ts.map
+//# sourceMappingURL=index-CRsmcAGl.d.ts.map

package/dist/{index-CpCIXObe.d.ts.map → index-CRsmcAGl.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-CpCIXObe.d.ts","names":[],"sources":["../src/contract/measured-comparison.ts","../src/contract/profile-measured-comparison.ts","../src/contract/intake/run-record-dir.ts","../src/contract/eval-reporting-suite.ts","../src/contract/intake/agent-trace.ts","../src/contract/intake/code-agent-observation.ts","../src/contract/intake/code-agent-session.ts","../src/contract/intake/code-agent-store.ts","../src/contract/intake/feedback-table.ts","../src/contract/intake/otel-spans.ts"],"mappings":";;;;;;;;;;;;UAiCiB;EACf,QAAQ,gCAAgC;EACxC;EACA;;UAGe;EACf,YAAY;EACZ;EACA,QAAQ;EACR,MAAM;EACN,eAAe;EACf;EACA,SAAS;;UAGM;EACf,YAAY;EACZ,QAAQ,OAAO,oCAAoC,QAAQ;;EAE3D;;EAEA,aAAa;EACb,SAAS;;UAGM;EACf,cAAc;EACd;IACE;IACA,MAAM;;;UAIO;EACf,YAAY;EACZ,cAAc;EACd;IACE;IACA,MAAM;;EAER,aAAa;EACb;EACA,YAAY;EACZ;EACA,WAAW;;;UAII,kBAAkB;EACjC;EACA,UAAU;EACV,WAAW;;;UAII,yBAAyB;EACxC,MAAM,KAAK;EACX,WAAW,KAAK;IAAkB;IAAc;;EAChD,QAAQ,KAAK;EACb,eAAe,KAAK,OAAO;EAC3B,UAAU,KAAK;EACf,UAAU,KAAK;EACf,OAAO,KAAK;;UAGG,kCAAkC;EACjD,uBAAuB,kBAAkB;EACzC,QAAQ;EACR,SAAS,yBAAyB;;EAElC;;EAEA,kBAAkB;;EAElB,kBAAkB;;;KAIR,8BAA8B,KACxC;EAGA,iBAAiB;EACjB,WAAW;EACX;;;iBAIc,2BACd,UAAU,sCACT;;iBAQa,4BACd,SAAS,qCACR;;iBAiBa,wBACd,UAAU,mCACT;iBAQa,0BAA0B,iBAAiB;;iBAarC,uBACpB,SAAS,gCACR,QAAQ;;;;;;;;iBAkEK,2BAA2B,MACzC,SAAS,kCAAkC,QAC1C;;iBA8Ya,0CACd,SAAS,oCACR;;iBAuEa,oCACd,iBACC;;;UCjrBc;EACf,aAAa;EACb,QAAQ,gCAAgC;EACxC;EACA;;UAGe;EACf,YAAY;EACZ;EACA,aAAa;EACb,MAAM;EACN,SAAS;EACT;EACA,SAAS;;UAGM;EACf,YAAY;EACZ,QACE,OAAO,kDACN,QAAQ;;EAEX;;EAEA,aAAa;EACb,SAAS;;UAGM;EACf,cAAc;EACd;IACE;IACA,MAAM;;;UAIO;EACf,YAAY;EACZ,cAAc;EACd;IACE;IACA,MAAM;;EAER,aAAa;EACb;EACA,YAAY;EACZ;EACA,WAAW;;;iBAIG,gCACd,UAAU,sCACT;;iBAQa,iCACd,SAAS,0CACR;;iBAqBa,sCACd,UAAU,4CACT;;;;;;iBAsBmB,qCACpB,SAAS,8CACR,QAAQ;;iBA0CK,wDACd,SAAS,kDACR;;iBAuEa,kDACd,iBACC;;;;UC7Oc;;EAEf;;EAEA;;EAEA;;UAGe;;;;;;EAMf;;;;;;;EAOA,WAAW;;;;;;EAMX;;UAGe;;EAEf,MAAM;;EAEN,UAAU;;EAEV;;;;;;;;;;iBAkBoB,iBACpB,cACA,UAAS,0BACR,QAAQ;;;;;KC7CC,0BAA0B;UAErB;;;;;EAKf,UAAU,KAAK;;EAEf,OAAO;;;;;;;;;;EAUP;;;;UAKe;;;EAGf,QAAQ;;EAER;;IAEE;;IAEA;;;IAGA;;IAEA;;;IAGA,UAAU;;;EAGZ;;;;;;;iBAUoB,mBACpB,OAAO,yBACP,UAAS,4BACR,QAAQ;;;KChEC;UAEK;EACf,MAAM;;EAEN;;UAGe;EACf;EACA;EACA;;;EAGA,cAAc;;UAGC;EACf;EACA,cAAc;EACd,QAAQ;;UAGO;EACf;EACA,eAAe;;UAGA;EACf;EACA;EACA;EACA;IAAQ;IAAc;;EACtB;IAAS;IAAe;;EACxB,OAAO;;;;UAOQ;EACf;;EAEA;;EAEA;EACA;EACA;;EAEA;;EAEA;;KAGU,kBAAkB,YAAY;;;;;;iBAW1B,gBAAgB,SAAS,qBAAqB;UAmE7C;;;;EAIf,SAAS,YAAY;;;EAGrB,cAAc;;;;;;;;iBASA,8BACd,MAAM,aACN,OAAO,kBACN;;;KCjLS;KAEA;KAEA;KAEA;KASA;UAEK;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA,MAAM;EACN,SAAS;EACT;EACA,QAAQ;EACR;EACA;EACA,UAAU;;UAGK;EACf,QAAQ;EACR;EACA;EACA;IACE,QAAQ;IACR;;EAEF,SAAS;;UAGM;EACf,QAAQ;EACR;EACA;EACA,YAAY;;;;;;;iBAeE,wBACd,SAAS,iCACR;;;UCjCc;EACf;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf,QAAQ;EACR;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,WAAW;EACX;;UAGe;EACf,MAAM;EACN,aAAa;EACb,SAAS;EACT,cAAc;;UAGC;EACf;EACA;EACA;EACA;EACA;EACA;EACA,WAAW;EACX;EACA;EACA;EACA;EACA;EACA;;;EAGA,iBAAiB;;;EAGjB,YAAY;;;;KAKF;EACN;EAAe;EAAoB;;EACnC;EAAmB;;iBAcT,oBAAoB,gBAAgB;;;;;;;;;;iBAuB7B,yBAAyB,eAAe,eAAe;;;;;iBA6BxD,wBAAwB,eAAe,QAAQ;iBAUrD,iBACd,SAAS,gCACR;iBAIa,sBACd,SAAS,gCACR;iBAIa,oBACd,SAAS,gCACR;iBAIa,oBACd,SAAS,gCACR;iBAIa,cACd,SAAS,gCACR;;;;UC/Lc;;;;;WAKN;;WAEA,QAAQ;;;;;WAKR;;;;;WAKA;aACE;;aAEA;;;;KAKD;;UAUK;WACN;WACA;WACA;WACA;WACA,aAAa;;;UAIP;WACN;WACA,UAAU,SAAS,QAAQ,OAAO;;WAElC,QAAQ;aACN;aACA,QAAQ;;;;;;;;;KAUT;WAEG;WACA,OAAO;WACP;WACA,mBAAmB;;WAEnB;;WAEA;;WAEA;WACA,WAAW,SAAS,QAAQ,OAAO;WACnC,YAAY;;WAGZ;WACA,OAAO;WACP;;WAEA;WACA,YAAY;;;;;;;;;iBAaL,sBACpB,OAAO,sBACN,QAAQ;;;UCtHM;;;EAGf;;EAEA;;;EAGA;;;EAGA,WAAW;;UAGI;EACf;;;EAGA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,WAAW;;;EAGX,SAAS;;UAGM;;EAEf,SAAS;;;EAGT,OAAO;;;;EAIP;IAAU;IAAa;;;;;EAIvB;;UAGe;EACf,MAAM;;;EAGN,aAAa;IAAQ;IAAe;IAAe;;;iBAGrC,kBAAkB,MAAM,2BAA2B;;;UC3BlD;EACf,OAAO;;EAEP,eAAe;;EAEf;;;;;;EAMA,eAAe,eAAe,gBAAgB;;iBAGhC,cAAc,MAAM,uBAAuB"}
+{"version":3,"file":"index-CRsmcAGl.d.ts","names":[],"sources":["../src/contract/measured-comparison.ts","../src/contract/profile-measured-comparison.ts","../src/contract/intake/run-record-dir.ts","../src/contract/eval-reporting-suite.ts","../src/contract/intake/agent-trace.ts","../src/contract/intake/code-agent-observation.ts","../src/contract/intake/code-agent-session.ts","../src/contract/intake/code-agent-store.ts","../src/contract/intake/feedback-table.ts","../src/contract/intake/otel-spans.ts"],"mappings":"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"}

package/dist/{index-CigojbNH.d.ts → index-DJKZEldg.d.ts}

@@ -2934,10 +2934,17 @@ interface ExternalSearchRecordInput {
  * GEPA's choice as the selected node, and the close. GEPA's own selection is a
  * budget decision, so the ledger carries no claim; the final comparison runs
  * outside this search.
+ *
+ * A composed recipe reports no population: pass `population: null` and GEPA's
+ * returned best as `selected`, and every evaluated candidate enters with an
+ * `unknown` edge, as SkillOpt's do.
  */
-declare function recordGepaSearch(input: ExternalSearchRecordInput & {
+declare function recordGepaSearch(input: ExternalSearchRecordInput & ({
   population: GepaCandidatePopulationArtifact;
-}): Promise<SearchHistoryReceipt>;
+} | {
+  population: null;
+  selected: MutableSurface;
+})): Promise<SearchHistoryReceipt>;
 /**
  * Write SkillOpt's finished search into its ledger: the baseline as the seeded
  * root, every candidate SkillOpt evaluated as a node with an `unknown` edge
@@ -4053,6 +4060,27 @@ declare function searchDivergence(state: SearchStateView, nodeId: string): {
   reason: string;
 } | null;
 //#endregion
+//#region src/campaign/search-campaign-cell.d.ts
+/**
+ * What `cell-settled` records for one campaign cell: `passed` with the
+ * composite (and each judge's) when every judge scored it, else `errored`,
+ * never retryable, because `runCampaign` already applied its own retry policy;
+ * its tokens and cost, with an uncaptured cost kept as a lower bound; the
+ * model the cell resolved, else the declared one.
+ */
+declare function campaignCellSearchResult<TArtifact>(cell: CampaignCellResult<TArtifact>, input: {
+  execution: SearchExecutionIdentity;
+  lane: string;
+}): SearchCellResult;
+/** A provider-reported model: a snapshot when its name pins one, else a moving alias. */
+declare function searchModelIdentity(model: string, provider: string): SearchModelIdentity;
+/** The accounting of a proposal's cost receipts: token and dollar sums, each
+ * unknown (with the known dollars as a lower bound) when a receipt lacks it. */
+declare function searchReceiptAccounting(receipts: ReadonlyArray<CostReceipt>): SearchAttemptAccounting;
+/** What ran a proposal: a model when it made a paid call other than a judge's,
+ * else deterministic code. */
+declare function searchProposalExecution(receipts: ReadonlyArray<CostReceipt>, provider: string, source: SearchOperationRecordedEvent['execution']['source']): SearchOperationRecordedEvent['execution'];
+//#endregion
 //#region src/campaign/single-run-lock.d.ts
 /**
  * Single-run lock for evaluations that share one mutable environment.
@@ -4238,5 +4266,5 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 //#endregion
-export { scoreDiscrimination as $, SettleSearchCellInput as $a, OptimizationMethodRunOptions as $i, CrossSurfaceCandidateEvidence as $n, FinalEvidencePolicy as $o, verifyLoopProvenanceRecord as $r, createLlmCorrectnessChecker as $t, SearchExecutor as A, isTransientTransportFailure as Aa, GepaEngineOptions as Ai, LoadEvalFixtureScenariosOptions as An, OpenAutoPrOptions as Ao, SearchAllocationView as Ar, RunProfileMatrixOptions as At, searchExpansionIndex as B, SearchExpansion as Ba, ExternalTextOptimizerContext as Bi, estimateNode as Bn, CampaignRunPlanCell as Bo, LoopProvenanceBackend as Br, RuntimeEventLike as Bt, SingleRunLockOptions as C, ReferenceEquivalenceScenario as Ca, runCanaries as Ci, neutralizationGate as Cn, openSearchLedger as Co, CrossSurfaceTaskRow as Cr, renderScoreboardMarkdown as Ct, SearchArtifactCodec as D, LlmJudgeOptions as Da, SkillOptTrainerConfig as Di, EvalFixtureRunPlan as Dn, SearchLedgerConflictError as Do, buildTraceAnalystSurfaceDispatch as Dr, ProfileDispatchFn as Dt, SEARCH_KERNEL_SOURCE as E, LlmJudgeDimension as Ea, SkillOptRunnerCommand as Ei, EvalFixtureLoadOptions as En, validateSearchLedgerEvent as Eo, TraceAnalystScenario as Er, userStoryScoreboard as Et, SearchProposedChild as F, runImprovementLoop as Fa, gepaOptimizationMethod as Fi, planEvalFixtureRun as Fn, CampaignCellFailureReceipt as Fo, uniform as Fr, BackendIntegrityReport as Ft, SearchClaimPlan as G, AllocateSearchCellInput as Ga, CompareOptimizationMethodsOptions as Gi, AnalyzeCrossSurfaceInteractionsInput as Gn, readCachedCell as Go, buildLoopProvenanceRecord as Gr, CorrectnessChecker as Gt, PlanSearchClaimInput as H, SearchPolicyView as Ha, ExternalOptimizationExample as Hi, searchCellSetDigest as Hn, planCampaignRun as Ho, LoopProvenanceEvidence as Hr, extractProducedState as Ht, SearchProposerPort as I, PremeasuredOptimizationBaseline as Ia, OpenAICompatibleOptimizerModel as Ii, EstimateNodeCellsInput as In, CampaignCellRetryPolicy as Io, BuildLoopProvenanceArgs as Ir, assertRealBackend as It, planSearchClaim as J, SearchLedgerBinding as Ja, OptimizationMethodComposition as Ji, CrossSurfaceAttemptCompleteness as Jn, cellCachePath as Jo, emitLoopProvenance as Jr, ProducedState as Jt, SearchClaimVerification as K, RecordSearchEdgeInput as Ka, OptimizationMethod as Ki, CrossSurfaceAdditionDecision as Kn, CellScheduleSlot as Ko, campaignMeasurementDigest as Kr, LlmCorrectnessCheckerOpts as Kt, SearchRunResult as L, RunOptimizationOptions as La, OptimizerModelBudget as Li, NodePosterior as Ln, RunCampaignOptions as Lo, EmitLoopProvenanceArgs as Lr, summarizeBackendIntegrity as Lt, SearchProposalBlob as M, transientDispatchFailure as Ma, GepaOptimizationMethodConfig as Mi, discoverEvalFixtures as Mn, openAutoPr as Mo, SearchCellPlan as Mr, ScenarioRollup as Mt, SearchProposalRequest as N, RunImprovementLoopOptions as Na, GepaOptimizationRecipe as Ni, loadEvalFixture as Nn, RunEvalOptions as No, SearchRungDecision as Nr, runProfileMatrix as Nt, SearchCellResult as O, llmJudge as Oa, skillOptOptimizationMethod as Oi, EvalFixtureScenario as On, SearchLedgerError as Oo, traceAnalystQualityJudge as Or, ProfileMatrixError as Ot, SearchProposalResult as P, RunImprovementLoopResult as Pa, GepaRunnerCommand as Pi, loadEvalFixtureScenarios as Pn, runEval as Po, asha as Pr, BackendIntegrityError as Pt, ScenarioSignal as Q, SearchRunIdentity as Qa, OptimizationMethodResult as Qi, CrossSurfaceCandidateComparison as Qn, inMemoryCampaignStorage as Qo, provenanceSpansPath as Qr, completionVerdict as Qt, runSearch as R, RunOptimizationResult as Ra, externalTextOptimizationMethod as Ri, SEARCH_ESTIMATOR as Rn, runCampaign as Ro, EmitLoopProvenanceResult as Rr, ArtifactEventLike as Rt, SingleRunLock as S, ReferenceEquivalenceJudgeResult as Sa, CanaryReport as Si, NeutralizationGateOptions as Sn, SearchLedgerTrustedHeadMode as So, CrossSurfaceSelections as Sr, makePlaybackDispatch as St, RunSearchOptions as T, runReferenceEquivalenceJudge as Ta, SkillOptOptimizationMethodConfig as Ti, EvalFixtureFile as Tn, replaySearchLedgerText as To, TraceAnalystArtifact as Tr, scoreboardSummary as Tt, SEARCH_CLAIM_RULE as U, crowdedFrontierParent as Ua, ExternalTextEvaluationResponse as Ui, searchPosterior as Un, CacheIssueReason as Uo, LoopProvenanceOptimizationMethod as Ur, CompletionRequirement as Ut, searchPolicyView as V, SearchPolicy as Va, ExternalTextOptimizerResult as Vi, estimateNodeFromCells as Vn, PlanCampaignRunOptions as Vo, LoopProvenanceCandidate as Vr, ToolCallEventLike as Vt, SearchClaimDecision as W, incumbent as Wa, decodeExternalTextCandidate as Wi, analyzeCrossSurfaceInteractions as Wn, CacheRead as Wo, LoopProvenanceRecord as Wr, CompletionVerdict as Wt, verifySearchClaim as X, SearchRecorder as Xa, OptimizationMethodPairwise as Xi, CrossSurfaceBootstrapPolicy as Xn, createRunCostLedger as Xo, loopProvenanceSpans as Xr, SatisfiedBy as Xt, searchClaimReserveUsd as Y, SearchOpening as Ya, OptimizationMethodInput as Yi, CrossSurfaceBestSingleSelection as Yn, CampaignStorage as Yo, loopProvenanceArgsFromResult as Yr, RequirementCheck as Yt, DiscriminationScore as Z, SearchRecorderOptions as Za, OptimizationMethodProvenance as Zi, CrossSurfaceCandidate as Zn, fsCampaignStorage as Zo, provenanceRecordPath as Zr, TaskGold as Zt, componentSurfaceIdentityMaterial as _, readExternalOptimizerObservationArtifact as _a, scoreRedTeamOutput as _i, externalSurface as _n, verifySearchHistoryReceipt as _o, CrossSurfacePairIncompatibilityReason as _r, ScoreboardRenderOptions as _t, WorktreeAdapterError as a, ComparisonCost as aa, heldOutGate as ai, FsLabeledScenarioStoreOptions as an, SearchHistoryAdmissionOptions as ao, CrossSurfaceDistribution as ar, campaignSplitDigestFromIdentities as as, FinalizedProfileMatrixResult as at, surfaceDispatchRef as b, ReferenceEquivalenceJudgeInput as ba, CanaryKind as bi, recordGepaSearch as bn, SearchLedger as bo, CrossSurfaceRelativeCost as br, UserStory as bt, verifyCodeSurface as c, GepaCandidatePopulationArtifact as ca, DefaultProductionRewardHackingOptions as ci, RolloutArgumentDiffOptions as cn, SearchHistoryCoverageRow as co, CrossSurfaceIneligibilityReason as cr, ProfileMatrixRow as ct, PhoenixEvaluationResultLike as d, GepaCandidateSelectionScore as da, RedTeamCase as di, UngroundedLiteralReport as dn, SearchHistoryRequiredError as do, CrossSurfaceInteractionPath as dr, createProfileMatrixPlan as dt, OptimizationMethodScore as ea, CampaignBreakdown as ei, verifyCompletion as en, developmentClaim as eo, CrossSurfaceCandidateOutcome as er, FinalEvidenceUse as es, selectDiscriminative as et, PhoenixEvaluatorLike as f, readGepaCandidatePopulationArtifact as fa, RedTeamCategory as fi, classifyUngroundedLiterals as fn, assertCompleteSearchHistory as fo, CrossSurfaceInteractionReport as fr, finalizeProfileMatrix as ft, codeSurfaceIdentityMaterial as g, ExternalOptimizerSubmittedCandidate as ga, redTeamReport as gi, GepaPopulationImport as gn, verifySearchHistoryArtifact as go, CrossSurfacePairEvidence as gr, PlaybackStep as gt, assertCodeSurfaceIdentity as h, ExternalOptimizerObservationSummary as ha, redTeamDataset as hi, GepaEvaluationImport as hn, searchHistoryCoverageRow as ho, CrossSurfacePairCompatibility as hr, PlaybackDriver as ht, WorktreeAdapter as i, optimizationTokenUsageFromSummary as ia, HeldOutGateOptions as ii, FsLabeledScenarioStore as in, CreateSearchHistoryReceiptInput as io, CrossSurfaceCompositionStep as ir, campaignSplitDigest as is, FinalizeProfileMatrixOptions as it, SearchLane as j, quotaExhaustedUntil as ja, GepaEngineRun as ji, PlanEvalFixtureRunOptions as jn, OpenAutoPrResult as jo, SearchAllocator as jr, RunProfileMatrixResult as jt, SearchCellWork as k, TransientFailureOptions as ka, GepaAdaptiveEngineRun as ki, EvalFixtureValidationMode as kn, SearchLedgerIntegrityError as ko, AshaOptions as kr, ProfileSummary as kt, AutoevalsScoreLike as l, GepaCandidatePopulationCandidate as la, defaultProductionGate as li, RolloutCall as ln, SearchHistoryPolicy as lo, CrossSurfaceInteractionAwareSelection as lr, ProfileMatrixSegmentResult as lt, phoenixEvaluatorJudge as m, ExternalOptimizerObservationArtifact as ma, RedTeamReport as mi, ExternalSearchOptimizer as mn, createSearchHistoryReceipt as mo, CrossSurfaceNaiveStackSelection as mr, PlaybackContext as mt, GitWorktreeAdapterOptions as n, OptimizationTokenUsage as na, campaignBreakdown as ni, sequentialOptimizationMethod as nn, surfaceDiff as no, CrossSurfaceComponent as nr, assertCampaignSplitIdentity as ns, tangleTracesRoot as nt, gitWorktreeAdapter as o, combineComparisonCosts as oa, DefaultProductionGateCheck as oi, LabeledScenarioStoreError as on, SearchHistoryAuditSummary as oo, CrossSurfaceEligibility as or, ProfileMatrixCoverage as ot, autoevalsScorerJudge as p, ExternalOptimizerExecutionSummary as pa, RedTeamFinding as pi, rolloutArgumentDiff as pn, assertSearchHistoryMatchesState as po, CrossSurfaceInteractionTask as pr, runProfileMatrixSegment as pt, decideSearchClaim as q, RegisterSearchNodeInput as qa, OptimizationMethodComparison as qi, CrossSurfaceAdditionRejectionReason as qn, buildCellSchedule as qo, canonicalDigest as qr, ProducedProposal as qt, Worktree as r, compareOptimizationMethods as ra, campaignMeanComposite as ri, neutralizeText as rn, surfaceNode as ro, CrossSurfaceComponentEvidence as rr, campaignScenarioIdentity as rs, CreateProfileMatrixPlanOptions as rt, resolveWorktreePath as s, costFromLedgerSummary as sa, DefaultProductionGateOptions as si, RolloutArgumentDiff as sn, SearchHistoryCoverage as so, CrossSurfaceEvidenceBreakdown as sr, ProfileMatrixPlan as st, CodeSurfaceVerification as t, OptimizationPackageSource as ta, CampaignComparisonUnits as ti, scopedOptimizationMethod as tn, searchEdgeId as to, CrossSurfaceCandidateSummary as tr, assertCampaignDesign as ts, resolveRunDir as tt, AutoevalsScorerLike as u, GepaCandidatePopulationSummary as ua, DEFAULT_RED_TEAM_CORPUS as ui, ScoredRollout as un, SearchHistoryReceipt as uo, CrossSurfaceInteractionEffect as ur, RunProfileMatrixSegmentOptions as ut, renderSurfaceDiff as v, REFERENCE_EQUIVALENCE_INPUT_LIMITS as va, CanaryAlert as vi, importExternalEvaluations as vn, FileSearchLedger as vo, CrossSurfacePairwiseEntry as vr, ScoreboardRow as vt, acquireSingleRunLock as w, createReferenceEquivalenceJudge as wa, composeGate as wi, EvalFixture as wn, parseSearchLedgerLine as wo, BuildTraceAnalystSurfaceDispatchOptions as wr, scoreUserStory as wt, surfaceHash as x, ReferenceEquivalenceJudgeOptions as xa, CanaryOptions as xi, recordSkillOptSearch as xn, SearchLedgerAppendResult as xo, CrossSurfaceSelectionPolicy as xr, UserStoryVerdict as xt, surfaceContentHash as y, REFERENCE_EQUIVALENCE_JUDGE_VERSION as ya, CanaryEvaluation as yi, importGepaPopulation as yn, OpenSearchLedgerOptions as yo, CrossSurfaceRankedSingle as yr, ScoreboardSummary as yt, searchDivergence as z, runOptimization as za, ExternalTextOptimizationMethodConfig as zi, SearchPosterior as zn, CampaignRunPlan as zo, LoopProvenanceArgsFromResult as zr, ProposalEventLike as zt };
-//# sourceMappingURL=index-CigojbNH.d.ts.map
+export { searchClaimReserveUsd as $, SearchOpening as $a, OptimizationMethodInput as $i, CrossSurfaceBestSingleSelection as $n, CampaignStorage as $o, loopProvenanceArgsFromResult as $r, RequirementCheck as $t, SEARCH_KERNEL_SOURCE as A, LlmJudgeDimension as Aa, SkillOptRunnerCommand as Ai, EvalFixtureLoadOptions as An, validateSearchLedgerEvent as Ao, TraceAnalystScenario as Ar, userStoryScoreboard as At, SearchProposerPort as B, PremeasuredOptimizationBaseline as Ba, OpenAICompatibleOptimizerModel as Bi, EstimateNodeCellsInput as Bn, CampaignCellRetryPolicy as Bo, BuildLoopProvenanceArgs as Br, assertRealBackend as Bt, SingleRunLockOptions as C, REFERENCE_EQUIVALENCE_JUDGE_VERSION as Ca, CanaryEvaluation as Ci, importGepaPopulation as Cn, OpenSearchLedgerOptions as Co, CrossSurfaceRankedSingle as Cr, ScoreboardSummary as Ct, searchProposalExecution as D, ReferenceEquivalenceScenario as Da, runCanaries as Di, neutralizationGate as Dn, openSearchLedger as Do, CrossSurfaceTaskRow as Dr, renderScoreboardMarkdown as Dt, searchModelIdentity as E, ReferenceEquivalenceJudgeResult as Ea, CanaryReport as Ei, NeutralizationGateOptions as En, SearchLedgerTrustedHeadMode as Eo, CrossSurfaceSelections as Er, makePlaybackDispatch as Et, SearchLane as F, quotaExhaustedUntil as Fa, GepaEngineRun as Fi, PlanEvalFixtureRunOptions as Fn, OpenAutoPrResult as Fo, SearchAllocator as Fr, RunProfileMatrixResult as Ft, searchPolicyView as G, SearchPolicy as Ga, ExternalTextOptimizerResult as Gi, estimateNodeFromCells as Gn, PlanCampaignRunOptions as Go, LoopProvenanceCandidate as Gr, ToolCallEventLike as Gt, runSearch as H, RunOptimizationResult as Ha, externalTextOptimizationMethod as Hi, SEARCH_ESTIMATOR as Hn, runCampaign as Ho, EmitLoopProvenanceResult as Hr, ArtifactEventLike as Ht, SearchProposalBlob as I, transientDispatchFailure as Ia, GepaOptimizationMethodConfig as Ii, discoverEvalFixtures as In, openAutoPr as Io, SearchCellPlan as Ir, ScenarioRollup as It, SearchClaimDecision as J, incumbent as Ja, decodeExternalTextCandidate as Ji, analyzeCrossSurfaceInteractions as Jn, CacheRead as Jo, LoopProvenanceRecord as Jr, CompletionVerdict as Jt, PlanSearchClaimInput as K, SearchPolicyView as Ka, ExternalOptimizationExample as Ki, searchCellSetDigest as Kn, planCampaignRun as Ko, LoopProvenanceEvidence as Kr, extractProducedState as Kt, SearchProposalRequest as L, RunImprovementLoopOptions as La, GepaOptimizationRecipe as Li, loadEvalFixture as Ln, RunEvalOptions as Lo, SearchRungDecision as Lr, runProfileMatrix as Lt, SearchCellResult as M, llmJudge as Ma, skillOptOptimizationMethod as Mi, EvalFixtureScenario as Mn, SearchLedgerError as Mo, traceAnalystQualityJudge as Mr, ProfileMatrixError as Mt, SearchCellWork as N, TransientFailureOptions as Na, GepaAdaptiveEngineRun as Ni, EvalFixtureValidationMode as Nn, SearchLedgerIntegrityError as No, AshaOptions as Nr, ProfileSummary as Nt, searchReceiptAccounting as O, createReferenceEquivalenceJudge as Oa, composeGate as Oi, EvalFixture as On, parseSearchLedgerLine as Oo, BuildTraceAnalystSurfaceDispatchOptions as Or, scoreUserStory as Ot, SearchExecutor as P, isTransientTransportFailure as Pa, GepaEngineOptions as Pi, LoadEvalFixtureScenariosOptions as Pn, OpenAutoPrOptions as Po, SearchAllocationView as Pr, RunProfileMatrixOptions as Pt, planSearchClaim as Q, SearchLedgerBinding as Qa, OptimizationMethodComposition as Qi, CrossSurfaceAttemptCompleteness as Qn, cellCachePath as Qo, emitLoopProvenance as Qr, ProducedState as Qt, SearchProposalResult as R, RunImprovementLoopResult as Ra, GepaRunnerCommand as Ri, loadEvalFixtureScenarios as Rn, runEval as Ro, asha as Rr, BackendIntegrityError as Rt, SingleRunLock as S, REFERENCE_EQUIVALENCE_INPUT_LIMITS as Sa, CanaryAlert as Si, importExternalEvaluations as Sn, FileSearchLedger as So, CrossSurfacePairwiseEntry as Sr, ScoreboardRow as St, campaignCellSearchResult as T, ReferenceEquivalenceJudgeOptions as Ta, CanaryOptions as Ti, recordSkillOptSearch as Tn, SearchLedgerAppendResult as To, CrossSurfaceSelectionPolicy as Tr, UserStoryVerdict as Tt, searchDivergence as U, runOptimization as Ua, ExternalTextOptimizationMethodConfig as Ui, SearchPosterior as Un, CampaignRunPlan as Uo, LoopProvenanceArgsFromResult as Ur, ProposalEventLike as Ut, SearchRunResult as V, RunOptimizationOptions as Va, OptimizerModelBudget as Vi, NodePosterior as Vn, RunCampaignOptions as Vo, EmitLoopProvenanceArgs as Vr, summarizeBackendIntegrity as Vt, searchExpansionIndex as W, SearchExpansion as Wa, ExternalTextOptimizerContext as Wi, estimateNode as Wn, CampaignRunPlanCell as Wo, LoopProvenanceBackend as Wr, RuntimeEventLike as Wt, SearchClaimVerification as X, RecordSearchEdgeInput as Xa, OptimizationMethod as Xi, CrossSurfaceAdditionDecision as Xn, CellScheduleSlot as Xo, campaignMeasurementDigest as Xr, LlmCorrectnessCheckerOpts as Xt, SearchClaimPlan as Y, AllocateSearchCellInput as Ya, CompareOptimizationMethodsOptions as Yi, AnalyzeCrossSurfaceInteractionsInput as Yn, readCachedCell as Yo, buildLoopProvenanceRecord as Yr, CorrectnessChecker as Yt, decideSearchClaim as Z, RegisterSearchNodeInput as Za, OptimizationMethodComparison as Zi, CrossSurfaceAdditionRejectionReason as Zn, buildCellSchedule as Zo, canonicalDigest as Zr, ProducedProposal as Zt, componentSurfaceIdentityMaterial as _, ExternalOptimizerExecutionSummary as _a, RedTeamFinding as _i, rolloutArgumentDiff as _n, assertSearchHistoryMatchesState as _o, CrossSurfaceInteractionTask as _r, runProfileMatrixSegment as _t, WorktreeAdapterError as a, OptimizationPackageSource as aa, CampaignComparisonUnits as ai, scopedOptimizationMethod as an, searchEdgeId as ao, CrossSurfaceCandidateSummary as ar, assertCampaignDesign as as, resolveRunDir as at, surfaceDispatchRef as b, ExternalOptimizerSubmittedCandidate as ba, redTeamReport as bi, GepaPopulationImport as bn, verifySearchHistoryArtifact as bo, CrossSurfacePairEvidence as br, PlaybackStep as bt, verifyCodeSurface as c, optimizationTokenUsageFromSummary as ca, HeldOutGateOptions as ci, FsLabeledScenarioStore as cn, CreateSearchHistoryReceiptInput as co, CrossSurfaceCompositionStep as cr, campaignSplitDigest as cs, FinalizeProfileMatrixOptions as ct, PhoenixEvaluationResultLike as d, costFromLedgerSummary as da, DefaultProductionGateOptions as di, RolloutArgumentDiff as dn, SearchHistoryCoverage as do, CrossSurfaceEvidenceBreakdown as dr, ProfileMatrixPlan as dt, OptimizationMethodPairwise as ea, loopProvenanceSpans as ei, SatisfiedBy as en, SearchRecorder as eo, CrossSurfaceBootstrapPolicy as er, createRunCostLedger as es, verifySearchClaim as et, PhoenixEvaluatorLike as f, GepaCandidatePopulationArtifact as fa, DefaultProductionRewardHackingOptions as fi, RolloutArgumentDiffOptions as fn, SearchHistoryCoverageRow as fo, CrossSurfaceIneligibilityReason as fr, ProfileMatrixRow as ft, codeSurfaceIdentityMaterial as g, readGepaCandidatePopulationArtifact as ga, RedTeamCategory as gi, classifyUngroundedLiterals as gn, assertCompleteSearchHistory as go, CrossSurfaceInteractionReport as gr, finalizeProfileMatrix as gt, assertCodeSurfaceIdentity as h, GepaCandidateSelectionScore as ha, RedTeamCase as hi, UngroundedLiteralReport as hn, SearchHistoryRequiredError as ho, CrossSurfaceInteractionPath as hr, createProfileMatrixPlan as ht, WorktreeAdapter as i, OptimizationMethodScore as ia, CampaignBreakdown as ii, verifyCompletion as in, developmentClaim as io, CrossSurfaceCandidateOutcome as ir, FinalEvidenceUse as is, selectDiscriminative as it, SearchArtifactCodec as j, LlmJudgeOptions as ja, SkillOptTrainerConfig as ji, EvalFixtureRunPlan as jn, SearchLedgerConflictError as jo, buildTraceAnalystSurfaceDispatch as jr, ProfileDispatchFn as jt, RunSearchOptions as k, runReferenceEquivalenceJudge as ka, SkillOptOptimizationMethodConfig as ki, EvalFixtureFile as kn, replaySearchLedgerText as ko, TraceAnalystArtifact as kr, scoreboardSummary as kt, AutoevalsScoreLike as l, ComparisonCost as la, heldOutGate as li, FsLabeledScenarioStoreOptions as ln, SearchHistoryAdmissionOptions as lo, CrossSurfaceDistribution as lr, campaignSplitDigestFromIdentities as ls, FinalizedProfileMatrixResult as lt, phoenixEvaluatorJudge as m, GepaCandidatePopulationSummary as ma, DEFAULT_RED_TEAM_CORPUS as mi, ScoredRollout as mn, SearchHistoryReceipt as mo, CrossSurfaceInteractionEffect as mr, RunProfileMatrixSegmentOptions as mt, GitWorktreeAdapterOptions as n, OptimizationMethodResult as na, provenanceSpansPath as ni, completionVerdict as nn, SearchRunIdentity as no, CrossSurfaceCandidateComparison as nr, inMemoryCampaignStorage as ns, ScenarioSignal as nt, gitWorktreeAdapter as o, OptimizationTokenUsage as oa, campaignBreakdown as oi, sequentialOptimizationMethod as on, surfaceDiff as oo, CrossSurfaceComponent as or, assertCampaignSplitIdentity as os, tangleTracesRoot as ot, autoevalsScorerJudge as p, GepaCandidatePopulationCandidate as pa, defaultProductionGate as pi, RolloutCall as pn, SearchHistoryPolicy as po, CrossSurfaceInteractionAwareSelection as pr, ProfileMatrixSegmentResult as pt, SEARCH_CLAIM_RULE as q, crowdedFrontierParent as qa, ExternalTextEvaluationResponse as qi, searchPosterior as qn, CacheIssueReason as qo, LoopProvenanceOptimizationMethod as qr, CompletionRequirement as qt, Worktree as r, OptimizationMethodRunOptions as ra, verifyLoopProvenanceRecord as ri, createLlmCorrectnessChecker as rn, SettleSearchCellInput as ro, CrossSurfaceCandidateEvidence as rr, FinalEvidencePolicy as rs, scoreDiscrimination as rt, resolveWorktreePath as s, compareOptimizationMethods as sa, campaignMeanComposite as si, neutralizeText as sn, surfaceNode as so, CrossSurfaceComponentEvidence as sr, campaignScenarioIdentity as ss, CreateProfileMatrixPlanOptions as st, CodeSurfaceVerification as t, OptimizationMethodProvenance as ta, provenanceRecordPath as ti, TaskGold as tn, SearchRecorderOptions as to, CrossSurfaceCandidate as tr, fsCampaignStorage as ts, DiscriminationScore as tt, AutoevalsScorerLike as u, combineComparisonCosts as ua, DefaultProductionGateCheck as ui, LabeledScenarioStoreError as un, SearchHistoryAuditSummary as uo, CrossSurfaceEligibility as ur, ProfileMatrixCoverage as ut, renderSurfaceDiff as v, ExternalOptimizerObservationArtifact as va, RedTeamReport as vi, ExternalSearchOptimizer as vn, createSearchHistoryReceipt as vo, CrossSurfaceNaiveStackSelection as vr, PlaybackContext as vt, acquireSingleRunLock as w, ReferenceEquivalenceJudgeInput as wa, CanaryKind as wi, recordGepaSearch as wn, SearchLedger as wo, CrossSurfaceRelativeCost as wr, UserStory as wt, surfaceHash as x, readExternalOptimizerObservationArtifact as xa, scoreRedTeamOutput as xi, externalSurface as xn, verifySearchHistoryReceipt as xo, CrossSurfacePairIncompatibilityReason as xr, ScoreboardRenderOptions as xt, surfaceContentHash as y, ExternalOptimizerObservationSummary as ya, redTeamDataset as yi, GepaEvaluationImport as yn, searchHistoryCoverageRow as yo, CrossSurfacePairCompatibility as yr, PlaybackDriver as yt, SearchProposedChild as z, runImprovementLoop as za, gepaOptimizationMethod as zi, planEvalFixtureRun as zn, CampaignCellFailureReceipt as zo, uniform as zr, BackendIntegrityReport as zt };
+//# sourceMappingURL=index-DJKZEldg.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DJKZEldg.d.ts","names":[],"sources":["../src/campaign/coverage.ts","../src/campaign/final-evidence.ts","../src/campaign/storage.ts","../src/campaign/cell-schedule.ts","../src/campaign/cell-cache.ts","../src/campaign/plan-campaign-run.ts","../src/campaign/run-campaign.ts","../src/campaign/presets/run-eval.ts","../src/campaign/auto-pr.ts","../src/campaign/search-ledger-errors.ts","../src/campaign/search-ledger.ts","../src/campaign/search-history-receipt.ts","../src/campaign/search-ledger-recording.ts","../src/campaign/search-policy.ts","../src/campaign/presets/run-optimization.ts","../src/campaign/presets/run-improvement-loop.ts","../src/campaign/transient-failure.ts","../src/llm-judge.ts","../src/reference-equivalence-judge.ts","../src/campaign/external-optimizer-observations.ts","../src/campaign/gepa-candidate-population.ts","../src/campaign/optimization-cost.ts","../src/campaign/presets/compare-optimization-methods.ts","../src/campaign/external-text-evaluation.ts","../src/campaign/external-text-optimization-contract.ts","../src/campaign/external-text-optimization.ts","../src/campaign/optimizer-model.ts","../src/campaign/gepa-optimization-method.ts","../src/campaign/skillopt-optimization-method.ts","../src/campaign/gates/compose.ts","../src/canary.ts","../src/red-team.ts","../src/campaign/gates/default-production-gate.ts","../src/campaign/gates/heldout-gate.ts","../src/campaign/score-utils.ts","../src/campaign/provenance.ts","../src/campaign/allocation.ts","../src/campaign/analyst-surface.ts","../src/campaign/cross-surface-types.ts","../src/campaign/cross-surface-interaction.ts","../src/campaign/estimate-node.ts","../src/campaign/fixtures.ts","../src/campaign/gates/neutralization-gate.ts","../src/campaign/gepa-search-import.ts","../src/campaign/grounded-reflection.ts","../src/campaign/labeled-store/fs-adapter.ts","../src/campaign/neutralize.ts","../src/campaign/optimization-method-composition.ts","../src/artifact-validator.ts","../src/completion-verifier.ts","../src/produced-state.ts","../src/integrity/backend-integrity.ts","../src/campaign/presets/run-profile-matrix.ts","../src/campaign/presets/playback.ts","../src/campaign/presets/segmented-profile-matrix.ts","../src/campaign/run-dir.ts","../src/campaign/scenario-selection.ts","../src/campaign/search-claim.ts","../src/campaign/search-kernel.ts","../src/campaign/search-campaign-cell.ts","../src/campaign/single-run-lock.ts","../src/campaign/surface-identity.ts","../src/campaign/upstream-evaluators.ts","../src/campaign/worktree/index.ts"],"mappings":"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"}

package/dist/index.d.ts

@@ -17,7 +17,7 @@ import { a as RunFilter, i as InMemoryTraceStore, n as FileSystemTraceStore, o a
 import { a as MintedRolloutLine } from "./schema-B5LtYvn9.js";
 import { a as mintRolloutRows, c as ScorePreference, i as RolloutSearchLineage, n as MintRolloutResult, t as MintRolloutOptions } from "./mint-C9Lojt1V.js";
 import { R as Scenario$1, S as JudgeConfig, _ as GateDecision, a as CampaignResult, w as JudgeScore$1 } from "./types-B2673PBj.js";
-import { $t as createLlmCorrectnessChecker, Bt as RuntimeEventLike, Ci as runCanaries, Da as LlmJudgeOptions, Fo as CampaignCellFailureReceipt, Ft as BackendIntegrityReport, Gt as CorrectnessChecker, Ht as extractProducedState, Io as CampaignCellRetryPolicy, It as assertRealBackend, Jt as ProducedState, Kt as LlmCorrectnessCheckerOpts, Lo as RunCampaignOptions, Lt as summarizeBackendIntegrity, Ma as transientDispatchFailure, Oa as llmJudge, Pt as BackendIntegrityError, Qt as completionVerdict, Ro as runCampaign, Rt as ArtifactEventLike, Si as CanaryReport, Ut as CompletionRequirement, Vt as ToolCallEventLike, Wt as CompletionVerdict, Xt as SatisfiedBy, Yt as RequirementCheck, Zt as TaskGold, _i as scoreRedTeamOutput, bi as CanaryKind, di as RedTeamCase, en as verifyCompletion, fi as RedTeamCategory, gi as redTeamReport, hi as redTeamDataset, ja as quotaExhaustedUntil, mi as RedTeamReport, pi as RedTeamFinding, qt as ProducedProposal, ui as DEFAULT_RED_TEAM_CORPUS, vi as CanaryAlert, xi as CanaryOptions, yi as CanaryEvaluation, zt as ProposalEventLike } from "./index-CigojbNH.js";
+import { $t as RequirementCheck, Bo as CampaignCellRetryPolicy, Bt as assertRealBackend, Ci as CanaryEvaluation, Di as runCanaries, Ei as CanaryReport, Fa as quotaExhaustedUntil, Gt as ToolCallEventLike, Ho as runCampaign, Ht as ArtifactEventLike, Ia as transientDispatchFailure, Jt as CompletionVerdict, Kt as extractProducedState, Ma as llmJudge, Qt as ProducedState, Rt as BackendIntegrityError, Si as CanaryAlert, Ti as CanaryOptions, Ut as ProposalEventLike, Vo as RunCampaignOptions, Vt as summarizeBackendIntegrity, Wt as RuntimeEventLike, Xt as LlmCorrectnessCheckerOpts, Yt as CorrectnessChecker, Zt as ProducedProposal, _i as RedTeamFinding, bi as redTeamReport, en as SatisfiedBy, gi as RedTeamCategory, hi as RedTeamCase, in as verifyCompletion, ja as LlmJudgeOptions, mi as DEFAULT_RED_TEAM_CORPUS, nn as completionVerdict, qt as CompletionRequirement, rn as createLlmCorrectnessChecker, tn as TaskGold, vi as RedTeamReport, wi as CanaryKind, xi as scoreRedTeamOutput, yi as redTeamDataset, zo as CampaignCellFailureReceipt, zt as BackendIntegrityReport } from "./index-DJKZEldg.js";
 import { a as ProfileAxisSpec, c as expandProfileAxes, i as HarnessType, l as harnessAxisOf, n as CODING_HARNESSES, o as agentProfileHash, r as HARNESS_NATIVE_MODEL, s as agentProfileId, t as AgentProfile } from "./agent-profile-DDfIjdyS.js";
 import { i as DatasetSplit, n as DatasetManifest, r as DatasetScenario, t as Dataset } from "./dataset-DQqhOCPt.js";
 import { C as defineEquivalenceCheck, S as buildEquivalenceRecord, _ as StrategyChecker, a as CheckerIdentity, b as VerificationStrategyProfile, c as EquivalenceCheckDefinition, d as EquivalenceCheckerInput, f as EquivalenceCheckerResult, g as EquivalenceRecord, h as EquivalenceProtocolError, i as equivalenceVerdict, l as EquivalenceCheckSpec, m as EquivalenceObligationStatus, n as VerdictCertification, o as CheckerOutcome, p as EquivalenceObligation, r as certificationEvidenceDigest, s as EquivalenceArm, t as DefaultVerdict, u as EquivalenceChecker, v as VERIFICATION_STRATEGIES, w as runEquivalenceCheck, x as VerificationStrategySource, y as VERIFICATION_STRATEGY_SOURCES } from "./verdict-E4eRNf7-.js";
@@ -27,7 +27,7 @@ import { a as FAILURE_BLAME, c as FailureContext, d as INFRA_FAILURE_BLAMES, f a
 import { d as InsightReport, i as analyzeRuns, t as AnalyzeRunsOptions } from "./analyze-runs-CPiKLJFs.js";
 import { i as ExactAnalystRunEvent, l as ExactCapableAnalyst, o as ExactAnalystRunResult } from "./exact-types-KGxBWH4b.js";
 import { c as RegistryRunOpts, i as BudgetPolicy, n as AnalystRegistry, r as AnalystRegistryOptions, s as ExactRegistryRunOpts } from "./registry-Bu3lNole.js";
-import { _ as SelfImproveMethodResult, a as DefinedAgentEval, c as SelfImproveMethodOptions, d as SelfImproveProposerOptions, f as SelfImproveProposerResult, g as SelfImproveMethodProvenance, h as selfImprove, i as DefineAgentEvalOptions, l as SelfImproveOptions, n as AgentEvalEvaluateOptions, o as defineAgentEval, p as SelfImproveResult, r as AgentEvalImproveOptions, s as SelfImproveBudget, t as AgentEvalAgent, u as SelfImproveProgressEvent } from "./define-agent-eval-DwAaPvvH.js";
+import { _ as SelfImproveMethodResult, a as DefinedAgentEval, c as SelfImproveMethodOptions, d as SelfImproveProposerOptions, f as SelfImproveProposerResult, g as SelfImproveMethodProvenance, h as selfImprove, i as DefineAgentEvalOptions, l as SelfImproveOptions, n as AgentEvalEvaluateOptions, o as defineAgentEval, p as SelfImproveResult, r as AgentEvalImproveOptions, s as SelfImproveBudget, t as AgentEvalAgent, u as SelfImproveProgressEvent } from "./define-agent-eval-ulRlLvse.js";
 import { a as createTraceAnalyst, i as TraceAnalystDefinition, n as buildDefaultAnalystRegistry, r as CreateTraceAnalystOptions, t as DefaultAnalystRegistryOptions } from "./default-registry-D2csUBBQ.js";
 import { i as TraceAnalysisEngineResult, l as RawAnalystFinding, n as TraceAnalysisEngine, t as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS } from "./engine-De2hfuiQ.js";
 import { A as SemanticConceptJudgeInput, C as DspyRlmTraceEngineOptions, D as ConceptFinding, E as createChatTraceEngine, M as SemanticConceptJudgeResult, N as runSemanticConceptJudge, O as ConceptSpec, T as ChatTraceEngineOptions, _ as FindingSubject, a as FAILURE_MODE_KIND_SPEC, d as FindingsStore, f as PersistedFinding, j as SemanticConceptJudgeOptions, k as SEMANTIC_CONCEPT_JUDGE_VERSION, l as DiffPolicy, m as diffFindings, t as DEFAULT_TRACE_ANALYST_KINDS, u as FindingsDiff, v as FindingSubjectKind, w as createDspyRlmTraceEngine } from "./index-kKECJfib.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { i as JudgeError, n as CaptureIntegrityError, o as NotFoundError, r as ConfigError, s as ValidationError, t as AgentEvalError } from "./errors-Dngq5h35.js";
 import { a as hashCanonical, r as canonicalString } from "./canonical-BsZVgBhW.js";
-import { a as CODING_HARNESSES, c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, n as completionVerdict, o as HARNESS_NATIVE_MODEL, r as createLlmCorrectnessChecker, s as agentProfileHash, t as extractProducedState, u as expandProfileAxes } from "./produced-state-B0QMdiLh.js";
+import { a as CODING_HARNESSES, c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, n as completionVerdict, o as HARNESS_NATIVE_MODEL, r as createLlmCorrectnessChecker, s as agentProfileHash, t as extractProducedState, u as expandProfileAxes } from "./produced-state-1RnbLrSa.js";
 import { c as groupRunsByAgentProfileCell, d as validateAgentProfileCell, f as verifyAgentProfileCell, h as manifestContentDigest, i as agentProfileCellKey, m as hashJson, r as agentProfileCellHashMaterial, s as buildAgentProfileCell, t as AGENT_PROFILE_KINDS, u as toAgentProfileJson } from "./agent-profile-cell-DcFW4vOc.js";
 import { t as mulberry32 } from "./random-Dn5fPWkt.js";
 import { a as spearmanR, c as weightedMean, i as ranks, n as partialCredit, o as summarizeNumberSeries, r as pearsonR, s as weightedComposite, t as confidenceInterval } from "./descriptive-1V17A-qa.js";
@@ -22,12 +22,12 @@ import { r as observedSplitScore, t as isRealnessGated } from "./reward-nw2xZGZG
 import { a as parseRunRecordSafe, c as runTaskScore, i as modelHasSnapshot, l as searchCellRunId, n as UNKNOWN_MODEL, o as roundTripRunRecord, r as isRunRecord, s as runCostFloorUsd, t as RunRecordValidationError, u as validateRunRecord } from "./run-record-BRlM99rX.js";
 import { a as summaryTable, n as gainHistogram, r as paretoChart } from "./summary-report-BMvou2oZ.js";
 import { n as contentHash, r as fileVerdictCache, t as canonicalJson } from "./verdict-cache-BQEsVy9n.js";
-import { G as requiredPairsForPairedPromotion, J as dominates, W as pairedPromotionPower, Y as paretoFrontier, a as transientDispatchFailure, et as DEFAULT_RED_TEAM_CORPUS, i as quotaExhaustedUntil, it as runCanaries, nt as redTeamReport, o as aggregateRunScore, rt as scoreRedTeamOutput, s as clamp01, t as llmJudge, tt as redTeamDataset, ut as runCampaign } from "./llm-judge-CxfoYqdk.js";
+import { $ as paretoFrontier, G as requiredPairsForPairedPromotion, Q as dominates, W as pairedPromotionPower, a as transientDispatchFailure, at as redTeamDataset, ct as runCanaries, i as quotaExhaustedUntil, it as DEFAULT_RED_TEAM_CORPUS, mt as runCampaign, o as aggregateRunScore, ot as redTeamReport, s as clamp01, st as scoreRedTeamOutput, t as llmJudge } from "./llm-judge-fhkFQL1N.js";
 import { a as resolveModelPricing, i as isModelPriced, n as estimateCost, r as estimateTokens, t as MODEL_PRICING } from "./metrics-DOMpkoeb.js";
 import { a as CostLedgerPersistenceError, c as costForTokenPricing, i as CostLedger, l as costForUsage, n as CostCallConflictError, o as CostReceiptCaptureError, r as CostCeilingReachedError, s as CostReservationExceededError, t as CostAccountingIncompleteError, u as modelPriceKey } from "./cost-ledger-_IbkejCF.js";
 import { B as assertRealBackend, F as surfaceContentHash, T as parseReflectionResponse, V as summarizeBackendIntegrity, c as ATTESTATION_ALGORITHM, l as attest, u as verifyAttestation, w as buildReflectionPrompt, z as BackendIntegrityError } from "./campaign-evidence-DJc60F9C.js";
 import { d as redactForShare, f as redactText, n as REDACTION_VERSION, p as shareAllowed, r as assessShareSafety, u as redact } from "./redact-Dk1ZdJEm.js";
-import { r as selfImprove, t as defineAgentEval } from "./define-agent-eval-h2qYe0xY.js";
+import { r as selfImprove, t as defineAgentEval } from "./define-agent-eval-4J02MdF7.js";
 import { n as equivalenceVerdict, t as certificationEvidenceDigest } from "./verdict-DhPoXApk.js";
 import { t as TraceEmitter } from "./emitter-DbMXUIVP.js";
 import { t as buildTrajectory } from "./trajectory-D_7rLrvE.js";

package/dist/jev-protocol.d.ts

@@ -1,27 +1,33 @@
 //#region src/jev-protocol.d.ts
-/** Structural equivalents of the native SDK types; callers can use its builders unchanged. */
+/**
+ * Structural equivalents of TypeSafe's published request schema
+ * (https://api.typesafe.ai/openapi.json); callers can use its builders unchanged.
+ */
 type JevJson = string | number | boolean | null | JevJson[] | {
   [key: string]: JevJson;
 };
+/** What TypeSafe accepts as `state` and as a score level: text or JSON, never null. */
 type JevState = string | {
   [key: string]: JevJson;
-} | JevJson[] | null;
+} | JevJson[];
+/** Instructions and choice or noul descriptions, which TypeSafe also accepts as null. */
+type JevDescription = JevState | null;
 type JevScoreCriteria = readonly [JevState, JevState, ...JevState[]];
 type JevQuestion = {
   type: 'noul';
-  instructions?: JevState;
+  instructions?: JevDescription;
   criteria?: {
-    true?: JevState;
-    false?: JevState;
+    true?: JevDescription;
+    false?: JevDescription;
   } | null;
 } | {
   type: 'score';
-  instructions?: JevState;
+  instructions?: JevDescription;
   criteria: JevScoreCriteria;
 } | {
   type: 'choice';
-  instructions?: JevState;
-  criteria: Record<string, JevState>;
+  instructions?: JevDescription;
+  criteria: Record<string, JevDescription>;
 };
 type JevQuestions = Record<string, JevQuestion>;
 interface JevRequest<Q extends JevQuestions = JevQuestions> {
@@ -65,10 +71,12 @@ interface JevResult<Q extends JevQuestions = JevQuestions> {
 declare class JevResponseError extends Error {
   constructor(message: string);
 }
+/** Validate named questions without a state, as a judge does before it has input. */
+declare function parseJevQuestions(raw: unknown): JevQuestions;
 declare function parseJevRequest(raw: unknown): JevRequest;
 declare function jevUsage(raw: unknown): JevResult['usage'];
 /** Validate native evidence, not model alias policy or the caller's scoring rules. */
 declare function parseJevResult<Q extends JevQuestions>(raw: unknown, request: JevRequest<Q>): JevResult<Q>;
 //#endregion
-export { JevAnswer, JevAnswerFor, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevRequest, parseJevResult };
+export { JevAnswer, JevAnswerFor, JevDescription, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult };
 //# sourceMappingURL=jev-protocol.d.ts.map

package/dist/jev-protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jev-protocol.d.ts","names":[],"sources":["../src/jev-protocol.ts"],"mappings":";;KAIY,6CAA6C;GAAe,cAAc;;KAC1E;GAAuB,cAAc;IAAY;KACjD,6BAA6B,UAAU,aAAa;KACpD;EAEN;EACA,eAAe;EACf;IAAa,OAAO;IAAU,QAAQ;;;EAEtC;EAAe,eAAe;EAAU,UAAU;;EAClD;EAAgB,eAAe;EAAU,UAAU,eAAe;;KAC5D,eAAe,eAAe;UACzB,WAAW,UAAU,eAAe;EACnD;EACA,OAAO;EACP,WAAW;;KAGR,UAAU,UAAU,mCAAmC,uBAExD,cAAc;KACN,aAAa,UAAU,eAAe;EAAY;;WAC/C;WAAuB;IAClC;EAAY;EAAe,gBAAgB,UAAU;;WAExC;WACA;WACA;WACA,oBAAoB,KAAK,UAAU,KAAK,EAAE;WAC1C,2BAA2B,KAAK,UAAU;IAErD;EAAY;EAAgB,gBAAgB;;WAE/B;WACA,cAAc;WACd;WACA,2BAA2B,WAAW;;KAG7C,YAAY,aAAa;UACpB,UAAU,UAAU,eAAe;WACzC;WACA,qBAAqB,WAAW,IAAI,aAAa,EAAE;WACnD;aAAkB;aAA+B;;;cAG/C,yBAAyB;EACpC,YAAY;;iBAoBE,gBAAgB,eAAe;iBAqC/B,SAAS,eAAe;;iBA2BxB,eAAe,UAAU,cACvC,cACA,SAAS,WAAW,KACnB,UAAU"}
+{"version":3,"file":"jev-protocol.d.ts","names":[],"sources":["../src/jev-protocol.ts"],"mappings":";;;;;KAOY,6CAA6C;GAAe,cAAc;;;KAE1E;GAAuB,cAAc;IAAY;;KAEjD,iBAAiB;KACjB,6BAA6B,UAAU,aAAa;KACpD;EAEN;EACA,eAAe;EACf;IAAa,OAAO;IAAgB,QAAQ;;;EAE5C;EAAe,eAAe;EAAgB,UAAU;;EACxD;EAAgB,eAAe;EAAgB,UAAU,eAAe;;KAClE,eAAe,eAAe;UACzB,WAAW,UAAU,eAAe;EACnD;EACA,OAAO;EACP,WAAW;;KAGR,UAAU,UAAU,mCAAmC,uBAExD,cAAc;KACN,aAAa,UAAU,eAAe;EAAY;;WAC/C;WAAuB;IAClC;EAAY;EAAe,gBAAgB,UAAU;;WAExC;WACA;WACA;WACA,oBAAoB,KAAK,UAAU,KAAK,EAAE;WAC1C,2BAA2B,KAAK,UAAU;IAErD;EAAY;EAAgB,gBAAgB;;WAE/B;WACA,cAAc;WACd;WACA,2BAA2B,WAAW;;KAG7C,YAAY,aAAa;UACpB,UAAU,UAAU,eAAe;WACzC;WACA,qBAAqB,WAAW,IAAI,aAAa,EAAE;WACnD;aAAkB;aAA+B;;;cAG/C,yBAAyB;EACpC,YAAY;;;iBA6BE,kBAAkB,eAAe;iBAkCjC,gBAAgB,eAAe;iBAU/B,SAAS,eAAe;;iBA2BxB,eAAe,UAAU,cACvC,cACA,SAAS,WAAW,KACnB,UAAU"}

package/dist/jev-protocol.js

@@ -11,37 +11,45 @@ function object(value) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new JevResponseError("Expected an object");
 	return value;
 }
-function entry(value) {
-	if (value === null || typeof value === "string") return;
-	if (typeof value !== "object") throw new TypeError("Expected text, JSON object/array, or null");
+function textOrJson(value, name) {
+	if (typeof value === "string") return;
+	if (value === null || typeof value !== "object") throw new TypeError(`${name} must be text or a JSON object/array`);
 	canonicalString(value);
 }
-function parseJevRequest(raw) {
-	const request = object(raw);
-	if (typeof request.model !== "string" || !request.model.trim()) throw new TypeError("Evaluation requires a model");
-	entry(request.state);
-	const questions = object(request.questions);
+function optionalTextOrJson(value, name) {
+	if (value !== null) textOrJson(value, name);
+}
+/** Validate named questions without a state, as a judge does before it has input. */
+function parseJevQuestions(raw) {
+	const questions = object(raw);
 	if (!Object.keys(questions).length) throw new TypeError("At least one question is required");
-	for (const rawQuestion of Object.values(questions)) {
+	for (const [name, rawQuestion] of Object.entries(questions)) {
 		const question = object(rawQuestion);
-		if (question.instructions !== void 0) entry(question.instructions);
+		if (question.instructions !== void 0) optionalTextOrJson(question.instructions, `${name} instructions`);
 		if (question.type === "noul") {
 			if (question.criteria != null) {
 				const criteria = object(question.criteria);
 				if (Object.keys(criteria).some((key) => key !== "true" && key !== "false")) throw new TypeError("Noul criteria must describe true and/or false");
-				for (const value of Object.values(criteria)) if (value !== void 0) entry(value);
+				for (const value of Object.values(criteria)) if (value !== void 0) optionalTextOrJson(value, `${name} criteria`);
 			}
 		} else if (question.type === "score") {
 			if (!Array.isArray(question.criteria) || question.criteria.length < 2) throw new TypeError("Score criteria require at least two ordered entries");
-			for (const value of question.criteria) entry(value);
+			for (const value of question.criteria) textOrJson(value, `${name} score level`);
 		} else if (question.type === "choice") {
 			const criteria = object(question.criteria);
 			if (!Object.keys(criteria).length) throw new TypeError("Choice criteria cannot be empty");
-			for (const value of Object.values(criteria)) entry(value);
+			for (const value of Object.values(criteria)) optionalTextOrJson(value, `${name} choice`);
 		} else throw new TypeError("Unsupported native question type");
 	}
 	return raw;
 }
+function parseJevRequest(raw) {
+	const request = object(raw);
+	if (typeof request.model !== "string" || !request.model.trim()) throw new TypeError("Evaluation requires a model");
+	textOrJson(request.state, "Evaluation state");
+	parseJevQuestions(request.questions);
+	return raw;
+}
 function jevUsage(raw) {
 	const usage = object(object(raw).usage);
 	for (const key of ["input_tokens", "output_tokens"]) if (!Number.isSafeInteger(usage[key]) || Number(usage[key]) < 0) throw new JevResponseError("Missing or invalid usage");
@@ -86,6 +94,6 @@ function parseJevResult(raw, request) {
 	return raw;
 }
 //#endregion
-export { JevResponseError, jevUsage, parseJevRequest, parseJevResult };
+export { JevResponseError, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult };
 
 //# sourceMappingURL=jev-protocol.js.map

package/dist/jev-protocol.js.map

@@ -1 +1 @@
-{"version":3,"file":"jev-protocol.js","names":[],"sources":["../src/jev-protocol.ts"],"sourcesContent":["import { isDeepStrictEqual } from 'node:util'\nimport { canonicalString } from './ledger-core/canonical'\n\n/** Structural equivalents of the native SDK types; callers can use its builders unchanged. */\nexport type JevJson = string | number | boolean | null | JevJson[] | { [key: string]: JevJson }\nexport type JevState = string | { [key: string]: JevJson } | JevJson[] | null\nexport type JevScoreCriteria = readonly [JevState, JevState, ...JevState[]]\nexport type JevQuestion =\n  | {\n      type: 'noul'\n      instructions?: JevState\n      criteria?: { true?: JevState; false?: JevState } | null\n    }\n  | { type: 'score'; instructions?: JevState; criteria: JevScoreCriteria }\n  | { type: 'choice'; instructions?: JevState; criteria: Record<string, JevState> }\nexport type JevQuestions = Record<string, JevQuestion>\nexport interface JevRequest<Q extends JevQuestions = JevQuestions> {\n  model: string\n  state: JevState\n  questions: Q\n}\n\ntype ScoreKeys<T extends JevScoreCriteria> = number extends T['length']\n  ? number\n  : Extract<keyof T, `${number}`>\nexport type JevAnswerFor<Q extends JevQuestion> = Q extends { type: 'noul' }\n  ? { readonly type: 'noul'; readonly noul: number }\n  : Q extends { type: 'score'; criteria: infer C extends JevScoreCriteria }\n    ? {\n        readonly type: 'score'\n        readonly score: number\n        readonly confidence: number\n        readonly legend: { readonly [K in ScoreKeys<C>]: C[K] }\n        readonly probabilities: { readonly [K in ScoreKeys<C>]: number }\n      }\n    : Q extends { type: 'choice'; criteria: infer C }\n      ? {\n          readonly type: 'choice'\n          readonly choice: keyof C & string\n          readonly confidence: number\n          readonly probabilities: { readonly [K in keyof C]: number }\n        }\n      : never\nexport type JevAnswer = JevAnswerFor<JevQuestion>\nexport interface JevResult<Q extends JevQuestions = JevQuestions> {\n  readonly model: string\n  readonly answers: { readonly [K in keyof Q]: JevAnswerFor<Q[K]> }\n  readonly usage: { readonly input_tokens: number; readonly output_tokens: number }\n}\n\nexport class JevResponseError extends Error {\n  constructor(message: string) {\n    super(`Jev: ${message}`)\n    this.name = 'JevResponseError'\n  }\n}\n\nfunction object(value: unknown): Record<string, unknown> {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    throw new JevResponseError('Expected an object')\n  }\n  return value as Record<string, unknown>\n}\n\nfunction entry(value: unknown): void {\n  if (value === null || typeof value === 'string') return\n  if (typeof value !== 'object') throw new TypeError('Expected text, JSON object/array, or null')\n  // Reuse the canonical JSON validator rather than accepting lossy Map/Date coercions.\n  canonicalString(value)\n}\n\nexport function parseJevRequest(raw: unknown): JevRequest {\n  const request = object(raw)\n  if (typeof request.model !== 'string' || !request.model.trim()) {\n    throw new TypeError('Evaluation requires a model')\n  }\n  entry(request.state)\n  const questions = object(request.questions)\n  if (!Object.keys(questions).length) throw new TypeError('At least one question is required')\n  for (const rawQuestion of Object.values(questions)) {\n    const question = object(rawQuestion)\n    if (question.instructions !== undefined) entry(question.instructions)\n    if (question.type === 'noul') {\n      if (question.criteria != null) {\n        const criteria = object(question.criteria)\n        if (Object.keys(criteria).some((key) => key !== 'true' && key !== 'false')) {\n          throw new TypeError('Noul criteria must describe true and/or false')\n        }\n        for (const value of Object.values(criteria)) {\n          if (value !== undefined) entry(value)\n        }\n      }\n    } else if (question.type === 'score') {\n      if (!Array.isArray(question.criteria) || question.criteria.length < 2) {\n        throw new TypeError('Score criteria require at least two ordered entries')\n      }\n      for (const value of question.criteria) entry(value)\n    } else if (question.type === 'choice') {\n      const criteria = object(question.criteria)\n      if (!Object.keys(criteria).length) throw new TypeError('Choice criteria cannot be empty')\n      for (const value of Object.values(criteria)) entry(value)\n    } else {\n      throw new TypeError('Unsupported native question type')\n    }\n  }\n  return raw as JevRequest\n}\n\nexport function jevUsage(raw: unknown): JevResult['usage'] {\n  const usage = object(object(raw).usage)\n  for (const key of ['input_tokens', 'output_tokens']) {\n    if (!Number.isSafeInteger(usage[key]) || Number(usage[key]) < 0) {\n      throw new JevResponseError('Missing or invalid usage')\n    }\n  }\n  return usage as unknown as JevResult['usage']\n}\n\nfunction probability(value: unknown): number {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {\n    throw new JevResponseError('Invalid probability')\n  }\n  return value\n}\n\nfunction exactKeys(value: Record<string, unknown>, names: string[]): void {\n  if (\n    Object.keys(value).length !== names.length ||\n    names.some((key) => !Object.hasOwn(value, key))\n  ) {\n    throw new JevResponseError('Response keys differ from the request')\n  }\n}\n\n/** Validate native evidence, not model alias policy or the caller's scoring rules. */\nexport function parseJevResult<Q extends JevQuestions>(\n  raw: unknown,\n  request: JevRequest<Q>,\n): JevResult<Q> {\n  // Preserve extension metadata, rejecting values that change when persisted as JSON.\n  canonicalString(raw)\n  const response = object(raw)\n  if (typeof response.model !== 'string' || !response.model.trim()) {\n    throw new JevResponseError('Missing served model')\n  }\n  const answers = object(response.answers)\n  exactKeys(answers, Object.keys(request.questions))\n  for (const [name, question] of Object.entries(request.questions)) {\n    const answer = object(answers[name])\n    if (answer.type !== question.type) throw new JevResponseError('Wrong answer type')\n    if (question.type === 'noul') {\n      probability(answer.noul)\n      continue\n    }\n    probability(answer.confidence)\n    const levels =\n      question.type === 'score'\n        ? question.criteria.map((_, index) => String(index))\n        : Object.keys(question.criteria)\n    const probabilities = object(answer.probabilities)\n    exactKeys(probabilities, levels)\n    const sum = levels.reduce((total, level) => total + probability(probabilities[level]), 0)\n    if (Math.abs(sum - 1) > 0.0001) throw new JevResponseError('Invalid probability distribution')\n    if (question.type === 'score') {\n      const legend = object(answer.legend)\n      exactKeys(legend, levels)\n      if (\n        levels.some((level) => !isDeepStrictEqual(legend[level], question.criteria[Number(level)]))\n      ) {\n        throw new JevResponseError('Provider changed the rubric')\n      }\n      const expected = levels.reduce(\n        (total, level) => total + Number(level) * Number(probabilities[level]),\n        0,\n      )\n      if (\n        typeof answer.score !== 'number' ||\n        !Number.isFinite(answer.score) ||\n        Math.abs(answer.score - expected) > 0.0001\n      ) {\n        throw new JevResponseError('Score differs from its distribution')\n      }\n    } else if (\n      typeof answer.choice !== 'string' ||\n      !Object.hasOwn(probabilities, answer.choice) ||\n      levels.some(\n        (level) =>\n          Number(probabilities[level]) > Number(probabilities[String(answer.choice)]) + 0.0001,\n      )\n    ) {\n      throw new JevResponseError('Choice is not a highest-probability option')\n    }\n  }\n  jevUsage(raw)\n  return raw as JevResult<Q>\n}\n"],"mappings":"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"}
+{"version":3,"file":"jev-protocol.js","names":[],"sources":["../src/jev-protocol.ts"],"sourcesContent":["import { isDeepStrictEqual } from 'node:util'\nimport { canonicalString } from './ledger-core/canonical'\n\n/**\n * Structural equivalents of TypeSafe's published request schema\n * (https://api.typesafe.ai/openapi.json); callers can use its builders unchanged.\n */\nexport type JevJson = string | number | boolean | null | JevJson[] | { [key: string]: JevJson }\n/** What TypeSafe accepts as `state` and as a score level: text or JSON, never null. */\nexport type JevState = string | { [key: string]: JevJson } | JevJson[]\n/** Instructions and choice or noul descriptions, which TypeSafe also accepts as null. */\nexport type JevDescription = JevState | null\nexport type JevScoreCriteria = readonly [JevState, JevState, ...JevState[]]\nexport type JevQuestion =\n  | {\n      type: 'noul'\n      instructions?: JevDescription\n      criteria?: { true?: JevDescription; false?: JevDescription } | null\n    }\n  | { type: 'score'; instructions?: JevDescription; criteria: JevScoreCriteria }\n  | { type: 'choice'; instructions?: JevDescription; criteria: Record<string, JevDescription> }\nexport type JevQuestions = Record<string, JevQuestion>\nexport interface JevRequest<Q extends JevQuestions = JevQuestions> {\n  model: string\n  state: JevState\n  questions: Q\n}\n\ntype ScoreKeys<T extends JevScoreCriteria> = number extends T['length']\n  ? number\n  : Extract<keyof T, `${number}`>\nexport type JevAnswerFor<Q extends JevQuestion> = Q extends { type: 'noul' }\n  ? { readonly type: 'noul'; readonly noul: number }\n  : Q extends { type: 'score'; criteria: infer C extends JevScoreCriteria }\n    ? {\n        readonly type: 'score'\n        readonly score: number\n        readonly confidence: number\n        readonly legend: { readonly [K in ScoreKeys<C>]: C[K] }\n        readonly probabilities: { readonly [K in ScoreKeys<C>]: number }\n      }\n    : Q extends { type: 'choice'; criteria: infer C }\n      ? {\n          readonly type: 'choice'\n          readonly choice: keyof C & string\n          readonly confidence: number\n          readonly probabilities: { readonly [K in keyof C]: number }\n        }\n      : never\nexport type JevAnswer = JevAnswerFor<JevQuestion>\nexport interface JevResult<Q extends JevQuestions = JevQuestions> {\n  readonly model: string\n  readonly answers: { readonly [K in keyof Q]: JevAnswerFor<Q[K]> }\n  readonly usage: { readonly input_tokens: number; readonly output_tokens: number }\n}\n\nexport class JevResponseError extends Error {\n  constructor(message: string) {\n    super(`Jev: ${message}`)\n    this.name = 'JevResponseError'\n  }\n}\n\nfunction object(value: unknown): Record<string, unknown> {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    throw new JevResponseError('Expected an object')\n  }\n  return value as Record<string, unknown>\n}\n\n// TypeSafe answers 422 for a null state or score level. Refusing it here reports the\n// caller's mistake before a paid round trip, not as a provider failure after one.\nfunction textOrJson(value: unknown, name: string): void {\n  if (typeof value === 'string') return\n  if (value === null || typeof value !== 'object') {\n    throw new TypeError(`${name} must be text or a JSON object/array`)\n  }\n  // Reuse the canonical JSON validator rather than accepting lossy Map/Date coercions.\n  canonicalString(value)\n}\n\nfunction optionalTextOrJson(value: unknown, name: string): void {\n  if (value !== null) textOrJson(value, name)\n}\n\n/** Validate named questions without a state, as a judge does before it has input. */\nexport function parseJevQuestions(raw: unknown): JevQuestions {\n  const questions = object(raw)\n  if (!Object.keys(questions).length) throw new TypeError('At least one question is required')\n  for (const [name, rawQuestion] of Object.entries(questions)) {\n    const question = object(rawQuestion)\n    if (question.instructions !== undefined) {\n      optionalTextOrJson(question.instructions, `${name} instructions`)\n    }\n    if (question.type === 'noul') {\n      if (question.criteria != null) {\n        const criteria = object(question.criteria)\n        if (Object.keys(criteria).some((key) => key !== 'true' && key !== 'false')) {\n          throw new TypeError('Noul criteria must describe true and/or false')\n        }\n        for (const value of Object.values(criteria)) {\n          if (value !== undefined) optionalTextOrJson(value, `${name} criteria`)\n        }\n      }\n    } else if (question.type === 'score') {\n      if (!Array.isArray(question.criteria) || question.criteria.length < 2) {\n        throw new TypeError('Score criteria require at least two ordered entries')\n      }\n      for (const value of question.criteria) textOrJson(value, `${name} score level`)\n    } else if (question.type === 'choice') {\n      const criteria = object(question.criteria)\n      if (!Object.keys(criteria).length) throw new TypeError('Choice criteria cannot be empty')\n      for (const value of Object.values(criteria)) optionalTextOrJson(value, `${name} choice`)\n    } else {\n      throw new TypeError('Unsupported native question type')\n    }\n  }\n  return raw as JevQuestions\n}\n\nexport function parseJevRequest(raw: unknown): JevRequest {\n  const request = object(raw)\n  if (typeof request.model !== 'string' || !request.model.trim()) {\n    throw new TypeError('Evaluation requires a model')\n  }\n  textOrJson(request.state, 'Evaluation state')\n  parseJevQuestions(request.questions)\n  return raw as JevRequest\n}\n\nexport function jevUsage(raw: unknown): JevResult['usage'] {\n  const usage = object(object(raw).usage)\n  for (const key of ['input_tokens', 'output_tokens']) {\n    if (!Number.isSafeInteger(usage[key]) || Number(usage[key]) < 0) {\n      throw new JevResponseError('Missing or invalid usage')\n    }\n  }\n  return usage as unknown as JevResult['usage']\n}\n\nfunction probability(value: unknown): number {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {\n    throw new JevResponseError('Invalid probability')\n  }\n  return value\n}\n\nfunction exactKeys(value: Record<string, unknown>, names: string[]): void {\n  if (\n    Object.keys(value).length !== names.length ||\n    names.some((key) => !Object.hasOwn(value, key))\n  ) {\n    throw new JevResponseError('Response keys differ from the request')\n  }\n}\n\n/** Validate native evidence, not model alias policy or the caller's scoring rules. */\nexport function parseJevResult<Q extends JevQuestions>(\n  raw: unknown,\n  request: JevRequest<Q>,\n): JevResult<Q> {\n  // Preserve extension metadata, rejecting values that change when persisted as JSON.\n  canonicalString(raw)\n  const response = object(raw)\n  if (typeof response.model !== 'string' || !response.model.trim()) {\n    throw new JevResponseError('Missing served model')\n  }\n  const answers = object(response.answers)\n  exactKeys(answers, Object.keys(request.questions))\n  for (const [name, question] of Object.entries(request.questions)) {\n    const answer = object(answers[name])\n    if (answer.type !== question.type) throw new JevResponseError('Wrong answer type')\n    if (question.type === 'noul') {\n      probability(answer.noul)\n      continue\n    }\n    probability(answer.confidence)\n    const levels =\n      question.type === 'score'\n        ? question.criteria.map((_, index) => String(index))\n        : Object.keys(question.criteria)\n    const probabilities = object(answer.probabilities)\n    exactKeys(probabilities, levels)\n    const sum = levels.reduce((total, level) => total + probability(probabilities[level]), 0)\n    if (Math.abs(sum - 1) > 0.0001) throw new JevResponseError('Invalid probability distribution')\n    if (question.type === 'score') {\n      const legend = object(answer.legend)\n      exactKeys(legend, levels)\n      if (\n        levels.some((level) => !isDeepStrictEqual(legend[level], question.criteria[Number(level)]))\n      ) {\n        throw new JevResponseError('Provider changed the rubric')\n      }\n      const expected = levels.reduce(\n        (total, level) => total + Number(level) * Number(probabilities[level]),\n        0,\n      )\n      if (\n        typeof answer.score !== 'number' ||\n        !Number.isFinite(answer.score) ||\n        Math.abs(answer.score - expected) > 0.0001\n      ) {\n        throw new JevResponseError('Score differs from its distribution')\n      }\n    } else if (\n      typeof answer.choice !== 'string' ||\n      !Object.hasOwn(probabilities, answer.choice) ||\n      levels.some(\n        (level) =>\n          Number(probabilities[level]) > Number(probabilities[String(answer.choice)]) + 0.0001,\n      )\n    ) {\n      throw new JevResponseError('Choice is not a highest-probability option')\n    }\n  }\n  jevUsage(raw)\n  return raw as JevResult<Q>\n}\n"],"mappings":"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"}

package/dist/jev.d.ts

@@ -2,7 +2,7 @@ import { b as CustomTokenPricing, g as CostReceiptInput } from "./cost-ledger-Db
 import { i as AnalystFinding, n as AnalystContext, t as Analyst } from "./types-CeDfCRXp.js";
 import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-B2673PBj.js";
 import { EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, Evaluator, EvaluatorOptions, asAnalyst, asJudge, createEvaluator } from "./evaluation.js";
-import { JevAnswer, JevAnswerFor, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevRequest, parseJevResult } from "./jev-protocol.js";
+import { JevAnswer, JevAnswerFor, JevDescription, JevJson, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult } from "./jev-protocol.js";
 import { z } from "zod";
 //#region src/jev-review.d.ts
 declare const checkSchema: z.ZodObject<{
@@ -127,5 +127,5 @@ interface JevAnalystOptions<I, Q extends JevQuestions = JevQuestions> extends Je
 }
 declare function jevAnalyst<I, Q extends JevQuestions = JevQuestions>(options: JevAnalystOptions<I, Q>): Analyst<I>;
 //#endregion
-export { EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, Evaluator, EvaluatorOptions, JevAnalystOptions, JevAnswer, JevAnswerFor, JevEvaluate, JevEvaluatorOptions, JevJson, JevJudgeOptions, JevOptions, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevReviewAssessment, JevReviewCheck, JevReviewInput, JevReviewReport, JevScoreCriteria, JevState, PreparedJevReview, asAnalyst, asJudge, assessJevReview, createEvaluator, jevAnalyst, jevEvaluator, jevJudge, jevReviewFindings, jevUsage, normalizedJevScore, parseJevRequest, parseJevResult, prepareJevReview };
+export { EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, Evaluator, EvaluatorOptions, JevAnalystOptions, JevAnswer, JevAnswerFor, JevDescription, JevEvaluate, JevEvaluatorOptions, JevJson, JevJudgeOptions, JevOptions, JevQuestion, JevQuestions, JevRequest, JevResponseError, JevResult, JevReviewAssessment, JevReviewCheck, JevReviewInput, JevReviewReport, JevScoreCriteria, JevState, PreparedJevReview, asAnalyst, asJudge, assessJevReview, createEvaluator, jevAnalyst, jevEvaluator, jevJudge, jevReviewFindings, jevUsage, normalizedJevScore, parseJevQuestions, parseJevRequest, parseJevResult, prepareJevReview };
 //# sourceMappingURL=jev.d.ts.map

package/dist/jev.js

@@ -4,7 +4,7 @@ import { n as contentHash } from "./verdict-cache-BQEsVy9n.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
 import { r as makeFinding, t as ANALYST_SEVERITIES } from "./types-CW5b90JH.js";
 import { asAnalyst, asJudge, createEvaluator } from "./evaluation.js";
-import { JevResponseError, jevUsage, parseJevRequest, parseJevResult } from "./jev-protocol.js";
+import { JevResponseError, jevUsage, parseJevQuestions, parseJevRequest, parseJevResult } from "./jev-protocol.js";
 import { z } from "zod";
 //#region src/jev-review.ts
 const name = z.string().trim().min(1);
@@ -247,11 +247,7 @@ function jevJudge(name, options) {
 	if (!name.trim() || !options.version.trim()) throw new TypeError("Judge name and version are required");
 	if ((typeof source === "function" || config.map) && !config.dimensions) throw new TypeError("Dynamic questions and custom mappings require stable judge dimensions");
 	if (!config.map && typeof source !== "function") {
-		parseJevRequest({
-			model: config.model,
-			state: null,
-			questions: source
-		});
+		parseJevQuestions(source);
 		if (Object.values(source).some((question) => question.type === "choice")) throw new TypeError("Choice scoring requires an explicit map; labels have no numeric ordering");
 		if (weights) validateWeights(weights, Object.keys(source));
 	}
@@ -308,6 +304,6 @@ function jevAnalyst(options) {
 	});
 }
 //#endregion
-export { JevResponseError, asAnalyst, asJudge, assessJevReview, createEvaluator, jevAnalyst, jevEvaluator, jevJudge, jevReviewFindings, jevUsage, normalizedJevScore, parseJevRequest, parseJevResult, prepareJevReview };
+export { JevResponseError, asAnalyst, asJudge, assessJevReview, createEvaluator, jevAnalyst, jevEvaluator, jevJudge, jevReviewFindings, jevUsage, normalizedJevScore, parseJevQuestions, parseJevRequest, parseJevResult, prepareJevReview };
 
 //# sourceMappingURL=jev.js.map