@absolutejs/voice 0.0.22-beta.251 → 0.0.22-beta.253

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';
@@ -57,7 +57,7 @@ export { createVoiceReadinessProfile, recommendVoiceReadinessProfile } from './r
 export { buildVoiceProviderContractMatrix, createVoiceProviderContractMatrixHTMLHandler, createVoiceProviderContractMatrixJSONHandler, createVoiceProviderContractMatrixPreset, createVoiceProviderContractMatrixRoutes, evaluateVoiceProviderStackGaps, renderVoiceProviderContractMatrixHTML, recommendVoiceProviderStack } from './providerStackRecommendations';
 export { buildVoiceOpsConsoleReport, createVoiceOpsConsoleRoutes, renderVoiceOpsConsoleHTML } from './opsConsoleRoutes';
 export { assertVoiceOperationsRecordGuardrails, buildVoiceOperationsRecord, createVoiceOperationsRecordRoutes, evaluateVoiceOperationsRecordGuardrails, renderVoiceOperationsRecordGuardrailMarkdown, renderVoiceOperationsRecordHTML, renderVoiceOperationsRecordIncidentMarkdown } from './operationsRecord';
-export { assertVoiceObservabilityExportRecord, buildVoiceObservabilityArtifactIndex, buildVoiceObservabilityExportDeliveryHistory, buildVoiceObservabilityExportReplayReport, buildVoiceObservabilityExport, assertVoiceObservabilityExportSchema, createVoiceObservabilityExportSchema, createVoiceFileObservabilityExportDeliveryReceiptStore, createVoiceMemoryObservabilityExportDeliveryReceiptStore, createVoiceObservabilityExportRoutes, createVoiceObservabilityExportReplayRoutes, deliverVoiceObservabilityExport, loadVoiceObservabilityExportReplaySource, replayVoiceObservabilityExport, renderVoiceObservabilityExportReplayHTML, renderVoiceObservabilityExportMarkdown, validateVoiceObservabilityExportRecord, voiceObservabilityExportSchemaId, voiceObservabilityExportSchemaVersion } from './observabilityExport';
+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';
 export { buildVoiceOpsRecoveryReadinessCheck, buildVoiceOpsRecoveryReport, createVoiceOpsRecoveryRoutes, renderVoiceOpsRecoveryHTML, renderVoiceOpsRecoveryMarkdown } from './opsRecovery';
 export { buildVoiceIncidentBundle, createStoredVoiceIncidentBundleArtifact, createVoiceIncidentBundleRoutes, createVoiceMemoryIncidentBundleStore, pruneVoiceIncidentBundleArtifacts, saveVoiceIncidentBundleArtifact } from './incidentBundle';
 export { summarizeVoiceOpsStatus } from './opsStatus';
