@tangle-network/agent-eval 0.183.0 → 0.185.0

package/dist/{insight-report-D1qa0HWs.d.ts → insight-report-C3Bfl762.d.ts}

@@ -1,7 +1,7 @@
 import { o as FailureClass } from "./schema-CR5cpjQ3.js";
-import { l as RunTerminalOutcome } from "./run-record-BiTWauyO.js";
+import { l as RunTerminalOutcome } from "./run-record-D9wS35fK.js";
 import { r as ContinuousAgreement } from "./judge-calibration-DFtEMlde.js";
-import { i as ParetoFigureSpec, t as GainDistributionBin } from "./summary-report-D1h4dlrK.js";
+import { i as ParetoFigureSpec, t as GainDistributionBin } from "./summary-report-BzFS5UhZ.js";
 //#region src/contract/insight-report.d.ts
 interface InsightReport {
   /** Number of runs analyzed. */
@@ -407,4 +407,4 @@ interface Recommendation {
 }
 //#endregion
 export { FailureClusterInsight as a, JudgeInsight as c, Recommendation as d, ReleaseSummary as f, FailureClassTally as i, LiftInsight as l, TokenUsageInsight as m, ExecutionErrorOutcomeCell as n, InsightReport as o, ScalarDistribution as p, ExecutionInsight as r, InterRaterInsight as s, CostProvenanceSummary as t, OutcomeCorrelationInsight as u };
-//# sourceMappingURL=insight-report-D1qa0HWs.d.ts.map
+//# sourceMappingURL=insight-report-C3Bfl762.d.ts.map

package/dist/{insight-report-D1qa0HWs.d.ts.map → insight-report-C3Bfl762.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"insight-report-D1qa0HWs.d.ts","names":[],"sources":["../src/contract/insight-report.ts"],"mappings":";;;;;UAqCiB;;EAEf;;;;EAKA,WAAW;;EAGX,WAAW;;;EAIX,cAAc,eAAe;;EAG7B;IACE,MAAM;IACN,QAAQ;;;;IAIR,aAAa;;;;;IAKb;MAAa;MAAe;;;;;;EAM9B,QAAQ,eAAe;;;;EAKvB,aAAa;;;;EAKb,OAAO;;;EAIP,kBAAkB;;;EAIlB,gBAAgB;;;;;EAMhB,qBAAqB;;;;;EAMrB,SAAS;;;;;;EAOT,wBAAwB;;;;EAKxB,iBAAiB;;;EAIjB,iBAAiB;;UAGF;EACf;IAAY;IAAW;;EACvB;IAAa;IAAW;;EACxB;IAAc;;EACd;;UAGe;;EAEf,YAAY;;EAEZ,SAAS;;;EAGT,YAAY;;;EAGZ;IACE;IACA,YAAY;IACZ,SAAS;IACT;;;EAGF,QAAQ;IAAQ;IAAe;;;;;EAI/B;IACE;IACA;IACA;;;;;EAKF;IACE;;;IAGA;;IAEA;;IAEA;;IAEA;;IAEA;;;;;IAKA,mBAAmB,OAAO,oBAAoB;;;;EAIhD;IACE;IACA;IACA;IACA;IACA;;;UAIa;;EAEf;;EAEA;;EAEA;;UAGe;EACf,OAAO;EACP,QAAQ;EACR,WAAW;EACX,QAAQ;EACR,YAAY;EACZ;IACE;IACA;IACA;IACA;IACA;;;;UAOa;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,WAAW;;;;;EAKX,WAAW;IAAQ;IAAe;;;UAGnB;;EAEf;;EAEA;;;EAGA,cAAc;;;EAGd;;;EAGA;;;EAGA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;EAET,mBAAmB;IACjB;IACA,SAAS;MAAQ;MAAe;;IAChC;;;UAIa;EACf;EACA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;EAWA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf,UAAU;IACR;IACA;;IAEA;;IAEA;;IAEA;;EAEF;;;;;UAMe;;EAEf,cAAc;;EAEd;;EAEA;;UAGe;;EAEf;;;EAGA;EACA,UAAU;IAAQ;IAAe;IAAgB;;;UAGlC;;;EAGf;;EAEA;;EAEA;;EAEA;;EAEA;IACE;IACA;IACA;;;UAIa;;;EAGf;EACA,MAAM;IACJ;IACA;IACA;;;;EAIF;;UAGQ;;EAER;;EAEA;;;;EAIA;;EAEA;EACA;;KAGU,eACP;EACC;;EAEA;;EAEA;;EAEA;;EAEA;MAED;EACC;;EAEA;EACA;EACA;EACA;;UAGW;;EAEf;EACA;;EAEA;;;;EAIA,SAAS,eAAe;;;EAGxB;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA"}
+{"version":3,"file":"insight-report-C3Bfl762.d.ts","names":[],"sources":["../src/contract/insight-report.ts"],"mappings":";;;;;UAqCiB;;EAEf;;;;EAKA,WAAW;;EAGX,WAAW;;;EAIX,cAAc,eAAe;;EAG7B;IACE,MAAM;IACN,QAAQ;;;;IAIR,aAAa;;;;;IAKb;MAAa;MAAe;;;;;;EAM9B,QAAQ,eAAe;;;;EAKvB,aAAa;;;;EAKb,OAAO;;;EAIP,kBAAkB;;;EAIlB,gBAAgB;;;;;EAMhB,qBAAqB;;;;;EAMrB,SAAS;;;;;;EAOT,wBAAwB;;;;EAKxB,iBAAiB;;;EAIjB,iBAAiB;;UAGF;EACf;IAAY;IAAW;;EACvB;IAAa;IAAW;;EACxB;IAAc;;EACd;;UAGe;;EAEf,YAAY;;EAEZ,SAAS;;;EAGT,YAAY;;;EAGZ;IACE;IACA,YAAY;IACZ,SAAS;IACT;;;EAGF,QAAQ;IAAQ;IAAe;;;;;EAI/B;IACE;IACA;IACA;;;;;EAKF;IACE;;;IAGA;;IAEA;;IAEA;;IAEA;;IAEA;;;;;IAKA,mBAAmB,OAAO,oBAAoB;;;;EAIhD;IACE;IACA;IACA;IACA;IACA;;;UAIa;;EAEf;;EAEA;;EAEA;;UAGe;EACf,OAAO;EACP,QAAQ;EACR,WAAW;EACX,QAAQ;EACR,YAAY;EACZ;IACE;IACA;IACA;IACA;IACA;;;;UAOa;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,WAAW;;;;;EAKX,WAAW;IAAQ;IAAe;;;UAGnB;;EAEf;;EAEA;;;EAGA,cAAc;;;EAGd;;;EAGA;;;EAGA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;EAET,mBAAmB;IACjB;IACA,SAAS;MAAQ;MAAe;;IAChC;;;UAIa;EACf;EACA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;EAWA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf,UAAU;IACR;IACA;;IAEA;;IAEA;;IAEA;;EAEF;;;;;UAMe;;EAEf,cAAc;;EAEd;;EAEA;;UAGe;;EAEf;;;EAGA;EACA,UAAU;IAAQ;IAAe;IAAgB;;;UAGlC;;;EAGf;;EAEA;;EAEA;;EAEA;;EAEA;IACE;IACA;IACA;;;UAIa;;;EAGf;EACA,MAAM;IACJ;IACA;IACA;;;;EAIF;;UAGQ;;EAER;;EAEA;;;;EAIA;;EAEA;EACA;;KAGU,eACP;EACC;;EAEA;;EAEA;;EAEA;;EAEA;MAED;EACC;;EAEA;EACA;EACA;EACA;;UAGW;;EAEf;EACA;;EAEA;;;;EAIA,SAAS,eAAe;;;EAGxB;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA"}

package/dist/jev-protocol.d.ts

@@ -0,0 +1,74 @@
+//#region src/jev-protocol.d.ts
+/** Structural equivalents of the native SDK types; callers can use its builders unchanged. */
+type JevJson = string | number | boolean | null | JevJson[] | {
+  [key: string]: JevJson;
+};
+type JevState = string | {
+  [key: string]: JevJson;
+} | JevJson[] | null;
+type JevScoreCriteria = readonly [JevState, JevState, ...JevState[]];
+type JevQuestion = {
+  type: 'noul';
+  instructions?: JevState;
+  criteria?: {
+    true?: JevState;
+    false?: JevState;
+  } | null;
+} | {
+  type: 'score';
+  instructions?: JevState;
+  criteria: JevScoreCriteria;
+} | {
+  type: 'choice';
+  instructions?: JevState;
+  criteria: Record<string, JevState>;
+};
+type JevQuestions = Record<string, JevQuestion>;
+interface JevRequest<Q extends JevQuestions = JevQuestions> {
+  model: string;
+  state: JevState;
+  questions: Q;
+}
+type ScoreKeys<T extends JevScoreCriteria> = number extends T['length'] ? number : Extract<keyof T, `${number}`>;
+type JevAnswerFor<Q extends JevQuestion> = Q extends {
+  type: 'noul';
+} ? {
+  readonly type: 'noul';
+  readonly noul: number;
+} : Q extends {
+  type: 'score';
+  criteria: infer C extends JevScoreCriteria;
+} ? {
+  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 JevAnswer = JevAnswerFor<JevQuestion>;
+interface JevResult<Q extends JevQuestions = JevQuestions> {
+  readonly model: string;
+  readonly answers: { readonly [K in keyof Q]: JevAnswerFor<Q[K]>; };
+  readonly usage: {
+    readonly input_tokens: number;
+    readonly output_tokens: number;
+  };
+}
+declare class JevResponseError extends Error {
+  constructor(message: string);
+}
+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 };
+//# sourceMappingURL=jev-protocol.d.ts.map

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

@@ -0,0 +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"}

package/dist/jev-protocol.js

@@ -0,0 +1,91 @@
+import { r as canonicalString } from "./canonical-BsZVgBhW.js";
+import { isDeepStrictEqual } from "node:util";
+//#region src/jev-protocol.ts
+var JevResponseError = class extends Error {
+	constructor(message) {
+		super(`Jev: ${message}`);
+		this.name = "JevResponseError";
+	}
+};
+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");
+	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);
+	if (!Object.keys(questions).length) throw new TypeError("At least one question is required");
+	for (const rawQuestion of Object.values(questions)) {
+		const question = object(rawQuestion);
+		if (question.instructions !== void 0) entry(question.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);
+			}
+		} 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);
+		} 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);
+		} else throw new TypeError("Unsupported native question type");
+	}
+	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");
+	return usage;
+}
+function probability(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) throw new JevResponseError("Invalid probability");
+	return value;
+}
+function exactKeys(value, names) {
+	if (Object.keys(value).length !== names.length || names.some((key) => !Object.hasOwn(value, key))) throw new JevResponseError("Response keys differ from the request");
+}
+/** Validate native evidence, not model alias policy or the caller's scoring rules. */
+function parseJevResult(raw, request) {
+	canonicalString(raw);
+	const response = object(raw);
+	if (typeof response.model !== "string" || !response.model.trim()) throw new JevResponseError("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 JevResponseError("Wrong answer type");
+		if (question.type === "noul") {
+			probability(answer.noul);
+			continue;
+		}
+		probability(answer.confidence);
+		const levels = question.type === "score" ? question.criteria.map((_, index) => String(index)) : Object.keys(question.criteria);
+		const probabilities = object(answer.probabilities);
+		exactKeys(probabilities, levels);
+		const sum = levels.reduce((total, level) => total + probability(probabilities[level]), 0);
+		if (Math.abs(sum - 1) > 1e-4) throw new JevResponseError("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 JevResponseError("Provider changed the rubric");
+			const expected = levels.reduce((total, level) => total + Number(level) * Number(probabilities[level]), 0);
+			if (typeof answer.score !== "number" || !Number.isFinite(answer.score) || Math.abs(answer.score - expected) > 1e-4) throw new JevResponseError("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)]) + 1e-4)) throw new JevResponseError("Choice is not a highest-probability option");
+	}
+	jevUsage(raw);
+	return raw;
+}
+//#endregion
+export { JevResponseError, jevUsage, parseJevRequest, parseJevResult };
+
+//# sourceMappingURL=jev-protocol.js.map

package/dist/jev-protocol.js.map

@@ -0,0 +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":";;;AAkDA,IAAa,mBAAb,cAAsC,MAAM;CAC1C,YAAY,SAAiB;EAC3B,MAAM,QAAQ,SAAS;EACvB,KAAK,OAAO;CACd;AACF;AAEA,SAAS,OAAO,OAAyC;CACvD,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,GACpE,MAAM,IAAI,iBAAiB,oBAAoB;CAEjD,OAAO;AACT;AAEA,SAAS,MAAM,OAAsB;CACnC,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;CACjD,IAAI,OAAO,UAAU,UAAU,MAAM,IAAI,UAAU,2CAA2C;CAE9F,gBAAgB,KAAK;AACvB;AAEA,SAAgB,gBAAgB,KAA0B;CACxD,MAAM,UAAU,OAAO,GAAG;CAC1B,IAAI,OAAO,QAAQ,UAAU,YAAY,CAAC,QAAQ,MAAM,KAAK,GAC3D,MAAM,IAAI,UAAU,6BAA6B;CAEnD,MAAM,QAAQ,KAAK;CACnB,MAAM,YAAY,OAAO,QAAQ,SAAS;CAC1C,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,QAAQ,MAAM,IAAI,UAAU,mCAAmC;CAC3F,KAAK,MAAM,eAAe,OAAO,OAAO,SAAS,GAAG;EAClD,MAAM,WAAW,OAAO,WAAW;EACnC,IAAI,SAAS,iBAAiB,KAAA,GAAW,MAAM,SAAS,YAAY;EACpE,IAAI,SAAS,SAAS,QAChB;OAAA,SAAS,YAAY,MAAM;IAC7B,MAAM,WAAW,OAAO,SAAS,QAAQ;IACzC,IAAI,OAAO,KAAK,QAAQ,CAAC,CAAC,MAAM,QAAQ,QAAQ,UAAU,QAAQ,OAAO,GACvE,MAAM,IAAI,UAAU,+CAA+C;IAErE,KAAK,MAAM,SAAS,OAAO,OAAO,QAAQ,GACxC,IAAI,UAAU,KAAA,GAAW,MAAM,KAAK;GAExC;SACK,IAAI,SAAS,SAAS,SAAS;GACpC,IAAI,CAAC,MAAM,QAAQ,SAAS,QAAQ,KAAK,SAAS,SAAS,SAAS,GAClE,MAAM,IAAI,UAAU,qDAAqD;GAE3E,KAAK,MAAM,SAAS,SAAS,UAAU,MAAM,KAAK;EACpD,OAAO,IAAI,SAAS,SAAS,UAAU;GACrC,MAAM,WAAW,OAAO,SAAS,QAAQ;GACzC,IAAI,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,QAAQ,MAAM,IAAI,UAAU,iCAAiC;GACxF,KAAK,MAAM,SAAS,OAAO,OAAO,QAAQ,GAAG,MAAM,KAAK;EAC1D,OACE,MAAM,IAAI,UAAU,kCAAkC;CAE1D;CACA,OAAO;AACT;AAEA,SAAgB,SAAS,KAAkC;CACzD,MAAM,QAAQ,OAAO,OAAO,GAAG,CAAC,CAAC,KAAK;CACtC,KAAK,MAAM,OAAO,CAAC,gBAAgB,eAAe,GAChD,IAAI,CAAC,OAAO,cAAc,MAAM,IAAI,KAAK,OAAO,MAAM,IAAI,IAAI,GAC5D,MAAM,IAAI,iBAAiB,0BAA0B;CAGzD,OAAO;AACT;AAEA,SAAS,YAAY,OAAwB;CAC3C,IAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,KAAK,QAAQ,KAAK,QAAQ,GAC/E,MAAM,IAAI,iBAAiB,qBAAqB;CAElD,OAAO;AACT;AAEA,SAAS,UAAU,OAAgC,OAAuB;CACxE,IACE,OAAO,KAAK,KAAK,CAAC,CAAC,WAAW,MAAM,UACpC,MAAM,MAAM,QAAQ,CAAC,OAAO,OAAO,OAAO,GAAG,CAAC,GAE9C,MAAM,IAAI,iBAAiB,uCAAuC;AAEtE;;AAGA,SAAgB,eACd,KACA,SACc;CAEd,gBAAgB,GAAG;CACnB,MAAM,WAAW,OAAO,GAAG;CAC3B,IAAI,OAAO,SAAS,UAAU,YAAY,CAAC,SAAS,MAAM,KAAK,GAC7D,MAAM,IAAI,iBAAiB,sBAAsB;CAEnD,MAAM,UAAU,OAAO,SAAS,OAAO;CACvC,UAAU,SAAS,OAAO,KAAK,QAAQ,SAAS,CAAC;CACjD,KAAK,MAAM,CAAC,MAAM,aAAa,OAAO,QAAQ,QAAQ,SAAS,GAAG;EAChE,MAAM,SAAS,OAAO,QAAQ,KAAK;EACnC,IAAI,OAAO,SAAS,SAAS,MAAM,MAAM,IAAI,iBAAiB,mBAAmB;EACjF,IAAI,SAAS,SAAS,QAAQ;GAC5B,YAAY,OAAO,IAAI;GACvB;EACF;EACA,YAAY,OAAO,UAAU;EAC7B,MAAM,SACJ,SAAS,SAAS,UACd,SAAS,SAAS,KAAK,GAAG,UAAU,OAAO,KAAK,CAAC,IACjD,OAAO,KAAK,SAAS,QAAQ;EACnC,MAAM,gBAAgB,OAAO,OAAO,aAAa;EACjD,UAAU,eAAe,MAAM;EAC/B,MAAM,MAAM,OAAO,QAAQ,OAAO,UAAU,QAAQ,YAAY,cAAc,MAAM,GAAG,CAAC;EACxF,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,MAAQ,MAAM,IAAI,iBAAiB,kCAAkC;EAC7F,IAAI,SAAS,SAAS,SAAS;GAC7B,MAAM,SAAS,OAAO,OAAO,MAAM;GACnC,UAAU,QAAQ,MAAM;GACxB,IACE,OAAO,MAAM,UAAU,CAAC,kBAAkB,OAAO,QAAQ,SAAS,SAAS,OAAO,KAAK,EAAE,CAAC,GAE1F,MAAM,IAAI,iBAAiB,6BAA6B;GAE1D,MAAM,WAAW,OAAO,QACrB,OAAO,UAAU,QAAQ,OAAO,KAAK,IAAI,OAAO,cAAc,MAAM,GACrE,CACF;GACA,IACE,OAAO,OAAO,UAAU,YACxB,CAAC,OAAO,SAAS,OAAO,KAAK,KAC7B,KAAK,IAAI,OAAO,QAAQ,QAAQ,IAAI,MAEpC,MAAM,IAAI,iBAAiB,qCAAqC;EAEpE,OAAO,IACL,OAAO,OAAO,WAAW,YACzB,CAAC,OAAO,OAAO,eAAe,OAAO,MAAM,KAC3C,OAAO,MACJ,UACC,OAAO,cAAc,MAAM,IAAI,OAAO,cAAc,OAAO,OAAO,MAAM,EAAE,IAAI,IAClF,GAEA,MAAM,IAAI,iBAAiB,4CAA4C;CAE3E;CACA,SAAS,GAAG;CACZ,OAAO;AACT"}

package/dist/jev.d.ts

@@ -0,0 +1,131 @@
+import { b as CustomTokenPricing, g as CostReceiptInput } from "./cost-ledger-DbQdN3nO.js";
+import { i as AnalystFinding, n as AnalystContext, t as Analyst } from "./types-BjB2wZM9.js";
+import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-BTRcIqFr.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 { z } from "zod";
+//#region src/jev-review.d.ts
+declare const checkSchema: z.ZodObject<{
+  claim: z.ZodString;
+  area: z.ZodString;
+  subject: z.ZodString;
+  severity: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    info: "info";
+    low: "low";
+    medium: "medium";
+  }>;
+  supports: z.ZodArray<z.ZodString>;
+  refutes: z.ZodArray<z.ZodString>;
+  supportAtLeast: z.ZodNumber;
+  refuteAtLeast: z.ZodNumber;
+  coverage: z.ZodEnum<{
+    complete: "complete";
+    missing: "missing";
+    partial: "partial";
+  }>;
+  evidence: z.ZodArray<z.ZodObject<{
+    kind: z.ZodEnum<{
+      artifact: "artifact";
+      event: "event";
+      finding: "finding";
+      metric: "metric";
+      span: "span";
+    }>;
+    uri: z.ZodString;
+    excerpt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Optional interpretation of native choices/scores. Policy and evidence belong to the caller. */
+type JevReviewCheck = z.infer<typeof checkSchema>;
+interface JevReviewInput<Q extends JevQuestions = JevQuestions> {
+  version: string;
+  request: JevRequest<Q>;
+  checks: { [K in keyof Q]: JevReviewCheck; };
+}
+interface PreparedJevReview<Q extends JevQuestions = JevQuestions> extends JevReviewInput<Q> {
+  /** Binds questions, option order, context, evidence, thresholds and definition version. */
+  digest: string;
+}
+interface JevReviewAssessment {
+  question: string;
+  status: 'supported' | 'refuted' | 'unresolved';
+  reason: 'support-threshold' | 'refutation-threshold' | 'missing-evidence' | 'partial-negative-evidence' | 'below-threshold' | 'ambiguous-thresholds';
+  /** Unnormalized marginal mass of caller-designated native alternatives. Not calibrated risk. */
+  supportProbability: number;
+  refutationProbability: number;
+  unresolvedProbability: number;
+  modelConfidence: number | null;
+  check: JevReviewCheck;
+}
+interface JevReviewReport {
+  reviewDigest: string;
+  requestedModel: string;
+  servedModel: string;
+  assessments: JevReviewAssessment[];
+}
+/** Validate before paid admission; make a detached, frozen snapshot without rewriting native JSON. */
+declare function prepareJevReview<const Q extends JevQuestions>(input: JevReviewInput<Q>): PreparedJevReview<Q>;
+/** Re-score the same retained distribution without new inference or any authorization effect. */
+declare function assessJevReview<Q extends JevQuestions>(review: PreparedJevReview<Q>, raw: unknown): JevReviewReport;
+/** Ordinary analyst findings; a negative review is not a global safety certificate. */
+declare function jevReviewFindings<Q extends JevQuestions>(review: PreparedJevReview<Q>, result: JevResult<Q>, options: {
+  analystId: string;
+  producedAt?: string;
+}): AnalystFinding[];
+//#endregion
+//#region src/jev.d.ts
+type JevEvaluate = EvaluatorOptions<JevRequest, unknown>['execute'];
+interface JevEvaluatorOptions {
+  evaluate: JevEvaluate;
+  costLedger?: EvaluatorOptions<JevRequest, unknown>['costLedger'];
+  maximumCharge?: EvaluatorOptions<JevRequest, unknown>['maximumCharge'];
+  pricing?: CustomTokenPricing;
+  receipt?: (response: unknown) => CostReceiptInput;
+  receiptFromError?: (error: Error) => CostReceiptInput | undefined;
+  /** Optional deployment policy; the protocol adapter does not hardcode model aliases. */
+  acceptModel?: (requested: string, served: string) => boolean;
+}
+/** Configure transport once; supply native state, questions, and model on every invocation. */
+declare function jevEvaluator(options: JevEvaluatorOptions): <const Q extends JevQuestions>(request: JevRequest<Q>, context?: EvaluationContext) => Promise<EvaluationResult<JevResult<Q>>>;
+type Input<A, S extends Scenario> = {
+  artifact: A;
+  scenario: S;
+};
+type QuestionSource<I, Q extends JevQuestions> = Q | ((input: I) => Q | Promise<Q>);
+interface JevOptions extends JevEvaluatorOptions {
+  model: string;
+  version: string;
+  questions: JevQuestions;
+}
+interface JevJudgeOptions<A, S extends Scenario = Scenario, Q extends JevQuestions = JevQuestions> extends JevEvaluatorOptions {
+  model: string;
+  version: string;
+  questions: QuestionSource<Input<A, S>, Q>;
+  renderState: (input: Input<A, S>, context: EvaluationContext) => JevState | Promise<JevState>;
+  dimensions?: JudgeConfig<A, S>['dimensions'];
+  weights?: Record<string, number>;
+  map?: (value: JevResult<Q>, input: Input<A, S>) => JudgeScore | Promise<JudgeScore>;
+  record?: (result: EvaluationResult<JevResult<Q>>, input: Input<A, S>) => void | Promise<void>;
+  appliesTo?: (scenario: S) => boolean;
+}
+/** Optional convention. Choice utilities and non-uniform scales belong in an explicit map. */
+declare function normalizedJevScore(result: JevResult, weights?: Record<string, number>): JudgeScore;
+/** Convenience around the public evaluator. No domain questions, thresholds, or prose. */
+declare function jevJudge<A, S extends Scenario = Scenario, Q extends JevQuestions = JevQuestions>(name: string, options: JevJudgeOptions<A, S, Q>): JudgeConfig<A, S>;
+interface JevAnalystOptions<I, Q extends JevQuestions = JevQuestions> extends JevEvaluatorOptions {
+  id: string;
+  description: string;
+  inputKind: Analyst<I>['inputKind'];
+  model: string;
+  version: string;
+  questions: Q | ((input: I, context: AnalystContext) => Q | Promise<Q>);
+  renderState: (input: I, context: AnalystContext) => JevState | Promise<JevState>;
+  findings: (value: JevResult<Q>, input: I, context: AnalystContext) => AnalystFinding[] | Promise<AnalystFinding[]>;
+  record?: (result: EvaluationResult<JevResult<Q>>, input: I, context: AnalystContext) => void | Promise<void>;
+}
+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 };
+//# sourceMappingURL=jev.d.ts.map

package/dist/jev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jev.d.ts","names":[],"sources":["../src/jev-review.ts","../src/jev.ts"],"mappings":";;;;;;;cAcM,aAAW,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0Bb,EAAA,KAAA;;KAGQ,iBAAiB,EAAE,aAAa;UAC3B,eAAe,UAAU,eAAe;EACvD;EACA,SAAS,WAAW;EACpB,WAAW,WAAW,IAAI;;UAGX,kBAAkB,UAAU,eAAe,sBAClD,eAAe;;EAEvB;;UAGe;EACf;EACA;EACA;;EAQA;EACA;EACA;EACA;EACA,OAAO;;UAGQ;EACf;EACA;EACA;EACA,aAAa;;;iBAWC,uBAAuB,UAAU,cAC/C,OAAO,eAAe,KACrB,kBAAkB;;iBAuCL,gBAAgB,UAAU,cACxC,QAAQ,kBAAkB,IAC1B,eACC;;iBAyDa,kBAAkB,UAAU,cAC1C,QAAQ,kBAAkB,IAC1B,QAAQ,UAAU,IAClB;EAAW;EAAmB;IAC7B;;;KCnLS,cAAc,iBAAiB;UAC1B;EACf,UAAU;EACV,aAAa,iBAAiB;EAC9B,gBAAgB,iBAAiB;EACjC,UAAU;EACV,WAAW,sBAAsB;EACjC,oBAAoB,OAAO,UAAU;;EAErC,eAAe,mBAAmB;;;iBAIpB,aAAa,SAAS,6BA2BhB,UAAU,cAAY,SAC/B,WAAW,IAAE,UACZ,sBACT,QAAQ,iBAAiB,UAAU;KAUnC,MAAM,GAAG,UAAU;EAAc,UAAU;EAAG,UAAU;;KACxD,eAAe,GAAG,UAAU,gBAAgB,MAAM,OAAO,MAAM,IAAI,QAAQ;UAC/D,mBAAmB;EAClC;EACA;EACA,WAAW;;UAEI,gBACf,GACA,UAAU,WAAW,UACrB,UAAU,eAAe,sBACjB;EACR;EACA;EACA,WAAW,eAAe,MAAM,GAAG,IAAI;EACvC,cAAc,OAAO,MAAM,GAAG,IAAI,SAAS,sBAAsB,WAAW,QAAQ;EACpF,aAAa,YAAY,GAAG;EAC5B,UAAU;EACV,OAAO,OAAO,UAAU,IAAI,OAAO,MAAM,GAAG,OAAO,aAAa,QAAQ;EACxE,UAAU,QAAQ,iBAAiB,UAAU,KAAK,OAAO,MAAM,GAAG,cAAc;EAChF,aAAa,UAAU;;;iBA0BT,mBACd,QAAQ,WACR,UAAU,yBACT;;iBAgCa,SAAS,GAAG,UAAU,WAAW,UAAU,UAAU,eAAe,cAClF,cACA,SAAS,gBAAgB,GAAG,GAAG,KAC9B,YAAY,GAAG;UAqDD,kBAAkB,GAAG,UAAU,eAAe,sBACrD;EACR;EACA;EACA,WAAW,QAAQ;EACnB;EACA;EACA,WAAW,MAAM,OAAO,GAAG,SAAS,mBAAmB,IAAI,QAAQ;EACnE,cAAc,OAAO,GAAG,SAAS,mBAAmB,WAAW,QAAQ;EACvE,WACE,OAAO,UAAU,IACjB,OAAO,GACP,SAAS,mBACN,mBAAmB,QAAQ;EAChC,UACE,QAAQ,iBAAiB,UAAU,KACnC,OAAO,GACP,SAAS,0BACC;;iBAGE,WAAW,GAAG,UAAU,eAAe,cACrD,SAAS,kBAAkB,GAAG,KAC7B,QAAQ"}