@tangle-network/agent-eval 0.205.2 → 0.207.0

package/dist/search/index.d.ts

@@ -1,6 +1,6 @@
 import { A as SearchLedgerHash, C as SearchEdgeOperator, G as SearchSplit, H as SearchProposerKind, I as SearchNodeStatus, L as SearchOpenedEvent, T as SearchEstimateMethod, W as SearchSourceRef, i as SearchArtifactRef, j as SearchModelIdentity, l as SearchCandidateSurface, m as SearchClaim, t as NodeEstimate, y as SearchCloseReason } from "../search-ledger-types-p2xKfiDJ.js";
 import { $ as SearchNode, it as SearchStateView } from "../types-ZUy5HGY5.js";
-import { $ as EXPANSION_OPERATORS, L as SearchPolicy, M as SearchUnitExtension, at as OperatorYieldRow, ct as LensResult, dt as rankingSplit, et as ExpansionOperator, ft as summarizeSamples, it as OperatorYieldOptions, lt as LensSignal, nt as OperatorOutcomeCounts, ot as OperatorYieldSignal, p as SearchRunResult, r as SearchArtifactCodec, rt as OperatorYieldData, s as SearchLane, st as operatorYield, t as RunSearchOptions, tt as MIN_OUTCOMES_FOR_WEIGHT, ut as SampleSummary, z as SearchPolicyView } from "../search-kernel-DNpsHb8P.js";
+import { L as SearchPolicy, M as SearchUnitExtension, at as OperatorYieldOptions, ct as operatorYield, dt as SampleSummary, et as EXPANSION_OPERATORS, ft as rankingSplit, it as OperatorYieldData, lt as LensResult, nt as MIN_OUTCOMES_FOR_WEIGHT, ot as OperatorYieldRow, p as SearchRunResult, pt as summarizeSamples, r as SearchArtifactCodec, rt as OperatorOutcomeCounts, s as SearchLane, st as OperatorYieldSignal, t as RunSearchOptions, tt as ExpansionOperator, ut as LensSignal, z as SearchPolicyView } from "../search-kernel-CZ8KJQRw.js";
 import { AgentProfileResourceRef } from "@tangle-network/agent-interface";
 //#region src/search/lenses/edit-credit.d.ts
 /** Signal name a policy reads. */