@@ -124,7 +124,7 @@ export type { VoiceProductionReadinessAction, VoiceProductionReadinessAuditOptio
 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 { 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, VoiceObservabilityExportDeliverySummary, VoiceObservabilityExportDeliveryDestination, VoiceObservabilityExportDeliveryDestinationResult, VoiceObservabilityExportDeliveryHistory, VoiceObservabilityExportDeliveryOptions, VoiceObservabilityExportDeliveryReceipt, VoiceObservabilityExportDeliveryReceiptStore, VoiceObservabilityExportDeliveryReport, VoiceObservabilityExportEnvelope, VoiceObservabilityExportIssue, VoiceObservabilityExportIssueCode, VoiceObservabilityExportOptions, VoiceObservabilityExportIngestedRecordKind, VoiceObservabilityExportRedactionSummary, VoiceObservabilityExportRecordValidationOptions, VoiceObservabilityExportReplayIssue, VoiceObservabilityExportReplayIssueCode, VoiceObservabilityExportReplayRecords, VoiceObservabilityExportReplayReport, VoiceObservabilityExportReplayRoutesOptions, VoiceObservabilityExportReplaySource, VoiceObservabilityExportReport, VoiceObservabilityExportRoutesOptions, VoiceObservabilityExportSchema, VoiceObservabilityExportStatus, VoiceObservabilityExportValidationIssue, VoiceObservabilityExportValidationResult } from './observabilityExport';
+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';
 export type { StoredVoiceIncidentBundleArtifact, VoiceIncidentBundle, VoiceIncidentBundleArtifactOptions, VoiceIncidentBundleFormat, VoiceIncidentBundleOptions, VoiceIncidentBundleRetentionOptions, VoiceIncidentBundleRetentionReport, VoiceIncidentBundleRoutesOptions, VoiceIncidentBundleStore, VoiceIncidentBundleStoreFilter, VoiceIncidentBundleSummary } from './incidentBundle';
 export type { VoiceQualityLink, VoiceQualityMetric, VoiceQualityReport, VoiceQualityRoutesOptions, VoiceQualityStatus, VoiceQualityThresholds } from './qualityRoutes';

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({
@@ -23851,6 +23929,62 @@ var buildVoiceObservabilityExportReplayReport = (records) => {
     }
   };
 };
+var evaluateVoiceObservabilityExportReplayEvidence = (report, input = {}) => {
+  const issues = [];
+  const requiredStatus = input.requireStatus ?? "pass";
+  const maxIssues = input.maxIssues ?? 0;
+  const maxValidationIssues = input.maxValidationIssues ?? 0;
+  const maxFailedArtifacts = input.maxFailedArtifacts ?? 0;
+  const maxFailedDeliveryDestinations = input.maxFailedDeliveryDestinations ?? 0;
+  const minArtifacts = input.minArtifacts ?? 1;
+  const minDeliveryDestinations = input.minDeliveryDestinations;
+  const recordKinds = Object.values(report.records).map((record) => record?.kind).filter((kind) => Boolean(kind)).sort();
+  if (report.status !== requiredStatus) {
+    issues.push(`Expected observability export replay status ${requiredStatus}, found ${report.status}.`);
+  }
+  if (report.issues.length > maxIssues) {
+    issues.push(`Expected at most ${String(maxIssues)} observability export replay issue(s), found ${String(report.issues.length)}.`);
+  }
+  if (report.summary.validationIssues > maxValidationIssues) {
+    issues.push(`Expected at most ${String(maxValidationIssues)} observability export replay validation issue(s), found ${String(report.summary.validationIssues)}.`);
+  }
+  if (report.summary.failedArtifacts > maxFailedArtifacts) {
+    issues.push(`Expected at most ${String(maxFailedArtifacts)} failed observability export artifact(s), found ${String(report.summary.failedArtifacts)}.`);
+  }
+  if (report.summary.failedDeliveryDestinations > maxFailedDeliveryDestinations) {
+    issues.push(`Expected at most ${String(maxFailedDeliveryDestinations)} failed observability export delivery destination(s), found ${String(report.summary.failedDeliveryDestinations)}.`);
+  }
+  if (report.summary.artifacts < minArtifacts) {
+    issues.push(`Expected at least ${String(minArtifacts)} replayed observability export artifact(s), found ${String(report.summary.artifacts)}.`);
+  }
+  if (minDeliveryDestinations !== undefined && report.summary.deliveryDestinations < minDeliveryDestinations) {
+    issues.push(`Expected at least ${String(minDeliveryDestinations)} replayed observability export delivery destination(s), found ${String(report.summary.deliveryDestinations)}.`);
+  }
+  for (const recordKind of input.requiredRecordKinds ?? []) {
+    if (!recordKinds.includes(recordKind)) {
+      issues.push(`Missing observability export replay record kind: ${recordKind}.`);
+    }
+  }
+  return {
+    artifacts: report.summary.artifacts,
+    deliveryDestinations: report.summary.deliveryDestinations,
+    failedArtifacts: report.summary.failedArtifacts,
+    failedDeliveryDestinations: report.summary.failedDeliveryDestinations,
+    issues,
+    ok: issues.length === 0,
+    recordKinds,
+    replayIssues: report.issues.length,
+    status: report.status,
+    validationIssues: report.summary.validationIssues
+  };
+};
+var assertVoiceObservabilityExportReplayEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceObservabilityExportReplayEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice observability export replay assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var loadVoiceObservabilityExportReplaySource = async (source) => {
   if (source.kind === "records") {
     return source;
@@ -24121,6 +24255,89 @@ var buildVoiceObservabilityExportDeliveryHistory = async (store) => {
     }
   };
 };
+var getSuccessfulObservabilityExportReceipts = (history) => history.receipts.filter((receipt) => receipt.status === "pass" && receipt.exportStatus === "pass" && receipt.summary.delivered > 0 && receipt.summary.failed === 0);
+var getLatestSuccessfulObservabilityExportReceipt = (history) => getSuccessfulObservabilityExportReceipts(history).sort((left, right) => right.checkedAt - left.checkedAt)[0];
+var evaluateVoiceObservabilityExportDeliveryEvidence = (history, input = {}) => {
+  const issues = [];
+  const requiredStatus = input.requireStatus ?? "pass";
+  const maxFailed = input.maxFailed ?? 0;
+  const maxFailedReceipts = input.maxFailedReceipts ?? 0;
+  const maxFailedExportReceipts = input.maxFailedExportReceipts ?? 0;
+  const minDelivered = input.minDelivered ?? 1;
+  const minReceipts = input.minReceipts ?? 1;
+  const minTotalDestinations = input.minTotalDestinations ?? 1;
+  const now = input.now ?? Date.now();
+  const failedReceipts = history.receipts.filter((receipt) => receipt.status === "fail").length;
+  const failedExportReceipts = history.receipts.filter((receipt) => receipt.exportStatus === "fail").length;
+  const latestSuccess = getLatestSuccessfulObservabilityExportReceipt(history);
+  const latestSuccessAgeMs = latestSuccess ? Math.max(0, now - latestSuccess.checkedAt) : undefined;
+  const destinations = history.receipts.flatMap((receipt) => receipt.destinations);
+  const destinationIds = [
+    ...new Set(destinations.map((destination) => destination.destinationId))
+  ].sort();
+  const destinationKinds = [
+    ...new Set(destinations.map((destination) => destination.destinationKind))
+  ].sort();
+  if (history.status !== requiredStatus) {
+    issues.push(`Expected observability export delivery status ${requiredStatus}, found ${history.status}.`);
+  }
+  if (history.summary.failed > maxFailed) {
+    issues.push(`Expected at most ${String(maxFailed)} failed observability export delivery destination(s), found ${String(history.summary.failed)}.`);
+  }
+  if (failedReceipts > maxFailedReceipts) {
+    issues.push(`Expected at most ${String(maxFailedReceipts)} failed observability export delivery receipt(s), found ${String(failedReceipts)}.`);
+  }
+  if (failedExportReceipts > maxFailedExportReceipts) {
+    issues.push(`Expected at most ${String(maxFailedExportReceipts)} failed observability export receipt manifest(s), found ${String(failedExportReceipts)}.`);
+  }
+  if (history.summary.delivered < minDelivered) {
+    issues.push(`Expected at least ${String(minDelivered)} delivered observability export destination(s), found ${String(history.summary.delivered)}.`);
+  }
+  if (history.summary.receipts < minReceipts) {
+    issues.push(`Expected at least ${String(minReceipts)} observability export delivery receipt(s), found ${String(history.summary.receipts)}.`);
+  }
+  if (history.summary.totalDestinations < minTotalDestinations) {
+    issues.push(`Expected at least ${String(minTotalDestinations)} observability export destination(s), found ${String(history.summary.totalDestinations)}.`);
+  }
+  if (input.maxLatestSuccessAgeMs !== undefined) {
+    if (latestSuccessAgeMs === undefined) {
+      issues.push("Missing successful observability export delivery receipt.");
+    } else if (latestSuccessAgeMs > input.maxLatestSuccessAgeMs) {
+      issues.push(`Expected latest successful observability export delivery age at most ${String(input.maxLatestSuccessAgeMs)}ms, found ${String(latestSuccessAgeMs)}ms.`);
+    }
+  }
+  for (const destinationId of input.requiredDestinationIds ?? []) {
+    if (!destinationIds.includes(destinationId)) {
+      issues.push(`Missing observability export delivery destination: ${destinationId}.`);
+    }
+  }
+  for (const destinationKind of input.requiredDestinationKinds ?? []) {
+    if (!destinationKinds.includes(destinationKind)) {
+      issues.push(`Missing observability export delivery destination kind: ${destinationKind}.`);
+    }
+  }
+  return {
+    delivered: history.summary.delivered,
+    destinationIds,
+    destinationKinds,
+    failed: history.summary.failed,
+    failedExportReceipts,
+    failedReceipts,
+    issues,
+    latestSuccessAgeMs,
+    ok: issues.length === 0,
+    receipts: history.summary.receipts,
+    status: history.status,
+    totalDestinations: history.summary.totalDestinations
+  };
+};
+var assertVoiceObservabilityExportDeliveryEvidence = (history, input = {}) => {
+  const assertion = evaluateVoiceObservabilityExportDeliveryEvidence(history, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice observability export delivery assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var inferContentType = (artifact) => {
   if (artifact.contentType) {
     return artifact.contentType;
@@ -30158,9 +30375,12 @@ export {
   evaluateVoiceQuality,
   evaluateVoiceProviderStackGaps,
   evaluateVoiceProviderSloEvidence,
+  evaluateVoiceProofTrendEvidence,
   evaluateVoiceProductionReadinessEvidence,
   evaluateVoicePlatformCoverage,
   evaluateVoiceOperationsRecordGuardrails,
+  evaluateVoiceObservabilityExportReplayEvidence,
+  evaluateVoiceObservabilityExportDeliveryEvidence,
   evaluateVoiceGuardrailPolicy,
   encodeTwilioMulawBase64,
   deliverVoiceTraceEventsToSinks,
@@ -30475,11 +30695,14 @@ export {
   assignVoiceOpsTask,
   assertVoiceProviderSloEvidence,
   assertVoiceProviderRoutingContract,
+  assertVoiceProofTrendEvidence,
   assertVoiceProductionReadinessEvidence,
   assertVoicePlatformCoverage,
   assertVoiceOperationsRecordGuardrails,
   assertVoiceObservabilityExportSchema,
+  assertVoiceObservabilityExportReplayEvidence,
   assertVoiceObservabilityExportRecord,
+  assertVoiceObservabilityExportDeliveryEvidence,
   assertVoiceLatencySLOGate,
   assertVoiceAgentSquadContract,
   applyVoiceTelephonyOutcome,

package/dist/observabilityExport.d.ts

@@ -269,6 +269,55 @@ export type VoiceObservabilityExportReplayReport = {
         validationIssues: number;
     };
 };
+export type VoiceObservabilityExportDeliveryAssertionInput = {
+    maxFailed?: number;
+    maxFailedExportReceipts?: number;
+    maxFailedReceipts?: number;
+    maxLatestSuccessAgeMs?: number;
+    minDelivered?: number;
+    minReceipts?: number;
+    minTotalDestinations?: number;
+    now?: number;
+    requireStatus?: VoiceObservabilityExportStatus;
+    requiredDestinationIds?: string[];
+    requiredDestinationKinds?: VoiceObservabilityExportDeliveryDestination['kind'][];
+};
+export type VoiceObservabilityExportDeliveryAssertionReport = {
+    delivered: number;
+    destinationIds: string[];
+    destinationKinds: VoiceObservabilityExportDeliveryDestination['kind'][];
+    failed: number;
+    failedExportReceipts: number;
+    failedReceipts: number;
+    issues: string[];
+    latestSuccessAgeMs?: number;
+    ok: boolean;
+    receipts: number;
+    status: VoiceObservabilityExportStatus;
+    totalDestinations: number;
+};
+export type VoiceObservabilityExportReplayAssertionInput = {
+    maxFailedArtifacts?: number;
+    maxFailedDeliveryDestinations?: number;
+    maxIssues?: number;
+    maxValidationIssues?: number;
+    minArtifacts?: number;
+    minDeliveryDestinations?: number;
+    requireStatus?: VoiceObservabilityExportStatus;
+    requiredRecordKinds?: VoiceObservabilityExportIngestedRecordKind[];
+};
+export type VoiceObservabilityExportReplayAssertionReport = {
+    artifacts: number;
+    deliveryDestinations: number;
+    failedArtifacts: number;
+    failedDeliveryDestinations: number;
+    issues: string[];
+    ok: boolean;
+    recordKinds: VoiceObservabilityExportIngestedRecordKind[];
+    replayIssues: number;
+    status: VoiceObservabilityExportStatus;
+    validationIssues: number;
+};
 export type VoiceObservabilityExportReplaySource = {
     artifactIndex?: unknown;
     databaseRecord?: unknown;
@@ -354,6 +403,8 @@ export type VoiceObservabilityExportRoutesOptions = VoiceObservabilityExportOpti
     title?: string;
 };
 export declare const buildVoiceObservabilityExportReplayReport: (records: VoiceObservabilityExportReplayRecords) => VoiceObservabilityExportReplayReport;
+export declare const evaluateVoiceObservabilityExportReplayEvidence: (report: VoiceObservabilityExportReplayReport, input?: VoiceObservabilityExportReplayAssertionInput) => VoiceObservabilityExportReplayAssertionReport;
+export declare const assertVoiceObservabilityExportReplayEvidence: (report: VoiceObservabilityExportReplayReport, input?: VoiceObservabilityExportReplayAssertionInput) => VoiceObservabilityExportReplayAssertionReport;
 export declare const loadVoiceObservabilityExportReplaySource: (source: VoiceObservabilityExportReplaySource) => Promise<VoiceObservabilityExportReplayRecords>;
 export declare const replayVoiceObservabilityExport: (source: VoiceObservabilityExportReplaySource) => Promise<VoiceObservabilityExportReplayReport>;
 export declare const renderVoiceObservabilityExportReplayHTML: (report: VoiceObservabilityExportReplayReport, options?: {
@@ -392,6 +443,8 @@ export declare const createVoiceFileObservabilityExportDeliveryReceiptStore: (op
     directory: string;
 }) => VoiceObservabilityExportDeliveryReceiptStore;
 export declare const buildVoiceObservabilityExportDeliveryHistory: (store: VoiceObservabilityExportDeliveryReceiptStore) => Promise<VoiceObservabilityExportDeliveryHistory>;
+export declare const evaluateVoiceObservabilityExportDeliveryEvidence: (history: VoiceObservabilityExportDeliveryHistory, input?: VoiceObservabilityExportDeliveryAssertionInput) => VoiceObservabilityExportDeliveryAssertionReport;
+export declare const assertVoiceObservabilityExportDeliveryEvidence: (history: VoiceObservabilityExportDeliveryHistory, input?: VoiceObservabilityExportDeliveryAssertionInput) => VoiceObservabilityExportDeliveryAssertionReport;
 export declare const buildVoiceObservabilityExport: (options?: VoiceObservabilityExportOptions) => Promise<VoiceObservabilityExportReport>;
 export declare const renderVoiceObservabilityExportMarkdown: (report: VoiceObservabilityExportReport, options?: {
     title?: string;

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/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.251",
+	"version": "0.0.22-beta.253",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",