@absolutejs/voice 0.0.22-beta.257 → 0.0.22-beta.259

package/dist/campaign.d.ts

@@ -190,6 +190,26 @@ export type VoiceCampaignReadinessProofReport = {
         windowBlocked: VoiceCampaignTickResult;
     };
 };
+export type VoiceCampaignReadinessAssertionInput = {
+    maxFailedChecks?: number;
+    minAcceptedImports?: number;
+    minRejectedImports?: number;
+    minTotalImports?: number;
+    requiredBlockedReasons?: VoiceCampaignTickResult['blocked'][number]['reason'][];
+    requiredChecks?: string[];
+    requireOk?: boolean;
+};
+export type VoiceCampaignReadinessAssertionReport = {
+    acceptedImports: number;
+    blockedReasons: VoiceCampaignTickResult['blocked'][number]['reason'][];
+    failed: number;
+    issues: string[];
+    ok: boolean;
+    passed: number;
+    rejectedImports: number;
+    total: number;
+    totalImports: number;
+};
 export type VoiceCampaignSummary = {
     attempts: {
         failed: number;
@@ -381,6 +401,8 @@ export declare const applyVoiceCampaignTelephonyOutcome: <TResult = unknown>(inp
 export declare const createVoiceCampaignTelephonyOutcomeHandler: <TResult = unknown>(options: VoiceCampaignTelephonyOutcomeOptions<TResult>) => (input: VoiceTelephonyWebhookDecision<TResult>) => Promise<VoiceCampaignTelephonyOutcomeResult>;
 export declare const runVoiceCampaignProof: (options?: VoiceCampaignProofOptions) => Promise<VoiceCampaignProofReport>;
 export declare const runVoiceCampaignReadinessProof: (options?: VoiceCampaignReadinessProofOptions) => Promise<VoiceCampaignReadinessProofReport>;
+export declare const evaluateVoiceCampaignReadinessEvidence: (report: VoiceCampaignReadinessProofReport, input?: VoiceCampaignReadinessAssertionInput) => VoiceCampaignReadinessAssertionReport;
+export declare const assertVoiceCampaignReadinessEvidence: (report: VoiceCampaignReadinessProofReport, input?: VoiceCampaignReadinessAssertionInput) => VoiceCampaignReadinessAssertionReport;
 export declare const renderVoiceCampaignsHTML: (records: VoiceCampaignRecord[], options?: Pick<VoiceCampaignRoutesOptions, "operationsRecordHref" | "title">) => string;
 export declare const renderVoiceCampaignObservabilityHTML: (report: VoiceCampaignObservabilityReport, options?: {
     title?: string;

package/dist/campaignDialers.d.ts

@@ -82,9 +82,30 @@ export type VoiceCampaignDialerProofOptions = {
     runPath?: string;
     store?: VoiceCampaignStore;
 };
+export type VoiceCampaignDialerProofAssertionInput = {
+    maxFailedProviders?: number;
+    minCarrierRequests?: number;
+    minProviders?: number;
+    minSuccessfulOutcomes?: number;
+    requiredProviders?: VoiceCampaignDialerProofProvider[];
+    requireDryRun?: boolean;
+    requireOk?: boolean;
+};
+export type VoiceCampaignDialerProofAssertionReport = {
+    carrierRequests: number;
+    failedProviders: number;
+    issues: string[];
+    mode: VoiceCampaignDialerProofReport['mode'];
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProvider[];
+    successfulOutcomes: number;
+    totalProviders: number;
+};
 export declare const createVoiceTwilioCampaignDialer: (options: VoiceTwilioCampaignDialerOptions) => VoiceCampaignDialer;
 export declare const createVoiceTelnyxCampaignDialer: (options: VoiceTelnyxCampaignDialerOptions) => VoiceCampaignDialer;
 export declare const createVoicePlivoCampaignDialer: (options: VoicePlivoCampaignDialerOptions) => VoiceCampaignDialer;
 export declare const getVoiceCampaignDialerProofStatus: (options?: Pick<VoiceCampaignDialerProofOptions, "providers" | "runPath">) => VoiceCampaignDialerProofStatus;
 export declare const runVoiceCampaignDialerProof: (options?: VoiceCampaignDialerProofOptions) => Promise<VoiceCampaignDialerProofReport>;
+export declare const evaluateVoiceCampaignDialerProofEvidence: (report: VoiceCampaignDialerProofReport, input?: VoiceCampaignDialerProofAssertionInput) => VoiceCampaignDialerProofAssertionReport;
+export declare const assertVoiceCampaignDialerProofEvidence: (report: VoiceCampaignDialerProofReport, input?: VoiceCampaignDialerProofAssertionInput) => VoiceCampaignDialerProofAssertionReport;
 export {};

package/dist/dataControl.d.ts

@@ -77,6 +77,44 @@ export type VoiceDataControlReport = {
     providerKeys: VoiceDataControlProviderKeySurface[];
     zeroRetentionAvailable: boolean;
 };
+export type VoiceDataControlAssertionInput = {
+    maxDeletionDeleted?: number;
+    maxMissingConfiguredStorage?: number;
+    maxMissingSelfHostedStorage?: number;
+    maxRetentionDeleted?: number;
+    minAuditExportEvents?: number;
+    minConfiguredStorage?: number;
+    minProviderKeys?: number;
+    requiredControls?: VoiceDataControlStorageSurface['control'][];
+    requiredDeletionScopes?: VoiceDataRetentionScope[];
+    requiredProviderKeys?: string[];
+    requiredRetentionScopes?: VoiceDataRetentionScope[];
+    requiredStorage?: string[];
+    requireAuditExport?: boolean;
+    requireDeletionDryRun?: boolean;
+    requireDeletionProof?: boolean;
+    requireRedaction?: boolean;
+    requireRetentionDryRun?: boolean;
+    requireSelfHostedStorage?: boolean;
+    requireZeroRetentionAvailable?: boolean;
+};
+export type VoiceDataControlAssertionReport = {
+    auditExportEvents: number;
+    configuredStorage: string[];
+    controls: VoiceDataControlStorageSurface['control'][];
+    deletionDeleted: number;
+    deletionDryRun?: boolean;
+    deletionScopes: VoiceDataRetentionScope[];
+    issues: string[];
+    ok: boolean;
+    providerKeys: string[];
+    redactionEnabled: boolean;
+    retentionDeleted: number;
+    retentionDryRun: boolean;
+    retentionScopes: VoiceDataRetentionScope[];
+    selfHostedConfiguredStorage: string[];
+    zeroRetentionAvailable: boolean;
+};
 export type VoiceDataControlRoutesOptions = VoiceDataRetentionStores & {
     audit?: VoiceAuditEventStore;
     auditActor?: VoiceAuditActor;
@@ -91,6 +129,8 @@ export type VoiceDataControlRoutesOptions = VoiceDataRetentionStores & {
 };
 export declare const applyVoiceDataRetentionPolicy: (options: VoiceDataRetentionPolicy) => Promise<VoiceDataRetentionReport>;
 export declare const buildVoiceDataRetentionPlan: (options: Omit<VoiceDataRetentionPolicy, "dryRun">) => Promise<VoiceDataRetentionReport>;
+export declare const evaluateVoiceDataControlEvidence: (report: VoiceDataControlReport, input?: VoiceDataControlAssertionInput) => VoiceDataControlAssertionReport;
+export declare const assertVoiceDataControlEvidence: (report: VoiceDataControlReport, input?: VoiceDataControlAssertionInput) => VoiceDataControlAssertionReport;
 export declare const createVoiceZeroRetentionPolicy: (options: VoiceDataRetentionStores & {
     audit?: VoiceAuditEventStore;
     auditActor?: VoiceAuditActor;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { voice } from './plugin';
-export { applyVoiceCampaignTelephonyOutcome, buildVoiceCampaignObservabilityReport, createVoiceCampaignTelephonyOutcomeHandler, createVoiceCampaign, createVoiceCampaignRoutes, createVoiceCampaignWorker, createVoiceCampaignWorkerLoop, createVoiceMemoryCampaignStore, importVoiceCampaignRecipients, renderVoiceCampaignObservabilityHTML, renderVoiceCampaignsHTML, runVoiceCampaignProof, runVoiceCampaignReadinessProof, summarizeVoiceCampaigns } from './campaign';
-export { createVoicePlivoCampaignDialer, createVoiceTelnyxCampaignDialer, createVoiceTwilioCampaignDialer, getVoiceCampaignDialerProofStatus, runVoiceCampaignDialerProof } from './campaignDialers';
+export { applyVoiceCampaignTelephonyOutcome, assertVoiceCampaignReadinessEvidence, buildVoiceCampaignObservabilityReport, createVoiceCampaignTelephonyOutcomeHandler, createVoiceCampaign, createVoiceCampaignRoutes, createVoiceCampaignWorker, createVoiceCampaignWorkerLoop, createVoiceMemoryCampaignStore, evaluateVoiceCampaignReadinessEvidence, importVoiceCampaignRecipients, renderVoiceCampaignObservabilityHTML, renderVoiceCampaignsHTML, runVoiceCampaignProof, runVoiceCampaignReadinessProof, summarizeVoiceCampaigns } from './campaign';
+export { assertVoiceCampaignDialerProofEvidence, createVoicePlivoCampaignDialer, createVoiceTelnyxCampaignDialer, createVoiceTwilioCampaignDialer, evaluateVoiceCampaignDialerProofEvidence, getVoiceCampaignDialerProofStatus, runVoiceCampaignDialerProof } from './campaignDialers';
 export { createVoiceAssistant, createVoiceExperiment, summarizeVoiceAssistantRuns } from './assistant';
 export { createVoiceAssistantHealthHTMLHandler, createVoiceAssistantHealthJSONHandler, createVoiceAssistantHealthRoutes, renderVoiceAssistantHealthHTML, summarizeVoiceAssistantHealth } from './assistantHealth';
 export { createVoiceAuditEvent, createVoiceAuditLogger, createVoiceMemoryAuditEventStore, filterVoiceAuditEvents, recordVoiceAuditEvent, recordVoiceHandoffAuditEvent, recordVoiceOperatorAuditEvent, recordVoiceProviderAuditEvent, recordVoiceRetentionAuditEvent, recordVoiceToolAuditEvent } from './audit';
@@ -21,8 +21,8 @@ export type { VoiceProofTrendAssertionInput, VoiceProofTrendAssertionReport, Voi
 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';
-export { applyVoiceDataRetentionPolicy, buildVoiceDataControlReport, buildVoiceDataRetentionPlan, createVoiceDataControlRoutes, createVoiceZeroRetentionPolicy, renderVoiceDataControlHTML, renderVoiceDataControlMarkdown, voiceComplianceRedactionDefaults } from './dataControl';
-export type { VoiceDataControlProviderKeySurface, VoiceDataControlReport, VoiceDataControlRoutesOptions, VoiceDataControlStorageSurface, VoiceDataRetentionPolicy, VoiceDataRetentionReport, VoiceDataRetentionScope, VoiceDataRetentionScopeReport, VoiceDataRetentionStores } from './dataControl';
+export { applyVoiceDataRetentionPolicy, assertVoiceDataControlEvidence, buildVoiceDataControlReport, buildVoiceDataRetentionPlan, createVoiceDataControlRoutes, createVoiceZeroRetentionPolicy, evaluateVoiceDataControlEvidence, renderVoiceDataControlHTML, renderVoiceDataControlMarkdown, voiceComplianceRedactionDefaults } from './dataControl';
+export type { VoiceDataControlAssertionInput, VoiceDataControlAssertionReport, VoiceDataControlProviderKeySurface, VoiceDataControlReport, VoiceDataControlRoutesOptions, VoiceDataControlStorageSurface, VoiceDataRetentionPolicy, VoiceDataRetentionReport, VoiceDataRetentionScope, VoiceDataRetentionScopeReport, VoiceDataRetentionStores } from './dataControl';
 export type { VoiceDemoReadyReport, VoiceDemoReadyRoutesOptions, VoiceDemoReadySection, VoiceDemoReadyStatus } from './demoReadyRoutes';
 export type { VoiceDeliverySinkDescriptor, VoiceDeliverySinkDescriptorInput, VoiceDeliverySinkKind, VoiceDeliverySinkPairOptions, VoiceDeliverySinkReport, VoiceDeliverySinkRoutesOptions, VoiceTraceDeliverySinkSurface } from './deliverySinkRoutes';
 export type { VoiceOpsActionAuditRecord, VoiceOpsActionAuditRoutesOptions, VoiceOpsActionHistoryEntry, VoiceOpsActionHistoryReport } from './opsActionAuditRoutes';
@@ -92,8 +92,8 @@ export { conditionAudioChunk, resolveAudioConditioningConfig } from './audioCond
 export { resolveVoiceRuntimePreset } from './presets';
 export { resolveTurnDetectionConfig, TURN_PROFILE_DEFAULTS } from './turnProfiles';
 export { createVoiceCallReviewFromLiveTelephonyReport, createVoiceCallReviewRecorder, renderVoiceCallReviewHTML, renderVoiceCallReviewMarkdown } from './testing/review';
-export type { VoiceCampaign, VoiceCampaignAttempt, VoiceCampaignAttemptResultInput, VoiceCampaignAttemptStatus, VoiceCampaignCreateInput, VoiceCampaignDialer, VoiceCampaignDialerInput, VoiceCampaignDialerResult, VoiceCampaignProofOptions, VoiceCampaignProofReport, VoiceCampaignReadinessCheck, VoiceCampaignReadinessProofOptions, VoiceCampaignReadinessProofReport, VoiceCampaignRecipient, VoiceCampaignRecipientImportIssue, VoiceCampaignRecipientImportIssueCode, VoiceCampaignRecipientImportOptions, VoiceCampaignRecipientImportResult, VoiceCampaignRecipientImportRow, VoiceCampaignRecipientInput, VoiceCampaignRecipientStatus, VoiceCampaignRecord, VoiceCampaignRoutesOptions, VoiceCampaignRuntime, VoiceCampaignRuntimeOptions, VoiceCampaignRateLimit, VoiceCampaignRetryPolicy, VoiceCampaignSchedule, VoiceCampaignStatus, VoiceCampaignStore, VoiceCampaignSummary, VoiceCampaignTimeWindow, VoiceCampaignTickResult } from './campaign';
-export type { VoiceCampaignDialerProofCarrierRequest, VoiceCampaignDialerProofOptions, VoiceCampaignDialerProofProvider, VoiceCampaignDialerProofProviderResult, VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus, VoicePlivoCampaignDialerOptions, VoiceTelnyxCampaignDialerOptions, VoiceTwilioCampaignDialerOptions } from './campaignDialers';
+export type { VoiceCampaign, VoiceCampaignAttempt, VoiceCampaignAttemptResultInput, VoiceCampaignAttemptStatus, VoiceCampaignCreateInput, VoiceCampaignDialer, VoiceCampaignDialerInput, VoiceCampaignDialerResult, VoiceCampaignProofOptions, VoiceCampaignProofReport, VoiceCampaignReadinessAssertionInput, VoiceCampaignReadinessAssertionReport, VoiceCampaignReadinessCheck, VoiceCampaignReadinessProofOptions, VoiceCampaignReadinessProofReport, VoiceCampaignRecipient, VoiceCampaignRecipientImportIssue, VoiceCampaignRecipientImportIssueCode, VoiceCampaignRecipientImportOptions, VoiceCampaignRecipientImportResult, VoiceCampaignRecipientImportRow, VoiceCampaignRecipientInput, VoiceCampaignRecipientStatus, VoiceCampaignRecord, VoiceCampaignRoutesOptions, VoiceCampaignRuntime, VoiceCampaignRuntimeOptions, VoiceCampaignRateLimit, VoiceCampaignRetryPolicy, VoiceCampaignSchedule, VoiceCampaignStatus, VoiceCampaignStore, VoiceCampaignSummary, VoiceCampaignTimeWindow, VoiceCampaignTickResult } from './campaign';
+export type { VoiceCampaignDialerProofAssertionInput, VoiceCampaignDialerProofAssertionReport, VoiceCampaignDialerProofCarrierRequest, VoiceCampaignDialerProofOptions, VoiceCampaignDialerProofProvider, VoiceCampaignDialerProofProviderResult, VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus, VoicePlivoCampaignDialerOptions, VoiceTelnyxCampaignDialerOptions, VoiceTwilioCampaignDialerOptions } from './campaignDialers';
 export type { VoiceBargeInReport, VoiceBargeInRoutesOptions } from './bargeInRoutes';
 export type { VoiceAssistant, VoiceAssistantArtifactPlan, VoiceAssistantExperiment, VoiceAssistantExperimentOptions, VoiceAssistantGuardrailInput, VoiceAssistantGuardrails, VoiceAssistantMemoryLifecycle, VoiceAssistantMemoryLifecycleInput, VoiceAssistantOptions, VoiceAssistantOutputGuardrailInput, VoiceAssistantPreset, VoiceAssistantRunsSummary, VoiceAssistantRunSummary, VoiceAssistantVariant } from './assistant';
 export type { VoiceAssistantHealthFailure, VoiceAssistantHealthHTMLHandlerOptions, VoiceAssistantHealthRoutesOptions, VoiceAssistantHealthSummary, VoiceAssistantHealthSummaryOptions } from './assistantHealth';

package/dist/index.js

@@ -6661,6 +6661,60 @@ recipient-no-consent,Barbara,+15550001004,no,delta`,
     }
   };
 };
+var evaluateVoiceCampaignReadinessEvidence = (report, input = {}) => {
+  const issues = [];
+  const maxFailedChecks = input.maxFailedChecks ?? 0;
+  const requireOk = input.requireOk ?? true;
+  const failed = report.checks.filter((check) => check.status === "fail").length;
+  const passed = report.checks.length - failed;
+  const checkNames = new Set(report.checks.map((check) => check.name));
+  const blockedReasons = [
+    ...new Set(Object.values(report.ticks).flatMap((tick) => tick.blocked.map((block) => block.reason)))
+  ].sort();
+  if (requireOk && !report.ok) {
+    issues.push("Expected campaign readiness proof to pass.");
+  }
+  if (failed > maxFailedChecks) {
+    issues.push(`Expected at most ${String(maxFailedChecks)} failing campaign readiness check(s), found ${String(failed)}.`);
+  }
+  if (input.minTotalImports !== undefined && report.import.total < input.minTotalImports) {
+    issues.push(`Expected at least ${String(input.minTotalImports)} campaign import row(s), found ${String(report.import.total)}.`);
+  }
+  if (input.minAcceptedImports !== undefined && report.import.accepted.length < input.minAcceptedImports) {
+    issues.push(`Expected at least ${String(input.minAcceptedImports)} accepted campaign import(s), found ${String(report.import.accepted.length)}.`);
+  }
+  if (input.minRejectedImports !== undefined && report.import.rejected.length < input.minRejectedImports) {
+    issues.push(`Expected at least ${String(input.minRejectedImports)} rejected campaign import(s), found ${String(report.import.rejected.length)}.`);
+  }
+  for (const check of input.requiredChecks ?? []) {
+    if (!checkNames.has(check)) {
+      issues.push(`Missing campaign readiness check: ${check}.`);
+    }
+  }
+  for (const reason of input.requiredBlockedReasons ?? []) {
+    if (!blockedReasons.includes(reason)) {
+      issues.push(`Missing campaign readiness blocked reason: ${reason}.`);
+    }
+  }
+  return {
+    acceptedImports: report.import.accepted.length,
+    blockedReasons,
+    failed,
+    issues,
+    ok: issues.length === 0,
+    passed,
+    rejectedImports: report.import.rejected.length,
+    total: report.checks.length,
+    totalImports: report.import.total
+  };
+};
+var assertVoiceCampaignReadinessEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceCampaignReadinessEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice campaign readiness evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var escapeHtml3 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var getString = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
 var campaignAttemptSessionId = (attempt) => getString(attempt.metadata?.sessionId) ?? getString(attempt.metadata?.voiceSessionId) ?? getString(attempt.metadata?.callSessionId);
@@ -7094,6 +7148,56 @@ var runVoiceCampaignDialerProof = async (options = {}) => {
     providers: results
   };
 };
+var evaluateVoiceCampaignDialerProofEvidence = (report, input = {}) => {
+  const issues = [];
+  const maxFailedProviders = input.maxFailedProviders ?? 0;
+  const requireOk = input.requireOk ?? true;
+  const requireDryRun = input.requireDryRun ?? true;
+  const providers = report.providers.map((provider) => provider.provider).sort();
+  const carrierRequests = report.providers.reduce((total, provider) => total + provider.carrierRequests.length, 0);
+  const successfulOutcomes = report.providers.reduce((total, provider) => total + provider.outcomes.filter((outcome) => outcome.applied).length, 0);
+  const failedProviders = report.providers.filter((provider) => provider.carrierRequests.length === 0 || provider.outcomes.some((outcome) => !outcome.applied)).length;
+  if (requireOk && !report.ok) {
+    issues.push("Expected campaign dialer proof to pass.");
+  }
+  if (requireDryRun && report.mode !== "dry-run") {
+    issues.push(`Expected campaign dialer proof mode dry-run, found ${report.mode}.`);
+  }
+  if (failedProviders > maxFailedProviders) {
+    issues.push(`Expected at most ${String(maxFailedProviders)} failing campaign dialer provider(s), found ${String(failedProviders)}.`);
+  }
+  if (input.minProviders !== undefined && report.providers.length < input.minProviders) {
+    issues.push(`Expected at least ${String(input.minProviders)} campaign dialer provider(s), found ${String(report.providers.length)}.`);
+  }
+  if (input.minCarrierRequests !== undefined && carrierRequests < input.minCarrierRequests) {
+    issues.push(`Expected at least ${String(input.minCarrierRequests)} campaign dialer carrier request(s), found ${String(carrierRequests)}.`);
+  }
+  if (input.minSuccessfulOutcomes !== undefined && successfulOutcomes < input.minSuccessfulOutcomes) {
+    issues.push(`Expected at least ${String(input.minSuccessfulOutcomes)} applied campaign dialer outcome(s), found ${String(successfulOutcomes)}.`);
+  }
+  for (const provider of input.requiredProviders ?? []) {
+    if (!providers.includes(provider)) {
+      issues.push(`Missing campaign dialer provider: ${provider}.`);
+    }
+  }
+  return {
+    carrierRequests,
+    failedProviders,
+    issues,
+    mode: report.mode,
+    ok: issues.length === 0,
+    providers,
+    successfulOutcomes,
+    totalProviders: report.providers.length
+  };
+};
+var assertVoiceCampaignDialerProofEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceCampaignDialerProofEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice campaign dialer proof evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 // src/audit.ts
 var includes = (filter, value) => {
   if (!filter) {
@@ -13318,6 +13422,127 @@ var defaultProviderKeys = [
   }
 ];
 var resolveDataControlRedaction = (redact) => redact === false ? undefined : redact === true || redact === undefined ? voiceComplianceRedactionDefaults : redact;
+var uniqueSorted = (values) => Array.from(new Set(values)).sort();
+var findMissing = (values, required) => {
+  if (!required?.length) {
+    return [];
+  }
+  const valueSet = new Set(values);
+  return required.filter((value) => !valueSet.has(value));
+};
+var evaluateVoiceDataControlEvidence = (report, input = {}) => {
+  const issues = [];
+  const configuredStorage = report.storage.filter((surface) => surface.configured).map((surface) => surface.name);
+  const selfHostedConfiguredStorage = report.storage.filter((surface) => surface.configured && surface.selfHosted).map((surface) => surface.name);
+  const controls = uniqueSorted(report.storage.filter((surface) => surface.configured).map((surface) => surface.control));
+  const retentionScopes = uniqueSorted(report.retentionPlan.scopes.map((scope) => scope.scope));
+  const deletionScopes = uniqueSorted(report.deletionProof?.scopes.map((scope) => scope.scope) ?? []);
+  const providerKeys = uniqueSorted(report.providerKeys.map((key) => key.name.toLowerCase()));
+  const auditExportEvents = report.auditExport?.events.length ?? 0;
+  const deletionDeleted = report.deletionProof?.deletedCount ?? 0;
+  const maxRetentionDeleted = input.maxRetentionDeleted;
+  const maxDeletionDeleted = input.maxDeletionDeleted;
+  const requireAuditExport = input.requireAuditExport ?? true;
+  const requireDeletionDryRun = input.requireDeletionDryRun ?? true;
+  const requireDeletionProof = input.requireDeletionProof ?? false;
+  const requireRedaction = input.requireRedaction ?? true;
+  const requireRetentionDryRun = input.requireRetentionDryRun ?? true;
+  const requireSelfHostedStorage = input.requireSelfHostedStorage ?? true;
+  const requireZeroRetentionAvailable = input.requireZeroRetentionAvailable ?? true;
+  if (requireRedaction && !report.redaction.enabled) {
+    issues.push("Expected data-control redaction to be enabled.");
+  }
+  if (requireZeroRetentionAvailable && !report.zeroRetentionAvailable) {
+    issues.push("Expected zero-retention policy recipe to be available.");
+  }
+  if (requireAuditExport && !report.auditExport) {
+    issues.push("Expected redacted audit export to be available.");
+  }
+  if (input.minAuditExportEvents !== undefined && auditExportEvents < input.minAuditExportEvents) {
+    issues.push(`Expected at least ${String(input.minAuditExportEvents)} audit export events, found ${String(auditExportEvents)}.`);
+  }
+  if (requireRetentionDryRun && !report.retentionPlan.dryRun) {
+    issues.push("Expected retention plan to run in dry-run mode.");
+  }
+  if (maxRetentionDeleted !== undefined && report.retentionPlan.deletedCount > maxRetentionDeleted) {
+    issues.push(`Expected retention plan to delete at most ${String(maxRetentionDeleted)} records, found ${String(report.retentionPlan.deletedCount)}.`);
+  }
+  if (requireDeletionProof && !report.deletionProof) {
+    issues.push("Expected deletion proof to be present.");
+  }
+  if (report.deletionProof && requireDeletionDryRun && !report.deletionProof.dryRun) {
+    issues.push("Expected deletion proof to run in dry-run mode.");
+  }
+  if (maxDeletionDeleted !== undefined && deletionDeleted > maxDeletionDeleted) {
+    issues.push(`Expected deletion proof to delete at most ${String(maxDeletionDeleted)} records, found ${String(deletionDeleted)}.`);
+  }
+  if (input.minConfiguredStorage !== undefined && configuredStorage.length < input.minConfiguredStorage) {
+    issues.push(`Expected at least ${String(input.minConfiguredStorage)} configured storage surfaces, found ${String(configuredStorage.length)}.`);
+  }
+  if (requireSelfHostedStorage) {
+    const nonSelfHostedConfigured = configuredStorage.length - selfHostedConfiguredStorage.length;
+    if (nonSelfHostedConfigured > (input.maxMissingSelfHostedStorage ?? 0)) {
+      issues.push(`Expected configured storage to be self-hosted, found ${String(nonSelfHostedConfigured)} non-self-hosted surfaces.`);
+    }
+  }
+  const missingConfiguredStorage = findMissing(configuredStorage, input.requiredStorage);
+  if (missingConfiguredStorage.length > (input.maxMissingConfiguredStorage ?? 0)) {
+    issues.push(`Missing configured storage surfaces: ${missingConfiguredStorage.join(", ")}.`);
+  }
+  for (const control of findMissing(controls, input.requiredControls)) {
+    issues.push(`Missing configured storage control: ${control}.`);
+  }
+  for (const scope of findMissing(retentionScopes, input.requiredRetentionScopes)) {
+    issues.push(`Missing retention scope: ${scope}.`);
+  }
+  for (const scope of input.requiredRetentionScopes ?? []) {
+    const retentionScope = report.retentionPlan.scopes.find((candidate) => candidate.scope === scope);
+    if (retentionScope?.skippedReason) {
+      issues.push(`Retention scope ${scope} was skipped: ${retentionScope.skippedReason}.`);
+    }
+  }
+  for (const scope of findMissing(deletionScopes, input.requiredDeletionScopes)) {
+    issues.push(`Missing deletion-proof scope: ${scope}.`);
+  }
+  for (const scope of input.requiredDeletionScopes ?? []) {
+    const deletionScope = report.deletionProof?.scopes.find((candidate) => candidate.scope === scope);
+    if (deletionScope?.skippedReason) {
+      issues.push(`Deletion-proof scope ${scope} was skipped: ${deletionScope.skippedReason}.`);
+    }
+  }
+  for (const provider of input.requiredProviderKeys ?? []) {
+    if (!providerKeys.includes(provider.toLowerCase())) {
+      issues.push(`Missing provider-key guidance: ${provider}.`);
+    }
+  }
+  if (input.minProviderKeys !== undefined && providerKeys.length < input.minProviderKeys) {
+    issues.push(`Expected at least ${String(input.minProviderKeys)} provider-key guidance entries, found ${String(providerKeys.length)}.`);
+  }
+  return {
+    auditExportEvents,
+    configuredStorage: configuredStorage.sort(),
+    controls,
+    deletionDeleted,
+    deletionDryRun: report.deletionProof?.dryRun,
+    deletionScopes,
+    issues,
+    ok: issues.length === 0,
+    providerKeys,
+    redactionEnabled: report.redaction.enabled,
+    retentionDeleted: report.retentionPlan.deletedCount,
+    retentionDryRun: report.retentionPlan.dryRun,
+    retentionScopes,
+    selfHostedConfiguredStorage: selfHostedConfiguredStorage.sort(),
+    zeroRetentionAvailable: report.zeroRetentionAvailable
+  };
+};
+var assertVoiceDataControlEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceDataControlEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice data-control evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var createVoiceZeroRetentionPolicy = (options) => ({
   ...options,
   beforeOrAt: options.beforeOrAt ?? Date.now(),
@@ -22582,7 +22807,7 @@ var statusRank = {
 var escapeHtml36 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var roundMetric3 = (value) => Math.round(value * 1e4) / 1e4;
 var rate3 = (count, total) => count / Math.max(1, total);
-var uniqueSorted = (values) => [
+var uniqueSorted2 = (values) => [
   ...new Set(values.filter((value) => typeof value === "string"))
 ].sort();
 var percentile3 = (values, rank) => {
@@ -22765,7 +22990,7 @@ var buildVoiceProviderSloReport = async (options = {}) => {
 var evaluateVoiceProviderSloEvidence = (report, input = {}) => {
   const issues = [];
   const kindReports = Object.values(report.kinds);
-  const providers = uniqueSorted(kindReports.flatMap((kind) => kind.providers));
+  const providers = uniqueSorted2(kindReports.flatMap((kind) => kind.providers));
   const kinds = providerKinds.filter((kind) => report.kinds[kind].events > 0);
   const fallbacks = kindReports.reduce((total, kind) => total + kind.fallbacks, 0);
   const timeouts = kindReports.reduce((total, kind) => total + kind.timeouts, 0);
@@ -23486,7 +23711,7 @@ var hasPayloadValue = (payload, key, values) => {
   return typeof value === "string" && values.has(value);
 };
 var countIntegrationDeliveryStatus = (events, status) => events.filter((event) => event.deliveryStatus === status).length;
-var uniqueSorted2 = (values) => [
+var uniqueSorted3 = (values) => [
   ...new Set(values.filter((value) => typeof value === "string"))
 ].sort();
 var pushMissingValuesIssue = (input) => {
@@ -23665,11 +23890,11 @@ var buildVoiceOperationsRecord = async (options) => {
 var evaluateVoiceOperationsRecordGuardrails = (record, input = {}) => {
   const issues = [];
   const decisions = record.guardrails.decisions;
-  const proofs = uniqueSorted2(decisions.map((decision) => decision.proof));
-  const ruleIds = uniqueSorted2(decisions.flatMap((decision) => decision.findings.map((finding) => finding.ruleId)));
-  const stages = uniqueSorted2(decisions.map((decision) => decision.stage));
-  const statuses = uniqueSorted2(decisions.map((decision) => decision.status));
-  const toolNames = uniqueSorted2(decisions.map((decision) => decision.toolName));
+  const proofs = uniqueSorted3(decisions.map((decision) => decision.proof));
+  const ruleIds = uniqueSorted3(decisions.flatMap((decision) => decision.findings.map((finding) => finding.ruleId)));
+  const stages = uniqueSorted3(decisions.map((decision) => decision.stage));
+  const statuses = uniqueSorted3(decisions.map((decision) => decision.status));
+  const toolNames = uniqueSorted3(decisions.map((decision) => decision.toolName));
   const minDecisions = input.minDecisions ?? 1;
   if (record.guardrails.total < minDecisions) {
     issues.push(`Expected at least ${String(minDecisions)} guardrail decisions, found ${String(record.guardrails.total)}.`);
@@ -30922,6 +31147,9 @@ export {
   evaluateVoiceObservabilityExportReplayEvidence,
   evaluateVoiceObservabilityExportDeliveryEvidence,
   evaluateVoiceGuardrailPolicy,
+  evaluateVoiceDataControlEvidence,
+  evaluateVoiceCampaignReadinessEvidence,
+  evaluateVoiceCampaignDialerProofEvidence,
   evaluateVoiceAgentSquadContractEvidence,
   encodeTwilioMulawBase64,
   deliverVoiceTraceEventsToSinks,
@@ -31251,6 +31479,9 @@ export {
   assertVoiceObservabilityExportRecord,
   assertVoiceObservabilityExportDeliveryEvidence,
   assertVoiceLatencySLOGate,
+  assertVoiceDataControlEvidence,
+  assertVoiceCampaignReadinessEvidence,
+  assertVoiceCampaignDialerProofEvidence,
   assertVoiceAgentSquadContractEvidence,
   assertVoiceAgentSquadContract,
   applyVoiceTelephonyOutcome,

package/package.json

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