@absolutejs/voice 0.0.22-beta.252 → 0.0.22-beta.254

package/dist/client/index.js

@@ -3000,6 +3000,84 @@ var readVoiceProofTrendReportFile = async (path, options = {}) => {
     });
   }
 };
+var maxNumber = (values) => {
+  const finite = values.filter((value) => typeof value === "number" && Number.isFinite(value));
+  return finite.length > 0 ? Math.max(...finite) : undefined;
+};
+var readProofTrendMaxLiveP95 = (report) => report.summary.maxLiveP95Ms ?? maxNumber(report.cycles.map((cycle) => cycle.liveLatency?.p95Ms));
+var readProofTrendMaxProviderP95 = (report) => report.summary.maxProviderP95Ms;
+var readProofTrendMaxTurnP95 = (report) => report.summary.maxTurnP95Ms ?? maxNumber(report.cycles.map((cycle) => cycle.turnLatency?.p95Ms));
+var evaluateVoiceProofTrendEvidence = (report, input = {}) => {
+  const issues = [];
+  const requiredStatus = input.requireStatus ?? "pass";
+  const minCycles = input.minCycles ?? 1;
+  const requireAllCyclesOk = input.requireAllCyclesOk ?? true;
+  const cycles = report.summary.cycles ?? report.cycles.length;
+  const failedCycles = report.cycles.filter((cycle) => cycle.ok !== true).length;
+  const maxLiveP95Ms = readProofTrendMaxLiveP95(report);
+  const maxProviderP95Ms = readProofTrendMaxProviderP95(report);
+  const maxTurnP95Ms = readProofTrendMaxTurnP95(report);
+  if (report.status !== requiredStatus) {
+    issues.push(`Expected proof trends status ${requiredStatus}, found ${report.status}.`);
+  }
+  if (report.ok !== true) {
+    issues.push("Expected proof trends ok to be true.");
+  }
+  if (cycles < minCycles) {
+    issues.push(`Expected at least ${String(minCycles)} proof trend cycle(s), found ${String(cycles)}.`);
+  }
+  if (requireAllCyclesOk && failedCycles > 0) {
+    issues.push(`Expected all proof trend cycles to pass, found ${String(failedCycles)} failing cycle(s).`);
+  }
+  if (input.maxAgeMs !== undefined && (report.ageMs === undefined || report.ageMs > input.maxAgeMs)) {
+    issues.push(report.ageMs === undefined ? "Missing proof trends artifact age." : `Expected proof trends age at most ${String(input.maxAgeMs)}ms, found ${String(report.ageMs)}ms.`);
+  }
+  if (input.maxLiveP95Ms !== undefined && (maxLiveP95Ms === undefined || maxLiveP95Ms > input.maxLiveP95Ms)) {
+    issues.push(maxLiveP95Ms === undefined ? "Missing proof trends live latency p95." : `Expected proof trends live latency p95 at most ${String(input.maxLiveP95Ms)}ms, found ${String(maxLiveP95Ms)}ms.`);
+  }
+  if (input.maxProviderP95Ms !== undefined && (maxProviderP95Ms === undefined || maxProviderP95Ms > input.maxProviderP95Ms)) {
+    issues.push(maxProviderP95Ms === undefined ? "Missing proof trends provider p95." : `Expected proof trends provider p95 at most ${String(input.maxProviderP95Ms)}ms, found ${String(maxProviderP95Ms)}ms.`);
+  }
+  if (input.maxTurnP95Ms !== undefined && (maxTurnP95Ms === undefined || maxTurnP95Ms > input.maxTurnP95Ms)) {
+    issues.push(maxTurnP95Ms === undefined ? "Missing proof trends turn latency p95." : `Expected proof trends turn latency p95 at most ${String(input.maxTurnP95Ms)}ms, found ${String(maxTurnP95Ms)}ms.`);
+  }
+  if (input.minLiveLatencySamples !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.liveLatency?.samples ?? 0) < input.minLiveLatencySamples).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minLiveLatencySamples)} live latency sample(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  if (input.minProviderSloEventsWithLatency !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.providerSlo?.eventsWithLatency ?? 0) < input.minProviderSloEventsWithLatency).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minProviderSloEventsWithLatency)} provider latency event(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  if (input.minTurnLatencySamples !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.turnLatency?.samples ?? 0) < input.minTurnLatencySamples).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minTurnLatencySamples)} turn latency sample(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  return {
+    ageMs: report.ageMs,
+    cycles,
+    failedCycles,
+    issues,
+    maxLiveP95Ms,
+    maxProviderP95Ms,
+    maxTurnP95Ms,
+    ok: issues.length === 0,
+    status: report.status
+  };
+};
+var assertVoiceProofTrendEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceProofTrendEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice proof trends assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var createVoiceProofTrendRoutes = (options) => {
   const path = options.path ?? "/api/voice/proof-trends";
   const routes = new Elysia({

package/dist/index.d.ts

@@ -16,8 +16,8 @@ export { buildVoiceDeliverySinkReport, createVoiceDeliverySinkDescriptor, create
 export { buildVoiceOpsActionHistoryReport, createVoiceOpsActionAuditRoutes, recordVoiceOpsActionAudit, renderVoiceOpsActionHistoryHTML } from './opsActionAuditRoutes';
 export { assertVoicePlatformCoverage, buildVoicePlatformCoverageSummary, createVoicePlatformCoverageRoutes, evaluateVoicePlatformCoverage } from './platformCoverage';
 export type { VoicePlatformCoverageAssertionInput, VoicePlatformCoverageAssertionReport, VoicePlatformCoverageEvidence, VoicePlatformCoverageRoutesOptions, VoicePlatformCoverageStatus, VoicePlatformCoverageSummary, VoicePlatformCoverageSummaryInput, VoicePlatformCoverageSurface } from './platformCoverage';
-export { buildEmptyVoiceProofTrendReport, buildVoiceProofTrendReport, createVoiceProofTrendRoutes, DEFAULT_VOICE_PROOF_TRENDS_MAX_AGE_MS, formatVoiceProofTrendAge, normalizeVoiceProofTrendReport, readVoiceProofTrendReportFile } from './proofTrends';
-export type { VoiceProofTrendCycle, VoiceProofTrendReport, VoiceProofTrendReportInput, VoiceProofTrendRoutesOptions, VoiceProofTrendStatus, VoiceProofTrendSummary } from './proofTrends';
+export { assertVoiceProofTrendEvidence, buildEmptyVoiceProofTrendReport, buildVoiceProofTrendReport, createVoiceProofTrendRoutes, DEFAULT_VOICE_PROOF_TRENDS_MAX_AGE_MS, evaluateVoiceProofTrendEvidence, formatVoiceProofTrendAge, normalizeVoiceProofTrendReport, readVoiceProofTrendReportFile } from './proofTrends';
+export type { VoiceProofTrendAssertionInput, VoiceProofTrendAssertionReport, VoiceProofTrendCycle, VoiceProofTrendReport, VoiceProofTrendReportInput, VoiceProofTrendRoutesOptions, VoiceProofTrendStatus, VoiceProofTrendSummary } from './proofTrends';
 export { buildVoiceLiveOpsControlState, createVoiceLiveOpsController, createVoiceLiveOpsRoutes, createVoiceMemoryLiveOpsControlStore, getVoiceLiveOpsControlStatus, VOICE_LIVE_OPS_ACTIONS } from './liveOps';
 export type { VoiceLiveOpsAction, VoiceLiveOpsActionInput, VoiceLiveOpsActionResult, VoiceLiveOpsControllerOptions, VoiceLiveOpsControlState, VoiceLiveOpsControlStatus, VoiceLiveOpsControlStore, VoiceLiveOpsRoutesOptions } from './liveOps';
 export { buildVoiceDeliveryRuntimeReport, createVoiceDeliveryRuntime, createVoiceDeliveryRuntimePresetConfig, createVoiceDeliveryRuntimeRoutes, renderVoiceDeliveryRuntimeHTML } from './deliveryRuntime';
@@ -54,7 +54,7 @@ export { assertVoiceProviderSloEvidence, buildVoiceProviderSloReport, createVoic
 export { createVoicePhoneAgentProductionSmokeHTMLHandler, createVoicePhoneAgentProductionSmokeJSONHandler, createVoicePhoneAgentProductionSmokeRoutes, renderVoicePhoneAgentProductionSmokeHTML, runVoicePhoneAgentProductionSmokeContract } from './phoneAgentProductionSmoke';
 export { assertVoiceProductionReadinessEvidence, buildVoiceProductionReadinessGate, buildVoiceProductionReadinessReport, createVoiceProductionReadinessRoutes, evaluateVoiceProductionReadinessEvidence, renderVoiceProductionReadinessHTML, summarizeVoiceProductionReadinessGate } from './productionReadiness';
 export { createVoiceReadinessProfile, recommendVoiceReadinessProfile } from './readinessProfiles';
-export { buildVoiceProviderContractMatrix, createVoiceProviderContractMatrixHTMLHandler, createVoiceProviderContractMatrixJSONHandler, createVoiceProviderContractMatrixPreset, createVoiceProviderContractMatrixRoutes, evaluateVoiceProviderStackGaps, renderVoiceProviderContractMatrixHTML, recommendVoiceProviderStack } from './providerStackRecommendations';
+export { assertVoiceProviderContractMatrixEvidence, assertVoiceProviderStackEvidence, buildVoiceProviderContractMatrix, createVoiceProviderContractMatrixHTMLHandler, createVoiceProviderContractMatrixJSONHandler, createVoiceProviderContractMatrixPreset, createVoiceProviderContractMatrixRoutes, evaluateVoiceProviderContractMatrixEvidence, evaluateVoiceProviderStackEvidence, evaluateVoiceProviderStackGaps, renderVoiceProviderContractMatrixHTML, recommendVoiceProviderStack } from './providerStackRecommendations';
 export { buildVoiceOpsConsoleReport, createVoiceOpsConsoleRoutes, renderVoiceOpsConsoleHTML } from './opsConsoleRoutes';
 export { assertVoiceOperationsRecordGuardrails, buildVoiceOperationsRecord, createVoiceOperationsRecordRoutes, evaluateVoiceOperationsRecordGuardrails, renderVoiceOperationsRecordGuardrailMarkdown, renderVoiceOperationsRecordHTML, renderVoiceOperationsRecordIncidentMarkdown } from './operationsRecord';
 export { assertVoiceObservabilityExportDeliveryEvidence, assertVoiceObservabilityExportRecord, assertVoiceObservabilityExportReplayEvidence, buildVoiceObservabilityArtifactIndex, buildVoiceObservabilityExportDeliveryHistory, buildVoiceObservabilityExportReplayReport, buildVoiceObservabilityExport, assertVoiceObservabilityExportSchema, createVoiceObservabilityExportSchema, createVoiceFileObservabilityExportDeliveryReceiptStore, createVoiceMemoryObservabilityExportDeliveryReceiptStore, createVoiceObservabilityExportRoutes, createVoiceObservabilityExportReplayRoutes, deliverVoiceObservabilityExport, evaluateVoiceObservabilityExportDeliveryEvidence, evaluateVoiceObservabilityExportReplayEvidence, loadVoiceObservabilityExportReplaySource, replayVoiceObservabilityExport, renderVoiceObservabilityExportReplayHTML, renderVoiceObservabilityExportMarkdown, validateVoiceObservabilityExportRecord, voiceObservabilityExportSchemaId, voiceObservabilityExportSchemaVersion } from './observabilityExport';
@@ -122,7 +122,7 @@ export type { VoiceOpsConsoleLink, VoiceOpsConsoleReport, VoiceOpsConsoleRoutesO
 export type { VoiceOpsStatus, VoiceOpsStatusLink, VoiceOpsStatusOptions, VoiceOpsStatusReport, VoiceOpsStatusRoutesOptions } from './opsStatus';
 export type { VoiceProductionReadinessAction, VoiceProductionReadinessAuditOptions, VoiceProductionReadinessAuditRequirement, VoiceProductionReadinessAuditSummary, VoiceProductionReadinessAssertionInput, VoiceProductionReadinessAssertionReport, VoiceProductionReadinessCheck, VoiceProductionReadinessGateIssue, VoiceProductionReadinessGateOptions, VoiceProductionReadinessGateProfile, VoiceProductionReadinessGateProfileSurface, VoiceProductionReadinessGateReport, VoiceProductionReadinessOpsActionHistoryOptions, VoiceProductionReadinessOpsActionHistorySummary, VoiceProductionReadinessOperationsRecordLink, VoiceProductionReadinessOperationsRecordLinks, VoiceProductionReadinessProfileExplanation, VoiceProductionReadinessProfileSurface, VoiceProductionReadinessProofSource, VoiceProductionReadinessReport, VoiceProductionReadinessRoutesOptions, VoiceProductionReadinessTraceDeliverySummary, VoiceProductionReadinessAuditDeliveryOptions, VoiceProductionReadinessAuditDeliverySummary, VoiceProductionReadinessTraceDeliveryOptions, VoiceProductionReadinessStatus } from './productionReadiness';
 export type { VoiceReadinessProfileName, VoiceReadinessProfileOptions, VoiceReadinessProfileRecommendation, VoiceReadinessProfileRecommendationScore, VoiceReadinessProfileRoutesOptions } from './readinessProfiles';
-export type { VoiceProviderStackChoice, VoiceProviderStackCapabilities, VoiceProviderStackCapabilityGap, VoiceProviderStackCapabilityGapInput, VoiceProviderStackCapabilityGapReport, VoiceProviderContractCheck, VoiceProviderContractCheckStatus, VoiceProviderContractDefinition, VoiceProviderContractMatrixHandlerOptions, VoiceProviderContractMatrixHTMLHandlerOptions, VoiceProviderContractMatrixInput, VoiceProviderContractMatrixPresetOptions, VoiceProviderContractMatrixReport, VoiceProviderContractMatrixRoutesOptions, VoiceProviderContractMatrixRow, VoiceProviderStackInput, VoiceProviderStackKind, VoiceProviderStackRecommendation } from './providerStackRecommendations';
+export type { VoiceProviderStackChoice, VoiceProviderStackCapabilities, VoiceProviderStackCapabilityGap, VoiceProviderStackCapabilityGapInput, VoiceProviderStackCapabilityGapReport, VoiceProviderContractCheck, VoiceProviderContractCheckStatus, VoiceProviderContractDefinition, VoiceProviderContractMatrixAssertionInput, VoiceProviderContractMatrixAssertionReport, VoiceProviderContractMatrixHandlerOptions, VoiceProviderContractMatrixHTMLHandlerOptions, VoiceProviderContractMatrixInput, VoiceProviderContractMatrixPresetOptions, VoiceProviderContractMatrixReport, VoiceProviderContractMatrixRoutesOptions, VoiceProviderContractMatrixRow, VoiceProviderStackAssertionInput, VoiceProviderStackAssertionReport, VoiceProviderStackInput, VoiceProviderStackKind, VoiceProviderStackRecommendation } from './providerStackRecommendations';
 export type { VoiceOperationsRecord, VoiceOperationsRecordAgentHandoff, VoiceOperationsRecordAuditSummary, VoiceOperationsRecordGuardrailAssertionInput, VoiceOperationsRecordGuardrailAssertionReport, VoiceOperationsRecordGuardrailDecision, VoiceOperationsRecordGuardrailFinding, VoiceOperationsRecordGuardrailSummary, VoiceOperationsRecordIntegrationEventSummary, VoiceOperationsRecordOptions, VoiceOperationsRecordOutcome, VoiceOperationsRecordProviderDecision, VoiceOperationsRecordReviewSummary, VoiceOperationsRecordRoutesOptions, VoiceOperationsRecordStatus, VoiceOperationsRecordTaskSummary, VoiceOperationsRecordTranscriptTurn, VoiceOperationsRecordTool } from './operationsRecord';
 export type { VoiceObservabilityExportArtifact, VoiceObservabilityExportArtifactChecksum, VoiceObservabilityExportArtifactFreshness, VoiceObservabilityExportArtifactIndex, VoiceObservabilityExportArtifactIndexItem, VoiceObservabilityExportArtifactKind, VoiceObservabilityExportDeliveryAssertionInput, VoiceObservabilityExportDeliveryAssertionReport, VoiceObservabilityExportDeliverySummary, VoiceObservabilityExportDeliveryDestination, VoiceObservabilityExportDeliveryDestinationResult, VoiceObservabilityExportDeliveryHistory, VoiceObservabilityExportDeliveryOptions, VoiceObservabilityExportDeliveryReceipt, VoiceObservabilityExportDeliveryReceiptStore, VoiceObservabilityExportDeliveryReport, VoiceObservabilityExportEnvelope, VoiceObservabilityExportIssue, VoiceObservabilityExportIssueCode, VoiceObservabilityExportOptions, VoiceObservabilityExportIngestedRecordKind, VoiceObservabilityExportRedactionSummary, VoiceObservabilityExportRecordValidationOptions, VoiceObservabilityExportReplayIssue, VoiceObservabilityExportReplayIssueCode, VoiceObservabilityExportReplayAssertionInput, VoiceObservabilityExportReplayAssertionReport, VoiceObservabilityExportReplayRecords, VoiceObservabilityExportReplayReport, VoiceObservabilityExportReplayRoutesOptions, VoiceObservabilityExportReplaySource, VoiceObservabilityExportReport, VoiceObservabilityExportRoutesOptions, VoiceObservabilityExportSchema, VoiceObservabilityExportStatus, VoiceObservabilityExportValidationIssue, VoiceObservabilityExportValidationResult } from './observabilityExport';
 export type { VoiceOpsRecoveryFailedSession, VoiceOpsRecoveryInterventionSummary, VoiceOpsRecoveryIssue, VoiceOpsRecoveryIssueCode, VoiceOpsRecoveryLinks, VoiceOpsRecoveryProviderSummary, VoiceOpsRecoveryReport, VoiceOpsRecoveryReportOptions, VoiceOpsRecoveryRoutesOptions, VoiceOpsRecoveryStatus } from './opsRecovery';

package/dist/index.js

@@ -12405,6 +12405,84 @@ var readVoiceProofTrendReportFile = async (path, options = {}) => {
     });
   }
 };
+var maxNumber = (values) => {
+  const finite = values.filter((value) => typeof value === "number" && Number.isFinite(value));
+  return finite.length > 0 ? Math.max(...finite) : undefined;
+};
+var readProofTrendMaxLiveP95 = (report) => report.summary.maxLiveP95Ms ?? maxNumber(report.cycles.map((cycle) => cycle.liveLatency?.p95Ms));
+var readProofTrendMaxProviderP95 = (report) => report.summary.maxProviderP95Ms;
+var readProofTrendMaxTurnP95 = (report) => report.summary.maxTurnP95Ms ?? maxNumber(report.cycles.map((cycle) => cycle.turnLatency?.p95Ms));
+var evaluateVoiceProofTrendEvidence = (report, input = {}) => {
+  const issues = [];
+  const requiredStatus = input.requireStatus ?? "pass";
+  const minCycles = input.minCycles ?? 1;
+  const requireAllCyclesOk = input.requireAllCyclesOk ?? true;
+  const cycles = report.summary.cycles ?? report.cycles.length;
+  const failedCycles = report.cycles.filter((cycle) => cycle.ok !== true).length;
+  const maxLiveP95Ms = readProofTrendMaxLiveP95(report);
+  const maxProviderP95Ms = readProofTrendMaxProviderP95(report);
+  const maxTurnP95Ms = readProofTrendMaxTurnP95(report);
+  if (report.status !== requiredStatus) {
+    issues.push(`Expected proof trends status ${requiredStatus}, found ${report.status}.`);
+  }
+  if (report.ok !== true) {
+    issues.push("Expected proof trends ok to be true.");
+  }
+  if (cycles < minCycles) {
+    issues.push(`Expected at least ${String(minCycles)} proof trend cycle(s), found ${String(cycles)}.`);
+  }
+  if (requireAllCyclesOk && failedCycles > 0) {
+    issues.push(`Expected all proof trend cycles to pass, found ${String(failedCycles)} failing cycle(s).`);
+  }
+  if (input.maxAgeMs !== undefined && (report.ageMs === undefined || report.ageMs > input.maxAgeMs)) {
+    issues.push(report.ageMs === undefined ? "Missing proof trends artifact age." : `Expected proof trends age at most ${String(input.maxAgeMs)}ms, found ${String(report.ageMs)}ms.`);
+  }
+  if (input.maxLiveP95Ms !== undefined && (maxLiveP95Ms === undefined || maxLiveP95Ms > input.maxLiveP95Ms)) {
+    issues.push(maxLiveP95Ms === undefined ? "Missing proof trends live latency p95." : `Expected proof trends live latency p95 at most ${String(input.maxLiveP95Ms)}ms, found ${String(maxLiveP95Ms)}ms.`);
+  }
+  if (input.maxProviderP95Ms !== undefined && (maxProviderP95Ms === undefined || maxProviderP95Ms > input.maxProviderP95Ms)) {
+    issues.push(maxProviderP95Ms === undefined ? "Missing proof trends provider p95." : `Expected proof trends provider p95 at most ${String(input.maxProviderP95Ms)}ms, found ${String(maxProviderP95Ms)}ms.`);
+  }
+  if (input.maxTurnP95Ms !== undefined && (maxTurnP95Ms === undefined || maxTurnP95Ms > input.maxTurnP95Ms)) {
+    issues.push(maxTurnP95Ms === undefined ? "Missing proof trends turn latency p95." : `Expected proof trends turn latency p95 at most ${String(input.maxTurnP95Ms)}ms, found ${String(maxTurnP95Ms)}ms.`);
+  }
+  if (input.minLiveLatencySamples !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.liveLatency?.samples ?? 0) < input.minLiveLatencySamples).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minLiveLatencySamples)} live latency sample(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  if (input.minProviderSloEventsWithLatency !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.providerSlo?.eventsWithLatency ?? 0) < input.minProviderSloEventsWithLatency).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minProviderSloEventsWithLatency)} provider latency event(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  if (input.minTurnLatencySamples !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.turnLatency?.samples ?? 0) < input.minTurnLatencySamples).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minTurnLatencySamples)} turn latency sample(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  return {
+    ageMs: report.ageMs,
+    cycles,
+    failedCycles,
+    issues,
+    maxLiveP95Ms,
+    maxProviderP95Ms,
+    maxTurnP95Ms,
+    ok: issues.length === 0,
+    status: report.status
+  };
+};
+var assertVoiceProofTrendEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceProofTrendEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice proof trends assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var createVoiceProofTrendRoutes = (options) => {
   const path = options.path ?? "/api/voice/proof-trends";
   const routes = new Elysia14({
@@ -26652,6 +26730,12 @@ var recommendVoiceProviderStack = (input) => {
   };
 };
 var rollupContractStatus = (checks) => checks.some((check) => check.status === "fail") ? "fail" : checks.some((check) => check.status === "warn") ? "warn" : "pass";
+var statusRank2 = {
+  pass: 0,
+  warn: 1,
+  fail: 2
+};
+var statusExceeds = (actual, max) => statusRank2[actual] > statusRank2[max];
 var buildVoiceProviderContractMatrix = (input) => {
   const rows = input.contracts.map((contract) => {
     const configured = contract.configured !== false;
@@ -26752,6 +26836,76 @@ var buildVoiceProviderContractMatrix = (input) => {
     warned
   };
 };
+var evaluateVoiceProviderContractMatrixEvidence = (report, input = {}) => {
+  const issues = [];
+  const maxStatus = input.maxStatus ?? "pass";
+  const maxFailed = input.maxFailed ?? 0;
+  const maxWarned = input.maxWarned ?? 0;
+  const minRows = input.minRows ?? 1;
+  const requireAllSelected = input.requireAllSelected ?? false;
+  const kinds = [...new Set(report.rows.map((row) => row.kind))].sort();
+  const providers = [...new Set(report.rows.map((row) => row.provider))].sort();
+  const selectedKinds = [
+    ...new Set(report.rows.filter((row) => row.selected).map((row) => row.kind))
+  ].sort();
+  if (statusExceeds(report.status, maxStatus)) {
+    issues.push(`Expected provider contract matrix status at most ${maxStatus}, found ${report.status}.`);
+  }
+  if (report.failed > maxFailed) {
+    issues.push(`Expected at most ${String(maxFailed)} failing provider contract row(s), found ${String(report.failed)}.`);
+  }
+  if (report.warned > maxWarned) {
+    issues.push(`Expected at most ${String(maxWarned)} warning provider contract row(s), found ${String(report.warned)}.`);
+  }
+  if (report.total < minRows) {
+    issues.push(`Expected at least ${String(minRows)} provider contract row(s), found ${String(report.total)}.`);
+  }
+  for (const kind of input.requiredKinds ?? []) {
+    if (!kinds.includes(kind)) {
+      issues.push(`Missing provider contract kind: ${kind}.`);
+    }
+  }
+  for (const provider of input.requiredProviders ?? []) {
+    if (!providers.includes(provider)) {
+      issues.push(`Missing provider contract provider: ${provider}.`);
+    }
+  }
+  for (const kind of input.selectedKinds ?? []) {
+    if (!selectedKinds.includes(kind)) {
+      issues.push(`Missing selected provider contract kind: ${kind}.`);
+    }
+  }
+  for (const key of input.requiredCheckKeys ?? []) {
+    const missingRows = report.rows.filter((row) => !row.checks.some((check) => check.key === key)).length;
+    if (missingRows > 0) {
+      issues.push(`Provider contract check ${key} is missing from ${String(missingRows)} row(s).`);
+    }
+  }
+  if (requireAllSelected) {
+    const unselected = report.rows.filter((row) => !row.selected).length;
+    if (unselected > 0) {
+      issues.push(`Expected every provider contract row to be selected, found ${String(unselected)} unselected row(s).`);
+    }
+  }
+  return {
+    failed: report.failed,
+    issues,
+    kinds,
+    ok: issues.length === 0,
+    providers,
+    selectedKinds,
+    status: report.status,
+    total: report.total,
+    warned: report.warned
+  };
+};
+var assertVoiceProviderContractMatrixEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceProviderContractMatrixEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice provider contract matrix assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var createVoiceProviderContractMatrixPreset = (profile, options) => {
   const contracts = ["llm", "stt", "tts"].flatMap((kind) => {
     const providers = options.providers[kind] ?? [];
@@ -26887,6 +27041,65 @@ var evaluateVoiceProviderStackGaps = (input) => {
     status: gaps.some((gap) => gap.status === "fail") ? "fail" : gaps.some((gap) => gap.status === "warn") ? "warn" : "pass"
   };
 };
+var evaluateVoiceProviderStackEvidence = (report, input = {}) => {
+  const issues = [];
+  const maxStatus = input.maxStatus ?? "pass";
+  const maxMissing = input.maxMissing ?? 0;
+  const requireProviders = input.requireProviders ?? true;
+  const kinds = [...new Set(report.gaps.map((gap) => gap.kind))].sort();
+  const providers = [
+    ...new Set(report.gaps.map((gap) => gap.provider).filter((provider) => provider !== undefined))
+  ].sort();
+  if (statusExceeds(report.status, maxStatus)) {
+    issues.push(`Expected provider stack status at most ${maxStatus}, found ${report.status}.`);
+  }
+  if (report.missing > maxMissing) {
+    issues.push(`Expected at most ${String(maxMissing)} missing provider stack capability/capabilities, found ${String(report.missing)}.`);
+  }
+  for (const kind of input.requiredKinds ?? []) {
+    if (!kinds.includes(kind)) {
+      issues.push(`Missing provider stack kind: ${kind}.`);
+    }
+  }
+  for (const provider of input.requiredProviders ?? []) {
+    if (!providers.includes(provider)) {
+      issues.push(`Missing provider stack provider: ${provider}.`);
+    }
+  }
+  for (const [kind, capabilities] of Object.entries(input.requiredCapabilities ?? {})) {
+    const gap = report.gaps.find((entry) => entry.kind === kind);
+    if (!gap) {
+      issues.push(`Missing provider stack kind: ${kind}.`);
+      continue;
+    }
+    for (const capability of capabilities) {
+      if (!includesCapability(gap.present, capability)) {
+        issues.push(`Missing provider stack capability for ${kind}: ${capability}.`);
+      }
+    }
+  }
+  if (requireProviders) {
+    const missingProviders = report.gaps.filter((gap) => !gap.provider).map((gap) => gap.kind);
+    if (missingProviders.length > 0) {
+      issues.push(`Missing provider stack provider for kind(s): ${missingProviders.join(", ")}.`);
+    }
+  }
+  return {
+    issues,
+    kinds,
+    missing: report.missing,
+    ok: issues.length === 0,
+    providers,
+    status: report.status
+  };
+};
+var assertVoiceProviderStackEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceProviderStackEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice provider stack assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 // src/opsConsoleRoutes.ts
 import { Elysia as Elysia44 } from "elysia";
 var DEFAULT_LINKS = [
@@ -30296,7 +30509,10 @@ export {
   evaluateVoiceTelephonyContract,
   evaluateVoiceQuality,
   evaluateVoiceProviderStackGaps,
+  evaluateVoiceProviderStackEvidence,
   evaluateVoiceProviderSloEvidence,
+  evaluateVoiceProviderContractMatrixEvidence,
+  evaluateVoiceProofTrendEvidence,
   evaluateVoiceProductionReadinessEvidence,
   evaluateVoicePlatformCoverage,
   evaluateVoiceOperationsRecordGuardrails,
@@ -30614,8 +30830,11 @@ export {
   buildVoiceAuditDeliveryReport,
   buildEmptyVoiceProofTrendReport,
   assignVoiceOpsTask,
+  assertVoiceProviderStackEvidence,
   assertVoiceProviderSloEvidence,
   assertVoiceProviderRoutingContract,
+  assertVoiceProviderContractMatrixEvidence,
+  assertVoiceProofTrendEvidence,
   assertVoiceProductionReadinessEvidence,
   assertVoicePlatformCoverage,
   assertVoiceOperationsRecordGuardrails,

package/dist/proofTrends.d.ts

@@ -59,6 +59,29 @@ export type VoiceProofTrendReport = {
     status: VoiceProofTrendStatus;
     summary: VoiceProofTrendSummary;
 };
+export type VoiceProofTrendAssertionInput = {
+    maxAgeMs?: number;
+    maxLiveP95Ms?: number;
+    maxProviderP95Ms?: number;
+    maxTurnP95Ms?: number;
+    minCycles?: number;
+    minLiveLatencySamples?: number;
+    minProviderSloEventsWithLatency?: number;
+    minTurnLatencySamples?: number;
+    requireAllCyclesOk?: boolean;
+    requireStatus?: VoiceProofTrendStatus;
+};
+export type VoiceProofTrendAssertionReport = {
+    ageMs?: number;
+    cycles: number;
+    failedCycles: number;
+    issues: string[];
+    maxLiveP95Ms?: number;
+    maxProviderP95Ms?: number;
+    maxTurnP95Ms?: number;
+    ok: boolean;
+    status: VoiceProofTrendStatus;
+};
 export type VoiceProofTrendRoutesOptions = {
     headers?: HeadersInit;
     jsonPath?: string;
@@ -77,6 +100,8 @@ export declare const normalizeVoiceProofTrendReport: (value: VoiceProofTrendRepo
 export declare const readVoiceProofTrendReportFile: (path: string, options?: {
     maxAgeMs?: number;
 }) => Promise<VoiceProofTrendReport>;
+export declare const evaluateVoiceProofTrendEvidence: (report: VoiceProofTrendReport, input?: VoiceProofTrendAssertionInput) => VoiceProofTrendAssertionReport;
+export declare const assertVoiceProofTrendEvidence: (report: VoiceProofTrendReport, input?: VoiceProofTrendAssertionInput) => VoiceProofTrendAssertionReport;
 export declare const createVoiceProofTrendRoutes: (options: VoiceProofTrendRoutesOptions) => Elysia<"", {
     decorator: {};
     store: {};

package/dist/providerStackRecommendations.d.ts

@@ -31,6 +31,22 @@ export type VoiceProviderStackCapabilityGapReport<TProvider extends string = str
     profile: VoiceReadinessProfileName;
     status: 'fail' | 'pass' | 'warn';
 };
+export type VoiceProviderStackAssertionInput<TProvider extends string = string> = {
+    maxMissing?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    requireProviders?: boolean;
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    requiredCapabilities?: Partial<Record<VoiceProviderStackKind, readonly string[]>>;
+};
+export type VoiceProviderStackAssertionReport<TProvider extends string = string> = {
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    missing: number;
+    ok: boolean;
+    providers: TProvider[];
+    status: VoiceProviderContractCheckStatus;
+};
 export type VoiceProviderStackCapabilityGapInput<TProvider extends string = string> = VoiceProviderStackInput<TProvider> & {
     capabilities?: VoiceProviderStackCapabilities<TProvider>;
     recommendation?: VoiceProviderStackRecommendation<TProvider>;
@@ -106,8 +122,32 @@ export type VoiceProviderContractMatrixReport<TProvider extends string = string>
     total: number;
     warned: number;
 };
+export type VoiceProviderContractMatrixAssertionInput<TProvider extends string = string> = {
+    maxFailed?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    maxWarned?: number;
+    minRows?: number;
+    requireAllSelected?: boolean;
+    requiredCheckKeys?: string[];
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    selectedKinds?: VoiceProviderStackKind[];
+};
+export type VoiceProviderContractMatrixAssertionReport<TProvider extends string = string> = {
+    failed: number;
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    ok: boolean;
+    providers: TProvider[];
+    selectedKinds: VoiceProviderStackKind[];
+    status: VoiceProviderContractCheckStatus;
+    total: number;
+    warned: number;
+};
 export declare const recommendVoiceProviderStack: <TProvider extends string = string>(input: VoiceProviderStackInput<TProvider>) => VoiceProviderStackRecommendation<TProvider>;
 export declare const buildVoiceProviderContractMatrix: <TProvider extends string = string>(input: VoiceProviderContractMatrixInput<TProvider>) => VoiceProviderContractMatrixReport<TProvider>;
+export declare const evaluateVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
+export declare const assertVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
 export declare const createVoiceProviderContractMatrixPreset: <TProvider extends string = string>(profile: VoiceReadinessProfileName, options: VoiceProviderContractMatrixPresetOptions<TProvider>) => VoiceProviderContractMatrixInput<TProvider>;
 export declare const renderVoiceProviderContractMatrixHTML: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, options?: {
     title?: string;
@@ -143,3 +183,5 @@ export declare const createVoiceProviderContractMatrixRoutes: <TProvider extends
     response: {};
 }>;
 export declare const evaluateVoiceProviderStackGaps: <TProvider extends string = string>(input: VoiceProviderStackCapabilityGapInput<TProvider>) => VoiceProviderStackCapabilityGapReport<TProvider>;
+export declare const evaluateVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;
+export declare const assertVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;

package/dist/react/index.js

@@ -1564,6 +1564,84 @@ var readVoiceProofTrendReportFile = async (path, options = {}) => {
     });
   }
 };
+var maxNumber = (values) => {
+  const finite = values.filter((value) => typeof value === "number" && Number.isFinite(value));
+  return finite.length > 0 ? Math.max(...finite) : undefined;
+};
+var readProofTrendMaxLiveP95 = (report) => report.summary.maxLiveP95Ms ?? maxNumber(report.cycles.map((cycle) => cycle.liveLatency?.p95Ms));
+var readProofTrendMaxProviderP95 = (report) => report.summary.maxProviderP95Ms;
+var readProofTrendMaxTurnP95 = (report) => report.summary.maxTurnP95Ms ?? maxNumber(report.cycles.map((cycle) => cycle.turnLatency?.p95Ms));
+var evaluateVoiceProofTrendEvidence = (report, input = {}) => {
+  const issues = [];
+  const requiredStatus = input.requireStatus ?? "pass";
+  const minCycles = input.minCycles ?? 1;
+  const requireAllCyclesOk = input.requireAllCyclesOk ?? true;
+  const cycles = report.summary.cycles ?? report.cycles.length;
+  const failedCycles = report.cycles.filter((cycle) => cycle.ok !== true).length;
+  const maxLiveP95Ms = readProofTrendMaxLiveP95(report);
+  const maxProviderP95Ms = readProofTrendMaxProviderP95(report);
+  const maxTurnP95Ms = readProofTrendMaxTurnP95(report);
+  if (report.status !== requiredStatus) {
+    issues.push(`Expected proof trends status ${requiredStatus}, found ${report.status}.`);
+  }
+  if (report.ok !== true) {
+    issues.push("Expected proof trends ok to be true.");
+  }
+  if (cycles < minCycles) {
+    issues.push(`Expected at least ${String(minCycles)} proof trend cycle(s), found ${String(cycles)}.`);
+  }
+  if (requireAllCyclesOk && failedCycles > 0) {
+    issues.push(`Expected all proof trend cycles to pass, found ${String(failedCycles)} failing cycle(s).`);
+  }
+  if (input.maxAgeMs !== undefined && (report.ageMs === undefined || report.ageMs > input.maxAgeMs)) {
+    issues.push(report.ageMs === undefined ? "Missing proof trends artifact age." : `Expected proof trends age at most ${String(input.maxAgeMs)}ms, found ${String(report.ageMs)}ms.`);
+  }
+  if (input.maxLiveP95Ms !== undefined && (maxLiveP95Ms === undefined || maxLiveP95Ms > input.maxLiveP95Ms)) {
+    issues.push(maxLiveP95Ms === undefined ? "Missing proof trends live latency p95." : `Expected proof trends live latency p95 at most ${String(input.maxLiveP95Ms)}ms, found ${String(maxLiveP95Ms)}ms.`);
+  }
+  if (input.maxProviderP95Ms !== undefined && (maxProviderP95Ms === undefined || maxProviderP95Ms > input.maxProviderP95Ms)) {
+    issues.push(maxProviderP95Ms === undefined ? "Missing proof trends provider p95." : `Expected proof trends provider p95 at most ${String(input.maxProviderP95Ms)}ms, found ${String(maxProviderP95Ms)}ms.`);
+  }
+  if (input.maxTurnP95Ms !== undefined && (maxTurnP95Ms === undefined || maxTurnP95Ms > input.maxTurnP95Ms)) {
+    issues.push(maxTurnP95Ms === undefined ? "Missing proof trends turn latency p95." : `Expected proof trends turn latency p95 at most ${String(input.maxTurnP95Ms)}ms, found ${String(maxTurnP95Ms)}ms.`);
+  }
+  if (input.minLiveLatencySamples !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.liveLatency?.samples ?? 0) < input.minLiveLatencySamples).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minLiveLatencySamples)} live latency sample(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  if (input.minProviderSloEventsWithLatency !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.providerSlo?.eventsWithLatency ?? 0) < input.minProviderSloEventsWithLatency).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minProviderSloEventsWithLatency)} provider latency event(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  if (input.minTurnLatencySamples !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.turnLatency?.samples ?? 0) < input.minTurnLatencySamples).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minTurnLatencySamples)} turn latency sample(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  return {
+    ageMs: report.ageMs,
+    cycles,
+    failedCycles,
+    issues,
+    maxLiveP95Ms,
+    maxProviderP95Ms,
+    maxTurnP95Ms,
+    ok: issues.length === 0,
+    status: report.status
+  };
+};
+var assertVoiceProofTrendEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceProofTrendEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice proof trends assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var createVoiceProofTrendRoutes = (options) => {
   const path = options.path ?? "/api/voice/proof-trends";
   const routes = new Elysia({

package/dist/vue/index.js

@@ -1485,6 +1485,84 @@ var readVoiceProofTrendReportFile = async (path, options = {}) => {
     });
   }
 };
+var maxNumber = (values) => {
+  const finite = values.filter((value) => typeof value === "number" && Number.isFinite(value));
+  return finite.length > 0 ? Math.max(...finite) : undefined;
+};
+var readProofTrendMaxLiveP95 = (report) => report.summary.maxLiveP95Ms ?? maxNumber(report.cycles.map((cycle) => cycle.liveLatency?.p95Ms));
+var readProofTrendMaxProviderP95 = (report) => report.summary.maxProviderP95Ms;
+var readProofTrendMaxTurnP95 = (report) => report.summary.maxTurnP95Ms ?? maxNumber(report.cycles.map((cycle) => cycle.turnLatency?.p95Ms));
+var evaluateVoiceProofTrendEvidence = (report, input = {}) => {
+  const issues = [];
+  const requiredStatus = input.requireStatus ?? "pass";
+  const minCycles = input.minCycles ?? 1;
+  const requireAllCyclesOk = input.requireAllCyclesOk ?? true;
+  const cycles = report.summary.cycles ?? report.cycles.length;
+  const failedCycles = report.cycles.filter((cycle) => cycle.ok !== true).length;
+  const maxLiveP95Ms = readProofTrendMaxLiveP95(report);
+  const maxProviderP95Ms = readProofTrendMaxProviderP95(report);
+  const maxTurnP95Ms = readProofTrendMaxTurnP95(report);
+  if (report.status !== requiredStatus) {
+    issues.push(`Expected proof trends status ${requiredStatus}, found ${report.status}.`);
+  }
+  if (report.ok !== true) {
+    issues.push("Expected proof trends ok to be true.");
+  }
+  if (cycles < minCycles) {
+    issues.push(`Expected at least ${String(minCycles)} proof trend cycle(s), found ${String(cycles)}.`);
+  }
+  if (requireAllCyclesOk && failedCycles > 0) {
+    issues.push(`Expected all proof trend cycles to pass, found ${String(failedCycles)} failing cycle(s).`);
+  }
+  if (input.maxAgeMs !== undefined && (report.ageMs === undefined || report.ageMs > input.maxAgeMs)) {
+    issues.push(report.ageMs === undefined ? "Missing proof trends artifact age." : `Expected proof trends age at most ${String(input.maxAgeMs)}ms, found ${String(report.ageMs)}ms.`);
+  }
+  if (input.maxLiveP95Ms !== undefined && (maxLiveP95Ms === undefined || maxLiveP95Ms > input.maxLiveP95Ms)) {
+    issues.push(maxLiveP95Ms === undefined ? "Missing proof trends live latency p95." : `Expected proof trends live latency p95 at most ${String(input.maxLiveP95Ms)}ms, found ${String(maxLiveP95Ms)}ms.`);
+  }
+  if (input.maxProviderP95Ms !== undefined && (maxProviderP95Ms === undefined || maxProviderP95Ms > input.maxProviderP95Ms)) {
+    issues.push(maxProviderP95Ms === undefined ? "Missing proof trends provider p95." : `Expected proof trends provider p95 at most ${String(input.maxProviderP95Ms)}ms, found ${String(maxProviderP95Ms)}ms.`);
+  }
+  if (input.maxTurnP95Ms !== undefined && (maxTurnP95Ms === undefined || maxTurnP95Ms > input.maxTurnP95Ms)) {
+    issues.push(maxTurnP95Ms === undefined ? "Missing proof trends turn latency p95." : `Expected proof trends turn latency p95 at most ${String(input.maxTurnP95Ms)}ms, found ${String(maxTurnP95Ms)}ms.`);
+  }
+  if (input.minLiveLatencySamples !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.liveLatency?.samples ?? 0) < input.minLiveLatencySamples).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minLiveLatencySamples)} live latency sample(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  if (input.minProviderSloEventsWithLatency !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.providerSlo?.eventsWithLatency ?? 0) < input.minProviderSloEventsWithLatency).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minProviderSloEventsWithLatency)} provider latency event(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  if (input.minTurnLatencySamples !== undefined) {
+    const lowSamples = report.cycles.filter((cycle) => (cycle.turnLatency?.samples ?? 0) < input.minTurnLatencySamples).length;
+    if (lowSamples > 0) {
+      issues.push(`Expected every proof trend cycle to have at least ${String(input.minTurnLatencySamples)} turn latency sample(s), found ${String(lowSamples)} low-sample cycle(s).`);
+    }
+  }
+  return {
+    ageMs: report.ageMs,
+    cycles,
+    failedCycles,
+    issues,
+    maxLiveP95Ms,
+    maxProviderP95Ms,
+    maxTurnP95Ms,
+    ok: issues.length === 0,
+    status: report.status
+  };
+};
+var assertVoiceProofTrendEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceProofTrendEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice proof trends assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var createVoiceProofTrendRoutes = (options) => {
   const path = options.path ?? "/api/voice/proof-trends";
   const routes = new Elysia({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.252",
+	"version": "0.0.22-beta.254",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",