@@ -1075,8 +1075,14 @@ interface TaskMatrixSpecialistRow {
 interface TaskMatrixData {
   split: 'train' | 'selection';
   direction: 'maximize' | 'minimize';
-  /** How `specialistGain` is computed. */
+  /** How `specialistGain` is computed, including the node cap when sampled. */
   method: string;
+  /** Present only when nodes were sampled; absent for an unchanged full matrix. */
+  sampling?: {
+    nodesClustered: number;
+    nodesTotal: number;
+    cap: number;
+  };
   nodeIds: string[];
   unitIds: string[];
   nodeClusters: TaskMatrixCluster[];

package/dist/search/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/search/lenses/edit-credit.ts","../../src/search/lenses/front.ts","../../src/search/lenses/geometry.ts","../../src/search/lenses/plateau.ts","../../src/search/lenses/landscape.ts","../../src/search/lenses/meta-search.ts","../../src/search/lenses/skill-manifold.ts","../../src/search/lenses/task-matrix.ts","../../src/search/lenses/tree.ts","../../src/search/nested-search.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/search/lenses/edit-credit.ts","../../src/search/lenses/front.ts","../../src/search/lenses/geometry.ts","../../src/search/lenses/plateau.ts","../../src/search/lenses/landscape.ts","../../src/search/lenses/meta-search.ts","../../src/search/lenses/skill-manifold.ts","../../src/search/lenses/task-matrix.ts","../../src/search/lenses/tree.ts","../../src/search/nested-search.ts"],"mappings":"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"}

package/dist/search/index.js

@@ -1,6 +1,6 @@
 import { a as hashCanonical } from "../canonical-BsZVgBhW.js";
 import { _ as rankingSplit, h as operatorYield, m as MIN_OUTCOMES_FOR_WEIGHT, n as runSearch, p as EXPANSION_OPERATORS, v as summarizeSamples } from "../search-kernel-mzeNuzr8.js";
-import { A as editCreditText, C as draftOnPlateau, D as EDIT_CREDIT_ESTIMATOR, E as front, O as EDIT_CREDIT_SIGNAL, S as vectorEmbedding, T as screenedNodes, _ as lineageEdits, a as skillCalibration, b as surfaceDigestEdits, c as META_SEARCH_SIGNAL, d as objectiveKey, f as renderMetaSearchText, g as lineEditDistance, h as landscape, i as nextUnitExtension, k as editCredit, l as metaSearch, m as formatLandscape, n as taskMatrix, o as skillManifold, p as searchPolicyGenome, r as formatSkillManifold, s as META_SEARCH_SCORE_SOURCE, t as tree, u as metaSearchScore, v as nearestNeighbours, w as searchPlateau, x as surfaceTextEdits, y as profileTextLines } from "../tree-By7LtLUu.js";
+import { A as editCreditText, C as draftOnPlateau, D as EDIT_CREDIT_ESTIMATOR, E as front, O as EDIT_CREDIT_SIGNAL, S as vectorEmbedding, T as screenedNodes, _ as lineageEdits, a as skillCalibration, b as surfaceDigestEdits, c as META_SEARCH_SIGNAL, d as objectiveKey, f as renderMetaSearchText, g as lineEditDistance, h as landscape, i as nextUnitExtension, k as editCredit, l as metaSearch, m as formatLandscape, n as taskMatrix, o as skillManifold, p as searchPolicyGenome, r as formatSkillManifold, s as META_SEARCH_SCORE_SOURCE, t as tree, u as metaSearchScore, v as nearestNeighbours, w as searchPlateau, x as surfaceTextEdits, y as profileTextLines } from "../tree-CN8mlzUO.js";
 //#region src/search/nested-search.ts
 /** The deterministic id of the inner search one outer cell attempt runs. */
 function nestedSearchId(containment) {

package/dist/{search-kernel-DNpsHb8P.d.ts → search-kernel-CZ8KJQRw.d.ts}

@@ -1,6 +1,6 @@
 import { o as CostLedger } from "./cost-ledger-DbQdN3nO.js";
 import { a as RunRecord } from "./run-record-DF-fuu31.js";
-import { A as SearchLedgerHash, C as SearchEdgeOperator, E as SearchExecutionIdentity, G as SearchSplit, H as SearchProposerKind, I as SearchNodeStatus, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, S as SearchEdgeAttribution, U as SearchReservation, V as SearchProposer, W as SearchSourceRef, Y as SearchSurfaceEvidence, Z as SearchTask, _ as SearchClaimPower, a as SearchAttemptAccounting, et as SearchTraceRef, i as SearchArtifactRef, j as SearchModelIdentity, k as SearchLedgerEvent, l as SearchCandidateSurface, m as SearchClaim, nt as EvaluationClaim, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, tt as SearchUnknown, y as SearchCloseReason, z as SearchOperationRecordedEvent } from "./search-ledger-types-p2xKfiDJ.js";
+import { A as SearchLedgerHash, C as SearchEdgeOperator, E as SearchExecutionIdentity, G as SearchSplit, H as SearchProposerKind, I as SearchNodeStatus, L as SearchOpenedEvent, N as SearchNodeDecision, O as SearchLedgerEntry, P as SearchNodeRef, Q as SearchTaskOutcome, R as SearchOperationKind, S as SearchEdgeAttribution, T as SearchEstimateMethod, U as SearchReservation, V as SearchProposer, W as SearchSourceRef, Y as SearchSurfaceEvidence, Z as SearchTask, _ as SearchClaimPower, a as SearchAttemptAccounting, et as SearchTraceRef, i as SearchArtifactRef, j as SearchModelIdentity, k as SearchLedgerEvent, l as SearchCandidateSurface, m as SearchClaim, nt as EvaluationClaim, o as SearchAudit, p as SearchCellStage, t as NodeEstimate, tt as SearchUnknown, y as SearchCloseReason, z as SearchOperationRecordedEvent } from "./search-ledger-types-p2xKfiDJ.js";
 import { b as LedgerTrustedHeadRemoval, f as LedgerLineContext, h as LedgerTextStore, y as LedgerTrustedHead } from "./index-Bj96W0jZ.js";
 import { $ as SearchNode, at as SearchUnitScore, it as SearchStateView, j as MutableSurface, tt as SearchScoredCell } from "./types-ZUy5HGY5.js";
 //#region src/campaign/storage.d.ts
@@ -509,6 +509,9 @@ declare function operatorYield(state: SearchStateView, options?: OperatorYieldOp
 //#region src/campaign/estimate-node.d.ts
 /** The estimator every `NodeEstimate` names. */
 declare const SEARCH_ESTIMATOR: SearchSourceRef;
+/** The method a paired sample of `pairs` units supports: the one staging
+ * every `NodeEstimate` and every search lens uses. */
+declare function searchEstimateMethod(pairs: number): SearchEstimateMethod;
 interface EstimateNodeCellsInput {
   nodeId: string;
   against: string;
@@ -1186,5 +1189,5 @@ declare function searchDivergence(state: SearchStateView, nodeId: string): {
   reason: string;
 } | null;
 //#endregion
-export { EXPANSION_OPERATORS as $, SearchCellPlan as A, SearchHistoryCoverageRow as At, aide as B, FileSearchLedger as Bt, decideSearchClaim as C, searchEdgeId as Ct, AshaOptions as D, SearchHistoryAdmissionOptions as Dt, verifySearchClaim as E, CreateSearchHistoryReceiptInput as Et, AideOptions as F, assertSearchHistoryMatchesState as Ft, EstimateNodeCellsInput as G, openSearchLedger as Gt, crowdedFrontierParent as H, SearchLedger as Ht, SearchExpansion as I, createSearchHistoryReceipt as It, SearchPosterior as J, validateSearchLedgerEvent as Jt, NodePosterior as K, parseSearchLedgerLine as Kt, SearchPolicy as L, searchHistoryCoverageRow as Lt, SearchUnitExtension as M, SearchHistoryReceipt as Mt, asha as N, SearchHistoryRequiredError as Nt, SearchAllocationView as O, SearchHistoryAuditSummary as Ot, uniform as P, assertCompleteSearchHistory as Pt, searchPosterior as Q, inMemoryCampaignStorage as Qt, SearchPolicyNode as R, verifySearchHistoryArtifact as Rt, SearchClaimVerification as S, developmentClaim as St, searchClaimReserveUsd as T, surfaceNode as Tt, incumbent as U, SearchLedgerAppendResult as Ut, beam as V, OpenSearchLedgerOptions as Vt, incumbentWithOperatorBandit as W, SearchLedgerTrustedHeadMode as Wt, estimateNodeFromCells as X, createRunCostLedger as Xt, estimateNode as Y, CampaignStorage as Yt, searchCellSetDigest as Z, fsCampaignStorage as Zt, searchPolicyView as _, SearchOpening as _t, SearchCellWork as a, OperatorYieldRow as at, SearchClaimDecision as b, SearchRunIdentity as bt, SearchProposalBlob as c, LensResult as ct, SearchProposedChild as d, rankingSplit as dt, ExpansionOperator as et, SearchProposerPort as f, summarizeSamples as ft, searchExpansionIndex as g, SearchLedgerBinding as gt, searchDivergence as h, RegisterSearchNodeInput as ht, SearchCellResult as i, OperatorYieldOptions as it, SearchRungDecision as j, SearchHistoryPolicy as jt, SearchAllocator as k, SearchHistoryCoverage as kt, SearchProposalRequest as l, LensSignal as lt, runSearch as m, RecordSearchEdgeInput as mt, SEARCH_KERNEL_SOURCE as n, OperatorOutcomeCounts as nt, SearchExecutor as o, OperatorYieldSignal as ot, SearchRunResult as p, AllocateSearchCellInput as pt, SEARCH_ESTIMATOR as q, replaySearchLedgerText as qt, SearchArtifactCodec as r, OperatorYieldData as rt, SearchLane as s, operatorYield as st, RunSearchOptions as t, MIN_OUTCOMES_FOR_WEIGHT as tt, SearchProposalResult as u, SampleSummary as ut, PlanSearchClaimInput as v, SearchRecorder as vt, planSearchClaim as w, surfaceDiff as wt, SearchClaimPlan as x, SettleSearchCellInput as xt, SEARCH_CLAIM_RULE as y, SearchRecorderOptions as yt, SearchPolicyView as z, verifySearchHistoryReceipt as zt };
-//# sourceMappingURL=search-kernel-DNpsHb8P.d.ts.map
+export { searchPosterior as $, inMemoryCampaignStorage as $t, SearchCellPlan as A, SearchHistoryCoverage as At, aide as B, verifySearchHistoryReceipt as Bt, decideSearchClaim as C, developmentClaim as Ct, AshaOptions as D, CreateSearchHistoryReceiptInput as Dt, verifySearchClaim as E, surfaceNode as Et, AideOptions as F, assertCompleteSearchHistory as Ft, EstimateNodeCellsInput as G, SearchLedgerTrustedHeadMode as Gt, crowdedFrontierParent as H, OpenSearchLedgerOptions as Ht, SearchExpansion as I, assertSearchHistoryMatchesState as It, SearchPosterior as J, replaySearchLedgerText as Jt, NodePosterior as K, openSearchLedger as Kt, SearchPolicy as L, createSearchHistoryReceipt as Lt, SearchUnitExtension as M, SearchHistoryPolicy as Mt, asha as N, SearchHistoryReceipt as Nt, SearchAllocationView as O, SearchHistoryAdmissionOptions as Ot, uniform as P, SearchHistoryRequiredError as Pt, searchEstimateMethod as Q, fsCampaignStorage as Qt, SearchPolicyNode as R, searchHistoryCoverageRow as Rt, SearchClaimVerification as S, SettleSearchCellInput as St, searchClaimReserveUsd as T, surfaceDiff as Tt, incumbent as U, SearchLedger as Ut, beam as V, FileSearchLedger as Vt, incumbentWithOperatorBandit as W, SearchLedgerAppendResult as Wt, estimateNodeFromCells as X, CampaignStorage as Xt, estimateNode as Y, validateSearchLedgerEvent as Yt, searchCellSetDigest as Z, createRunCostLedger as Zt, searchPolicyView as _, SearchLedgerBinding as _t, SearchCellWork as a, OperatorYieldOptions as at, SearchClaimDecision as b, SearchRecorderOptions as bt, SearchProposalBlob as c, operatorYield as ct, SearchProposedChild as d, SampleSummary as dt, EXPANSION_OPERATORS as et, SearchProposerPort as f, rankingSplit as ft, searchExpansionIndex as g, RegisterSearchNodeInput as gt, searchDivergence as h, RecordSearchEdgeInput as ht, SearchCellResult as i, OperatorYieldData as it, SearchRungDecision as j, SearchHistoryCoverageRow as jt, SearchAllocator as k, SearchHistoryAuditSummary as kt, SearchProposalRequest as l, LensResult as lt, runSearch as m, AllocateSearchCellInput as mt, SEARCH_KERNEL_SOURCE as n, MIN_OUTCOMES_FOR_WEIGHT as nt, SearchExecutor as o, OperatorYieldRow as ot, SearchRunResult as p, summarizeSamples as pt, SEARCH_ESTIMATOR as q, parseSearchLedgerLine as qt, SearchArtifactCodec as r, OperatorOutcomeCounts as rt, SearchLane as s, OperatorYieldSignal as st, RunSearchOptions as t, ExpansionOperator as tt, SearchProposalResult as u, LensSignal as ut, PlanSearchClaimInput as v, SearchOpening as vt, planSearchClaim as w, searchEdgeId as wt, SearchClaimPlan as x, SearchRunIdentity as xt, SEARCH_CLAIM_RULE as y, SearchRecorder as yt, SearchPolicyView as z, verifySearchHistoryArtifact as zt };
+//# sourceMappingURL=search-kernel-CZ8KJQRw.d.ts.map

package/dist/{search-kernel-DNpsHb8P.d.ts.map → search-kernel-CZ8KJQRw.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"search-kernel-DNpsHb8P.d.ts","names":[],"sources":["../src/campaign/storage.ts","../src/campaign/search-ledger.ts","../src/campaign/search-history-receipt.ts","../src/campaign/search-ledger-recording.ts","../src/search/lenses/shared.ts","../src/search/lenses/operator-yield.ts","../src/campaign/estimate-node.ts","../src/campaign/search-policy.ts","../src/campaign/allocation.ts","../src/campaign/search-claim.ts","../src/campaign/search-kernel.ts"],"mappings":"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"}
+{"version":3,"file":"search-kernel-CZ8KJQRw.d.ts","names":[],"sources":["../src/campaign/storage.ts","../src/campaign/search-ledger.ts","../src/campaign/search-history-receipt.ts","../src/campaign/search-ledger-recording.ts","../src/search/lenses/shared.ts","../src/search/lenses/operator-yield.ts","../src/campaign/estimate-node.ts","../src/campaign/search-policy.ts","../src/campaign/allocation.ts","../src/campaign/search-claim.ts","../src/campaign/search-kernel.ts"],"mappings":"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"}

package/dist/systemone-protocol-DKoi1NdK.d.ts

@@ -0,0 +1,132 @@
+//#region src/systemone-protocol.d.ts
+/**
+ * The System One wire contract (TypeSafe-originated, https://api.typesafe.ai/openapi.json; also
+ * served by Cloudflare Workers AI and Perplexity). This module names no endpoint, credential or
+ * model; callers can use TypeSafe's SDK builders unchanged.
+ */
+type SystemOneJson = string | number | boolean | null | SystemOneJson[] | {
+  [key: string]: SystemOneJson;
+};
+/** What the TypeSafe route accepts as `state` and as a score level: text or JSON, never null. */
+type SystemOneState = string | {
+  [key: string]: SystemOneJson;
+} | SystemOneJson[];
+/** Instructions and choice or noul descriptions, which TypeSafe also accepts as null. */
+type SystemOneDescription = SystemOneState | null;
+type SystemOneScoreCriteria = readonly [SystemOneState, SystemOneState, ...SystemOneState[]];
+type SystemOneQuestion = {
+  type: 'noul';
+  instructions?: SystemOneDescription;
+  criteria?: {
+    true?: SystemOneDescription;
+    false?: SystemOneDescription;
+  } | null;
+} | {
+  type: 'score';
+  instructions?: SystemOneDescription;
+  criteria: SystemOneScoreCriteria;
+} | {
+  type: 'choice';
+  instructions?: SystemOneDescription;
+  criteria: Record<string, SystemOneDescription>;
+};
+type SystemOneQuestions = Record<string, SystemOneQuestion>;
+interface SystemOneRequest<Q extends SystemOneQuestions = SystemOneQuestions> {
+  model: string;
+  state: SystemOneState;
+  questions: Q;
+}
+/** Historical Tangle observations accepted null state and score levels. Not a live request. */
+type SystemOneRecordedQuestion = Exclude<SystemOneQuestion, {
+  type: 'score';
+}> | {
+  type: 'score';
+  instructions?: SystemOneDescription;
+  criteria: readonly [SystemOneDescription, SystemOneDescription, ...SystemOneDescription[]];
+};
+type SystemOneRecordedQuestions = Record<string, SystemOneRecordedQuestion>;
+interface SystemOneRecordedRequest<Q extends SystemOneRecordedQuestions = SystemOneRecordedQuestions> {
+  model: string;
+  state: SystemOneDescription;
+  questions: Q;
+}
+type ScoreKeys<T extends readonly SystemOneDescription[]> = number extends T['length'] ? number : Extract<keyof T, `${number}`>;
+type SystemOneAnswerFor<Q extends SystemOneRecordedQuestion> = Q extends {
+  type: 'noul';
+} ? {
+  readonly type: 'noul';
+  readonly noul: number;
+} : Q extends {
+  type: 'score';
+  criteria: infer C extends readonly SystemOneDescription[];
+} ? {
+  readonly type: 'score';
+  readonly score: number;
+  readonly confidence: number;
+  readonly legend: { readonly [K in ScoreKeys<C>]: C[K]; };
+  readonly probabilities: { readonly [K in ScoreKeys<C>]: number; };
+} : Q extends {
+  type: 'choice';
+  criteria: infer C;
+} ? {
+  readonly type: 'choice';
+  readonly choice: keyof C & string;
+  readonly confidence: number;
+  readonly probabilities: { readonly [K in keyof C]: number; };
+} : never;
+type SystemOneAnswer = SystemOneAnswerFor<SystemOneQuestion>;
+interface SystemOneResult<Q extends SystemOneRecordedQuestions = SystemOneQuestions> {
+  readonly model: string;
+  readonly answers: { readonly [K in keyof Q]: SystemOneAnswerFor<Q[K]>; };
+  readonly usage: {
+    readonly input_tokens: number;
+    readonly output_tokens: number;
+  };
+}
+declare class SystemOneResponseError extends Error {
+  constructor(message: string);
+}
+/** Validate named questions without a state, as a judge does before it has input. */
+declare function parseSystemOneQuestions(raw: unknown): SystemOneQuestions;
+declare function parseSystemOneRequest(raw: unknown): SystemOneRequest;
+/** Read immutable historical evidence without rewriting it or authorizing new inference.
+ * Live transports must still call parseSystemOneRequest, even for re-execution of an old request. */
+declare function parseSystemOneRecordedRequest(raw: unknown): SystemOneRecordedRequest;
+declare function systemOneUsage(raw: unknown): SystemOneResult['usage'];
+/** Validate native evidence, not model alias policy or the caller's scoring rules. */
+declare function parseSystemOneResult<Q extends SystemOneRecordedQuestions>(raw: unknown, request: SystemOneRecordedRequest<Q>): SystemOneResult<Q>;
+/**
+ * How one provider reports results, measured from its responses. The caller that owns the
+ * provider route supplies it; this module names no provider.
+ */
+interface SystemOneResultProfile {
+  /** Decimal places the provider rounds probabilities and scores to. Omit when it reports exact values. */
+  readonly decimals?: number;
+  /**
+   * `canonical`: the provider's `confidence` already follows `systemOneConfidence`.
+   * `provider-defined`: it follows another definition, kept as `provider_confidence`.
+   */
+  readonly confidence: 'canonical' | 'provider-defined';
+}
+/**
+ * The one confidence definition every route reports, TypeSafe's published formulas
+ * (https://docs.typesafe.ai/confidence). Choice: (p_max − 1/n)/(1 − 1/n), and 1 for one option.
+ * Score: 1 − Σ p_i·|i − m| / MAD_uniform, where m is the most likely level (the lowest on ties)
+ * and MAD_uniform = (1/n)·Σ|i − (n − 1)/2|. Expects a normalized distribution; noul has none.
+ */
+declare function systemOneConfidence(answer: {
+  readonly type: 'choice' | 'score';
+  readonly probabilities: Readonly<Record<string, number>>;
+}): number;
+/**
+ * Remove a provider's declared rounding and apply the one confidence definition, before
+ * `parseSystemOneResult`. An answer that already passes the strict checks keeps its
+ * probabilities and score. One that fails them only within the declared rounding is renormalized
+ * and its score recomputed from that distribution; larger error throws. Noul answers never change.
+ * Returns `raw` itself when nothing changes and never mutates it; shapes it cannot read are left
+ * for the strict parser to refuse.
+ */
+declare function normalizeSystemOneResult(raw: unknown, request: SystemOneRecordedRequest, profile: SystemOneResultProfile): unknown;
+//#endregion
+export { systemOneUsage as S, parseSystemOneQuestions as _, SystemOneQuestion as a, parseSystemOneResult as b, SystemOneRecordedQuestions as c, SystemOneResponseError as d, SystemOneResult as f, normalizeSystemOneResult as g, SystemOneState as h, SystemOneJson as i, SystemOneRecordedRequest as l, SystemOneScoreCriteria as m, SystemOneAnswerFor as n, SystemOneQuestions as o, SystemOneResultProfile as p, SystemOneDescription as r, SystemOneRecordedQuestion as s, SystemOneAnswer as t, SystemOneRequest as u, parseSystemOneRecordedRequest as v, systemOneConfidence as x, parseSystemOneRequest as y };
+//# sourceMappingURL=systemone-protocol-DKoi1NdK.d.ts.map

package/dist/systemone-protocol-DKoi1NdK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemone-protocol-DKoi1NdK.d.ts","names":[],"sources":["../src/systemone-protocol.ts"],"mappings":";;;;;;KAQY,mDAKR;GACG,cAAc;;;KAET;GAA6B,cAAc;IAAkB;;KAE7D,uBAAuB;KACvB,mCAAmC,gBAAgB,mBAAmB;KACtE;EAEN;EACA,eAAe;EACf;IAAa,OAAO;IAAsB,QAAQ;;;EAElD;EAAe,eAAe;EAAsB,UAAU;;EAE9D;EACA,eAAe;EACf,UAAU,eAAe;;KAEnB,qBAAqB,eAAe;UAC/B,iBAAiB,UAAU,qBAAqB;EAC/D;EACA,OAAO;EACP,WAAW;;;KAID,4BACR,QAAQ;EAAqB;;EAE3B;EACA,eAAe;EACf,oBAAoB,sBAAsB,yBAAyB;;KAE7D,6BAA6B,eAAe;UACvC,yBACf,UAAU,6BAA6B;EAEvC;EACA,OAAO;EACP,WAAW;;KAGR,UAAU,mBAAmB,yCAAyC,uBAEvE,cAAc;KACN,mBAAmB,UAAU,6BAA6B;EAAY;;WACnE;WAAuB;IAClC;EAAY;EAAe,gBAAgB,mBAAmB;;WAEjD;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,kBAAkB,mBAAmB;UAChC,gBAAgB,UAAU,6BAA6B;WAC7D;WACA,qBAAqB,WAAW,IAAI,mBAAmB,EAAE;WACzD;aAAkB;aAA+B;;;cAG/C,+BAA+B;EAC1C,YAAY;;;iBA6BE,wBAAwB,eAAe;iBAyCvC,sBAAsB,eAAe;;;iBAMrC,8BAA8B,eAAe;iBAe7C,eAAe,eAAe;;iBA2C9B,qBAAqB,UAAU,4BAC7C,cACA,SAAS,yBAAyB,KACjC,gBAAgB;;;;;UA0DF;;WAEN;;;;;WAKA;;;;;;;;iBASK,oBAAoB;WACzB;WACA,eAAe,SAAS;;;;;;;;;;iBAwHnB,yBACd,cACA,SAAS,0BACT,SAAS"}

package/dist/systemone-protocol.d.ts

@@ -0,0 +1,2 @@
+import { S as systemOneUsage, _ as parseSystemOneQuestions, a as SystemOneQuestion, b as parseSystemOneResult, c as SystemOneRecordedQuestions, d as SystemOneResponseError, f as SystemOneResult, g as normalizeSystemOneResult, h as SystemOneState, i as SystemOneJson, l as SystemOneRecordedRequest, m as SystemOneScoreCriteria, n as SystemOneAnswerFor, o as SystemOneQuestions, p as SystemOneResultProfile, r as SystemOneDescription, s as SystemOneRecordedQuestion, t as SystemOneAnswer, u as SystemOneRequest, v as parseSystemOneRecordedRequest, x as systemOneConfidence, y as parseSystemOneRequest } from "./systemone-protocol-DKoi1NdK.js";
+export { SystemOneAnswer, SystemOneAnswerFor, SystemOneDescription, SystemOneJson, SystemOneQuestion, SystemOneQuestions, SystemOneRecordedQuestion, SystemOneRecordedQuestions, SystemOneRecordedRequest, SystemOneRequest, SystemOneResponseError, SystemOneResult, SystemOneResultProfile, SystemOneScoreCriteria, SystemOneState, normalizeSystemOneResult, parseSystemOneQuestions, parseSystemOneRecordedRequest, parseSystemOneRequest, parseSystemOneResult, systemOneConfidence, systemOneUsage };

package/dist/systemone-protocol.js

@@ -0,0 +1,214 @@
+import { r as canonicalString } from "./canonical-BsZVgBhW.js";
+import { isDeepStrictEqual } from "node:util";
+//#region src/systemone-protocol.ts
+var SystemOneResponseError = class extends Error {
+	constructor(message) {
+		super(`System One: ${message}`);
+		this.name = "SystemOneResponseError";
+	}
+};
+function object(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new SystemOneResponseError("Expected an object");
+	return value;
+}
+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 optionalTextOrJson(value, name) {
+	if (value !== null) textOrJson(value, name);
+}
+/** Validate named questions without a state, as a judge does before it has input. */
+function parseSystemOneQuestions(raw) {
+	return readQuestions(raw, false);
+}
+function readQuestions(raw, recorded) {
+	const questions = object(raw);
+	if (!Object.keys(questions).length) throw new TypeError("At least one question is required");
+	for (const [name, rawQuestion] of Object.entries(questions)) {
+		const question = object(rawQuestion);
+		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) 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) {
+				if (recorded && value === null) continue;
+				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)) optionalTextOrJson(value, `${name} choice`);
+		} else throw new TypeError("Unsupported native question type");
+	}
+	return raw;
+}
+function parseSystemOneRequest(raw) {
+	return readRequest(raw, false);
+}
+/** Read immutable historical evidence without rewriting it or authorizing new inference.
+* Live transports must still call parseSystemOneRequest, even for re-execution of an old request. */
+function parseSystemOneRecordedRequest(raw) {
+	canonicalString(raw);
+	return readRequest(raw, true);
+}
+function readRequest(raw, recorded) {
+	const request = object(raw);
+	if (typeof request.model !== "string" || !request.model.trim()) throw new TypeError("Evaluation requires a model");
+	if (!recorded || request.state !== null) textOrJson(request.state, "Evaluation state");
+	readQuestions(request.questions, recorded);
+	return raw;
+}
+function systemOneUsage(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 SystemOneResponseError("Missing or invalid usage");
+	return usage;
+}
+/** The strict parser's allowance for floating-point error; provider rounding is normalized first. */
+const TOLERANCE = 1e-4;
+function levelsOf(question) {
+	return question.type === "score" ? question.criteria.map((_, index) => String(index)) : question.type === "choice" ? Object.keys(question.criteria) : [];
+}
+/** Σ level·p over score levels "0".."n-1". */
+function expectation(levels, probabilities) {
+	return levels.reduce((total, level) => total + Number(level) * Number(probabilities[level]), 0);
+}
+function probability(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) throw new SystemOneResponseError("Invalid probability");
+	return value;
+}
+function exactKeys(value, names) {
+	if (Object.keys(value).length !== names.length || names.some((key) => !Object.hasOwn(value, key))) throw new SystemOneResponseError("Response keys differ from the request");
+}
+/** Validate native evidence, not model alias policy or the caller's scoring rules. */
+function parseSystemOneResult(raw, request) {
+	canonicalString(raw);
+	const response = object(raw);
+	if (typeof response.model !== "string" || !response.model.trim()) throw new SystemOneResponseError("Missing served model");
+	const answers = object(response.answers);
+	exactKeys(answers, Object.keys(request.questions));
+	for (const [name, question] of Object.entries(request.questions)) {
+		const answer = object(answers[name]);
+		if (answer.type !== question.type) throw new SystemOneResponseError("Wrong answer type");
+		if (question.type === "noul") {
+			probability(answer.noul);
+			continue;
+		}
+		probability(answer.confidence);
+		const levels = levelsOf(question);
+		const probabilities = object(answer.probabilities);
+		exactKeys(probabilities, levels);
+		const sum = levels.reduce((total, level) => total + probability(probabilities[level]), 0);
+		if (Math.abs(sum - 1) > TOLERANCE) throw new SystemOneResponseError("Invalid probability distribution");
+		if (question.type === "score") {
+			const legend = object(answer.legend);
+			exactKeys(legend, levels);
+			if (levels.some((level) => !isDeepStrictEqual(legend[level], question.criteria[Number(level)]))) throw new SystemOneResponseError("Provider changed the rubric");
+			if (typeof answer.score !== "number" || !Number.isFinite(answer.score) || Math.abs(answer.score - expectation(levels, probabilities)) > TOLERANCE) throw new SystemOneResponseError("Score differs from its distribution");
+		} else if (typeof answer.choice !== "string" || !Object.hasOwn(probabilities, answer.choice) || levels.some((level) => Number(probabilities[level]) > Number(probabilities[String(answer.choice)]) + TOLERANCE)) throw new SystemOneResponseError("Choice is not a highest-probability option");
+	}
+	systemOneUsage(raw);
+	return raw;
+}
+/**
+* The one confidence definition every route reports, TypeSafe's published formulas
+* (https://docs.typesafe.ai/confidence). Choice: (p_max − 1/n)/(1 − 1/n), and 1 for one option.
+* Score: 1 − Σ p_i·|i − m| / MAD_uniform, where m is the most likely level (the lowest on ties)
+* and MAD_uniform = (1/n)·Σ|i − (n − 1)/2|. Expects a normalized distribution; noul has none.
+*/
+function systemOneConfidence(answer) {
+	const labels = Object.keys(answer.probabilities);
+	const n = labels.length;
+	const p = labels.map((label, index) => answer.probabilities[answer.type === "score" ? String(index) : label]);
+	if (!n || answer.type === "score" && n < 2 || p.some((value) => typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1)) throw new TypeError("Confidence requires a probability for every option or score level");
+	const values = p;
+	const peak = Math.max(...values);
+	let confidence;
+	if (answer.type === "choice") confidence = n === 1 ? 1 : (peak - 1 / n) / (1 - 1 / n);
+	else {
+		const mode = values.indexOf(peak);
+		const center = (n - 1) / 2;
+		const uniform = values.reduce((total, _, level) => total + Math.abs(level - center), 0) / n;
+		confidence = 1 - values.reduce((total, value, level) => total + value * Math.abs(level - mode), 0) / uniform;
+	}
+	return Math.min(1, Math.max(0, confidence));
+}
+function readProfile(profile) {
+	if (profile === null || typeof profile !== "object" || profile.decimals !== void 0 && (!Number.isSafeInteger(profile.decimals) || profile.decimals < 0 || profile.decimals > 15) || profile.confidence !== "canonical" && profile.confidence !== "provider-defined") throw new TypeError("Invalid System One result profile");
+}
+function normalizeAnswer(answer, question, profile) {
+	const levels = levelsOf(question);
+	const probabilities = answer.probabilities;
+	const keys = Object.keys(probabilities);
+	if (keys.length !== levels.length || levels.some((level) => {
+		const value = probabilities[level];
+		return !Object.hasOwn(probabilities, level) || typeof value !== "number" || !(value >= 0 && value <= 1);
+	})) return answer;
+	const q = probabilities;
+	const sum = keys.reduce((total, key) => total + q[key], 0);
+	const scored = question.type === "score";
+	const score = answer.score;
+	if (scored && (typeof score !== "number" || !Number.isFinite(score))) return answer;
+	let next = answer;
+	if (!(Math.abs(sum - 1) <= TOLERANCE && (!scored || Math.abs(score - expectation(levels, q)) <= TOLERANCE)) && profile.decimals !== void 0) {
+		const unit = 10 ** -profile.decimals;
+		if (Math.abs(sum - 1) > levels.length * unit / 2) throw new SystemOneResponseError("Distribution error exceeds declared rounding");
+		const levelTotal = levels.length * (levels.length - 1) / 2;
+		if (scored && Math.abs(score - expectation(levels, q)) > unit / 2 + unit * levelTotal) throw new SystemOneResponseError("Score error exceeds declared rounding");
+		const p = Math.abs(sum - 1) <= TOLERANCE ? q : Object.fromEntries(keys.map((key) => [key, q[key] / sum]));
+		next = {
+			...answer,
+			probabilities: p,
+			...scored ? { score: expectation(levels, p) } : {}
+		};
+	}
+	if (profile.confidence === "provider-defined" && typeof answer.confidence === "number" && !Object.hasOwn(answer, "provider_confidence")) next = {
+		...next,
+		provider_confidence: answer.confidence,
+		confidence: systemOneConfidence({
+			type: question.type,
+			probabilities: next.probabilities
+		})
+	};
+	return next;
+}
+/**
+* Remove a provider's declared rounding and apply the one confidence definition, before
+* `parseSystemOneResult`. An answer that already passes the strict checks keeps its
+* probabilities and score. One that fails them only within the declared rounding is renormalized
+* and its score recomputed from that distribution; larger error throws. Noul answers never change.
+* Returns `raw` itself when nothing changes and never mutates it; shapes it cannot read are left
+* for the strict parser to refuse.
+*/
+function normalizeSystemOneResult(raw, request, profile) {
+	readProfile(profile);
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
+	const response = raw;
+	const original = response.answers;
+	if (original === null || typeof original !== "object" || Array.isArray(original)) return raw;
+	const answers = { ...original };
+	let changed = false;
+	for (const [name, question] of Object.entries(request.questions)) {
+		const answer = answers[name];
+		if (question.type === "noul" || answer === null || typeof answer !== "object" || Array.isArray(answer) || answer.type !== question.type || answer.probabilities === null || typeof answer.probabilities !== "object" || Array.isArray(answer.probabilities)) continue;
+		const next = normalizeAnswer(answer, question, profile);
+		if (next !== answer) {
+			answers[name] = next;
+			changed = true;
+		}
+	}
+	return changed ? {
+		...response,
+		answers
+	} : raw;
+}
+//#endregion
+export { SystemOneResponseError, normalizeSystemOneResult, parseSystemOneQuestions, parseSystemOneRecordedRequest, parseSystemOneRequest, parseSystemOneResult, systemOneConfidence, systemOneUsage };
+
+//# sourceMappingURL=systemone-protocol.js.map

package/dist/systemone-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemone-protocol.js","names":[],"sources":["../src/systemone-protocol.ts"],"sourcesContent":["import { isDeepStrictEqual } from 'node:util'\nimport { canonicalString } from './ledger-core/canonical'\n\n/**\n * The System One wire contract (TypeSafe-originated, https://api.typesafe.ai/openapi.json; also\n * served by Cloudflare Workers AI and Perplexity). This module names no endpoint, credential or\n * model; callers can use TypeSafe's SDK builders unchanged.\n */\nexport type SystemOneJson =\n  | string\n  | number\n  | boolean\n  | null\n  | SystemOneJson[]\n  | { [key: string]: SystemOneJson }\n/** What the TypeSafe route accepts as `state` and as a score level: text or JSON, never null. */\nexport type SystemOneState = string | { [key: string]: SystemOneJson } | SystemOneJson[]\n/** Instructions and choice or noul descriptions, which TypeSafe also accepts as null. */\nexport type SystemOneDescription = SystemOneState | null\nexport type SystemOneScoreCriteria = readonly [SystemOneState, SystemOneState, ...SystemOneState[]]\nexport type SystemOneQuestion =\n  | {\n      type: 'noul'\n      instructions?: SystemOneDescription\n      criteria?: { true?: SystemOneDescription; false?: SystemOneDescription } | null\n    }\n  | { type: 'score'; instructions?: SystemOneDescription; criteria: SystemOneScoreCriteria }\n  | {\n      type: 'choice'\n      instructions?: SystemOneDescription\n      criteria: Record<string, SystemOneDescription>\n    }\nexport type SystemOneQuestions = Record<string, SystemOneQuestion>\nexport interface SystemOneRequest<Q extends SystemOneQuestions = SystemOneQuestions> {\n  model: string\n  state: SystemOneState\n  questions: Q\n}\n\n/** Historical Tangle observations accepted null state and score levels. Not a live request. */\nexport type SystemOneRecordedQuestion =\n  | Exclude<SystemOneQuestion, { type: 'score' }>\n  | {\n      type: 'score'\n      instructions?: SystemOneDescription\n      criteria: readonly [SystemOneDescription, SystemOneDescription, ...SystemOneDescription[]]\n    }\nexport type SystemOneRecordedQuestions = Record<string, SystemOneRecordedQuestion>\nexport interface SystemOneRecordedRequest<\n  Q extends SystemOneRecordedQuestions = SystemOneRecordedQuestions,\n> {\n  model: string\n  state: SystemOneDescription\n  questions: Q\n}\n\ntype ScoreKeys<T extends readonly SystemOneDescription[]> = number extends T['length']\n  ? number\n  : Extract<keyof T, `${number}`>\nexport type SystemOneAnswerFor<Q extends SystemOneRecordedQuestion> = Q extends { type: 'noul' }\n  ? { readonly type: 'noul'; readonly noul: number }\n  : Q extends { type: 'score'; criteria: infer C extends readonly SystemOneDescription[] }\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 SystemOneAnswer = SystemOneAnswerFor<SystemOneQuestion>\nexport interface SystemOneResult<Q extends SystemOneRecordedQuestions = SystemOneQuestions> {\n  readonly model: string\n  readonly answers: { readonly [K in keyof Q]: SystemOneAnswerFor<Q[K]> }\n  readonly usage: { readonly input_tokens: number; readonly output_tokens: number }\n}\n\nexport class SystemOneResponseError extends Error {\n  constructor(message: string) {\n    super(`System One: ${message}`)\n    this.name = 'SystemOneResponseError'\n  }\n}\n\nfunction object(value: unknown): Record<string, unknown> {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    throw new SystemOneResponseError('Expected an object')\n  }\n  return value as Record<string, unknown>\n}\n\n// Providers answer 422 for a null state, and TypeSafe also for a null score level. Refusing them\n// here reports the 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 parseSystemOneQuestions(raw: unknown): SystemOneQuestions {\n  return readQuestions(raw, false) as SystemOneQuestions\n}\n\nfunction readQuestions(raw: unknown, recorded: boolean): SystemOneRecordedQuestions {\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) {\n        if (recorded && value === null) continue\n        textOrJson(value, `${name} score level`)\n      }\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 SystemOneRecordedQuestions\n}\n\nexport function parseSystemOneRequest(raw: unknown): SystemOneRequest {\n  return readRequest(raw, false) as SystemOneRequest\n}\n\n/** Read immutable historical evidence without rewriting it or authorizing new inference.\n * Live transports must still call parseSystemOneRequest, even for re-execution of an old request. */\nexport function parseSystemOneRecordedRequest(raw: unknown): SystemOneRecordedRequest {\n  canonicalString(raw)\n  return readRequest(raw, true)\n}\n\nfunction readRequest(raw: unknown, recorded: boolean): SystemOneRecordedRequest {\n  const request = object(raw)\n  if (typeof request.model !== 'string' || !request.model.trim()) {\n    throw new TypeError('Evaluation requires a model')\n  }\n  if (!recorded || request.state !== null) textOrJson(request.state, 'Evaluation state')\n  readQuestions(request.questions, recorded)\n  return raw as SystemOneRecordedRequest\n}\n\nexport function systemOneUsage(raw: unknown): SystemOneResult['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 SystemOneResponseError('Missing or invalid usage')\n    }\n  }\n  return usage as unknown as SystemOneResult['usage']\n}\n\n/** The strict parser's allowance for floating-point error; provider rounding is normalized first. */\nconst TOLERANCE = 0.0001\n\nfunction levelsOf(question: SystemOneRecordedQuestion): string[] {\n  return question.type === 'score'\n    ? question.criteria.map((_, index) => String(index))\n    : question.type === 'choice'\n      ? Object.keys(question.criteria)\n      : []\n}\n\n/** Σ level·p over score levels \"0\"..\"n-1\". */\nfunction expectation(levels: string[], probabilities: Record<string, unknown>): number {\n  return levels.reduce((total, level) => total + Number(level) * Number(probabilities[level]), 0)\n}\n\nfunction probability(value: unknown): number {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {\n    throw new SystemOneResponseError('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 SystemOneResponseError('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 parseSystemOneResult<Q extends SystemOneRecordedQuestions>(\n  raw: unknown,\n  request: SystemOneRecordedRequest<Q>,\n): SystemOneResult<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 SystemOneResponseError('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 SystemOneResponseError('Wrong answer type')\n    if (question.type === 'noul') {\n      probability(answer.noul)\n      continue\n    }\n    probability(answer.confidence)\n    const levels = levelsOf(question)\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) > TOLERANCE) {\n      throw new SystemOneResponseError('Invalid probability distribution')\n    }\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 SystemOneResponseError('Provider changed the rubric')\n      }\n      if (\n        typeof answer.score !== 'number' ||\n        !Number.isFinite(answer.score) ||\n        Math.abs(answer.score - expectation(levels, probabilities)) > TOLERANCE\n      ) {\n        throw new SystemOneResponseError('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)]) + TOLERANCE,\n      )\n    ) {\n      throw new SystemOneResponseError('Choice is not a highest-probability option')\n    }\n  }\n  systemOneUsage(raw)\n  return raw as SystemOneResult<Q>\n}\n\n/**\n * How one provider reports results, measured from its responses. The caller that owns the\n * provider route supplies it; this module names no provider.\n */\nexport interface SystemOneResultProfile {\n  /** Decimal places the provider rounds probabilities and scores to. Omit when it reports exact values. */\n  readonly decimals?: number\n  /**\n   * `canonical`: the provider's `confidence` already follows `systemOneConfidence`.\n   * `provider-defined`: it follows another definition, kept as `provider_confidence`.\n   */\n  readonly confidence: 'canonical' | 'provider-defined'\n}\n\n/**\n * The one confidence definition every route reports, TypeSafe's published formulas\n * (https://docs.typesafe.ai/confidence). Choice: (p_max − 1/n)/(1 − 1/n), and 1 for one option.\n * Score: 1 − Σ p_i·|i − m| / MAD_uniform, where m is the most likely level (the lowest on ties)\n * and MAD_uniform = (1/n)·Σ|i − (n − 1)/2|. Expects a normalized distribution; noul has none.\n */\nexport function systemOneConfidence(answer: {\n  readonly type: 'choice' | 'score'\n  readonly probabilities: Readonly<Record<string, number>>\n}): number {\n  const labels = Object.keys(answer.probabilities)\n  const n = labels.length\n  const p = labels.map(\n    (label, index) => answer.probabilities[answer.type === 'score' ? String(index) : label],\n  )\n  if (\n    !n ||\n    (answer.type === 'score' && n < 2) ||\n    p.some(\n      (value) => typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1,\n    )\n  ) {\n    throw new TypeError('Confidence requires a probability for every option or score level')\n  }\n  const values = p as number[]\n  const peak = Math.max(...values)\n  let confidence: number\n  if (answer.type === 'choice') {\n    confidence = n === 1 ? 1 : (peak - 1 / n) / (1 - 1 / n)\n  } else {\n    const mode = values.indexOf(peak)\n    const center = (n - 1) / 2\n    const uniform = values.reduce((total, _, level) => total + Math.abs(level - center), 0) / n\n    const spread = values.reduce((total, value, level) => total + value * Math.abs(level - mode), 0)\n    confidence = 1 - spread / uniform\n  }\n  return Math.min(1, Math.max(0, confidence))\n}\n\nfunction readProfile(profile: SystemOneResultProfile): void {\n  if (\n    profile === null ||\n    typeof profile !== 'object' ||\n    (profile.decimals !== undefined &&\n      (!Number.isSafeInteger(profile.decimals) || profile.decimals < 0 || profile.decimals > 15)) ||\n    (profile.confidence !== 'canonical' && profile.confidence !== 'provider-defined')\n  ) {\n    throw new TypeError('Invalid System One result profile')\n  }\n}\n\nfunction normalizeAnswer(\n  answer: Record<string, unknown>,\n  question: Exclude<SystemOneRecordedQuestion, { type: 'noul' }>,\n  profile: SystemOneResultProfile,\n): Record<string, unknown> {\n  const levels = levelsOf(question)\n  const probabilities = answer.probabilities as Record<string, unknown>\n  const keys = Object.keys(probabilities)\n  if (\n    keys.length !== levels.length ||\n    levels.some((level) => {\n      const value = probabilities[level]\n      return (\n        !Object.hasOwn(probabilities, level) ||\n        typeof value !== 'number' ||\n        !(value >= 0 && value <= 1)\n      )\n    })\n  ) {\n    // Leave shapes the strict parser refuses for it to name.\n    return answer\n  }\n  const q = probabilities as Record<string, number>\n  const sum = keys.reduce((total, key) => total + q[key]!, 0)\n  const scored = question.type === 'score'\n  const score = answer.score\n  if (scored && (typeof score !== 'number' || !Number.isFinite(score))) return answer\n  let next = answer\n  const consistent =\n    Math.abs(sum - 1) <= TOLERANCE &&\n    (!scored || Math.abs((score as number) - expectation(levels, q)) <= TOLERANCE)\n  if (!consistent && profile.decimals !== undefined) {\n    // Rounding to `decimals` moves each reported probability by at most one unit in the last\n    // place, and the reported score by half a unit; anything larger is a provider defect.\n    const unit = 10 ** -profile.decimals\n    if (Math.abs(sum - 1) > (levels.length * unit) / 2) {\n      throw new SystemOneResponseError('Distribution error exceeds declared rounding')\n    }\n    const levelTotal = (levels.length * (levels.length - 1)) / 2\n    if (\n      scored &&\n      Math.abs((score as number) - expectation(levels, q)) > unit / 2 + unit * levelTotal\n    ) {\n      throw new SystemOneResponseError('Score error exceeds declared rounding')\n    }\n    const p =\n      Math.abs(sum - 1) <= TOLERANCE\n        ? q\n        : Object.fromEntries(keys.map((key) => [key, q[key]! / sum]))\n    next = { ...answer, probabilities: p, ...(scored ? { score: expectation(levels, p) } : {}) }\n  }\n  // An answer that already carries provider_confidence was normalized before.\n  if (\n    profile.confidence === 'provider-defined' &&\n    typeof answer.confidence === 'number' &&\n    !Object.hasOwn(answer, 'provider_confidence')\n  ) {\n    next = {\n      ...next,\n      provider_confidence: answer.confidence,\n      confidence: systemOneConfidence({\n        type: question.type,\n        probabilities: next.probabilities as Record<string, number>,\n      }),\n    }\n  }\n  return next\n}\n\n/**\n * Remove a provider's declared rounding and apply the one confidence definition, before\n * `parseSystemOneResult`. An answer that already passes the strict checks keeps its\n * probabilities and score. One that fails them only within the declared rounding is renormalized\n * and its score recomputed from that distribution; larger error throws. Noul answers never change.\n * Returns `raw` itself when nothing changes and never mutates it; shapes it cannot read are left\n * for the strict parser to refuse.\n */\nexport function normalizeSystemOneResult(\n  raw: unknown,\n  request: SystemOneRecordedRequest,\n  profile: SystemOneResultProfile,\n): unknown {\n  readProfile(profile)\n  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return raw\n  const response = raw as Record<string, unknown>\n  const original = response.answers\n  if (original === null || typeof original !== 'object' || Array.isArray(original)) return raw\n  const answers: Record<string, unknown> = { ...original }\n  let changed = false\n  for (const [name, question] of Object.entries(request.questions)) {\n    const answer = answers[name]\n    if (\n      question.type === 'noul' ||\n      answer === null ||\n      typeof answer !== 'object' ||\n      Array.isArray(answer) ||\n      (answer as Record<string, unknown>).type !== question.type ||\n      (answer as Record<string, unknown>).probabilities === null ||\n      typeof (answer as Record<string, unknown>).probabilities !== 'object' ||\n      Array.isArray((answer as Record<string, unknown>).probabilities)\n    ) {\n      continue\n    }\n    const next = normalizeAnswer(answer as Record<string, unknown>, question, profile)\n    if (next !== answer) {\n      answers[name] = next\n      changed = true\n    }\n  }\n  return changed ? { ...response, answers } : raw\n}\n"],"mappings":"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"}