@absolutejs/voice 0.0.22-beta.394 → 0.0.22-beta.396

package/dist/index.d.ts

@@ -33,6 +33,8 @@ export type { VoicePlatformCoverageAssertionInput, VoicePlatformCoverageAssertio
 export { assertVoiceProofTrendEvidence, appendVoiceRealCallProfileRecoveryEvidence, buildEmptyVoiceProofTrendReport, buildVoiceProofTrendProfileSummaries, buildVoiceProofTrendRecommendationReport, buildVoiceProofTrendReportFromRealCallProfiles, buildVoiceProofTrendReport, buildVoiceRealCallProfileEvidenceFromTraceEvents, buildVoiceRealCallProfileDefaults, buildVoiceRealCallProfileHistoryReport, buildVoiceRealCallProfileReadinessCheck, buildVoiceRealCallProfileRecoveryJobHistoryCheck, buildVoiceRealCallProfileRecoveryActions, createVoiceInMemoryRealCallProfileRecoveryJobStore, createVoiceRealCallProfileTraceCollector, createVoiceSQLiteRealCallProfileRecoveryJobStore, createVoiceProofTrendRecommendationRoutes, createVoiceProofTrendRoutes, createVoiceRealCallProfileHistoryRoutes, createVoiceRealCallProfileRecoveryActionRoutes, DEFAULT_VOICE_PROOF_TREND_PROFILE_DEFINITIONS, DEFAULT_VOICE_PROOF_TRENDS_MAX_AGE_MS, evaluateVoiceProofTrendEvidence, formatVoiceProofTrendAge, loadVoiceRealCallProfileEvidenceFromTraceStore, normalizeVoiceProofTrendReport, readVoiceProofTrendReportFile, renderVoiceProofTrendRecommendationHTML, renderVoiceProofTrendRecommendationMarkdown, renderVoiceRealCallProfileHistoryHTML, renderVoiceRealCallProfileHistoryMarkdown, runVoiceRealCallProfileRecoveryLoop, resolveVoiceRealCallProfileProviderRoute } from './proofTrends';
 export { createVoiceEvidenceAssertion, createVoiceProofAssertion, summarizeVoiceProofAssertions } from './proofAssertions';
 export type { VoiceEvidenceAssertionInput, VoiceProofAssertionInput, VoiceProofAssertionResult, VoiceProofAssertionSummary } from './proofAssertions';
+export { fetchVoiceProofTarget, getVoiceProofTargetLogicalFailure, mapVoiceProofTargetsWithConcurrency, runVoiceCommandProofTarget, runVoiceCommandProofTargets, runVoiceProofTargets } from './proofRunner';
+export type { VoiceCommandProofExecutionResult, VoiceCommandProofTarget, VoiceCommandProofTargetResult, VoiceCommandProofTargetRunnerOptions, VoiceCommandProofTargetRunOptions, VoiceProofTarget, VoiceProofTargetMethod, VoiceProofTargetResult, VoiceProofTargetRunnerOptions, VoiceProofTargetRunOptions } from './proofRunner';
 export { applyVoiceProfileSwitchGuard, buildVoiceProfileSwitchReadinessReport, buildVoiceProfileSwitchLiveDecisionReport, createVoiceProfileSwitchLiveDecisionRoutes, createVoiceProfileSwitchPolicyProofRoutes, createVoiceProfileSwitchReadinessRoutes, recommendVoiceProfileSwitch, renderVoiceProfileSwitchLiveDecisionHTML, renderVoiceProfileSwitchPolicyProofHTML, renderVoiceProfileSwitchReadinessHTML, runVoiceProfileSwitchPolicyProof } from './profileSwitchRecommendation';
 export type { VoiceProfileSwitchGuardAction, VoiceProfileSwitchGuardDecision, VoiceProfileSwitchGuardMode, VoiceProfileSwitchGuardOptions, VoiceProfileSwitchObservedSignals, VoiceProfileSwitchLiveDecisionEvidence, VoiceProfileSwitchLiveDecisionReport, VoiceProfileSwitchLiveDecisionReportOptions, VoiceProfileSwitchLiveDecisionRoutesOptions, VoiceProfileSwitchLiveDecisionSession, VoiceProfileSwitchPolicyProofCase, VoiceProfileSwitchPolicyProofCaseResult, VoiceProfileSwitchPolicyProofOptions, VoiceProfileSwitchPolicyProofReport, VoiceProfileSwitchPolicyProofRoutesOptions, VoiceProfileSwitchReadinessIssue, VoiceProfileSwitchReadinessOptions, VoiceProfileSwitchReadinessReport, VoiceProfileSwitchReadinessRoutesOptions, VoiceProfileSwitchReadinessStatus, VoiceProfileSwitchRecommendation, VoiceProfileSwitchRecommendationOptions } from './profileSwitchRecommendation';
 export { buildVoiceProviderDecisionTraceReport, createVoiceProviderDecisionTraceEvent, createVoiceProviderDecisionTraceRoutes, listVoiceProviderDecisionTraces, renderVoiceProviderDecisionTraceHTML, renderVoiceProviderDecisionTraceMarkdown } from './providerDecisionTraces';

package/dist/index.js

@@ -18385,6 +18385,218 @@ var summarizeVoiceProofAssertions = (assertions) => {
     total: assertions.length
   };
 };
+// src/proofRunner.ts
+var encoder = new TextEncoder;
+var trimBaseUrl = (baseUrl) => baseUrl.replace(/\/$/, "");
+var safeArtifactName = (name) => name.replace(/[^a-z0-9_.-]/gi, "-");
+var summarizeValue = (value) => {
+  if (Array.isArray(value)) {
+    return { count: value.length };
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const record = value;
+  const preferredKeys = [
+    "status",
+    "ok",
+    "pass",
+    "ready",
+    "proof",
+    "total",
+    "passed",
+    "failed",
+    "issues",
+    "summary",
+    "links",
+    "actions",
+    "checks",
+    "campaigns",
+    "recipients",
+    "attempts",
+    "telephonyMedia",
+    "operationsRecordHref",
+    "sentEvents",
+    "tasks",
+    "reviews",
+    "events",
+    "eventsWithLatency",
+    "observabilityExportReplay",
+    "validationIssues",
+    "deliveryDestinations",
+    "failedDeliveryDestinations",
+    "failedArtifacts",
+    "artifacts",
+    "kinds",
+    "redaction",
+    "retentionPlan",
+    "zeroRetentionAvailable"
+  ];
+  const summary = {};
+  for (const key of preferredKeys) {
+    if (key in record) {
+      summary[key] = summarizeValue(record[key]);
+    }
+  }
+  return Object.keys(summary).length > 0 ? summary : {
+    keys: Object.keys(record).slice(0, 12)
+  };
+};
+var getVoiceProofTargetLogicalFailure = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  if (record.status === "fail") {
+    return 'Response status is "fail".';
+  }
+  if (record.pass === false) {
+    return "Response pass is false.";
+  }
+  if (record.ok === false) {
+    return "Response ok is false.";
+  }
+  return;
+};
+var mapVoiceProofTargetsWithConcurrency = async (items, limit, mapper) => {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.min(Math.max(1, limit), items.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      const item = items[index];
+      if (item !== undefined) {
+        results[index] = await mapper(item);
+      }
+    }
+  });
+  await Promise.all(workers);
+  return results;
+};
+var fetchVoiceProofTarget = async (target, options) => {
+  const method = target.method ?? "GET";
+  const baseUrl = trimBaseUrl(options.baseUrl);
+  const url = `${baseUrl}${target.path}`;
+  const fetcher = options.fetch ?? globalThis.fetch;
+  const now = options.now ?? performance.now.bind(performance);
+  const startedAt = now();
+  const controller = new AbortController;
+  const timeout = options.timeoutMs && options.timeoutMs > 0 ? setTimeout(() => controller.abort(), options.timeoutMs) : undefined;
+  try {
+    const response = await fetcher(url, {
+      body: target.body === undefined ? undefined : JSON.stringify(target.body),
+      headers: {
+        accept: target.accept ?? (target.kind === "json" ? "application/json" : "text/markdown,text/plain,*/*"),
+        ...target.body === undefined ? {} : { "content-type": "application/json" }
+      },
+      method,
+      signal: controller.signal
+    });
+    const text = await response.text();
+    const bytes = encoder.encode(text).byteLength;
+    let body = text;
+    let parseError;
+    if (target.kind === "json" && text.trim()) {
+      try {
+        body = JSON.parse(text);
+      } catch (error) {
+        parseError = error instanceof Error ? error.message : String(error);
+      }
+    }
+    const missingText = target.kind === "text" ? (target.requiredText ?? []).filter((item) => !text.includes(item)) : [];
+    const logicalFailure = target.kind === "json" && !parseError && !target.allowLogicalFail ? getVoiceProofTargetLogicalFailure(body) : undefined;
+    await options.writeArtifact?.({
+      content: target.kind === "json" ? `${JSON.stringify(parseError ? { parseError, text } : body, null, 2)}
+` : text,
+      name: `${safeArtifactName(target.name)}.${target.kind === "json" ? "json" : "md"}`,
+      target
+    });
+    return {
+      body,
+      bytes,
+      elapsedMs: Math.round(now() - startedAt),
+      error: parseError ?? logicalFailure ?? (missingText.length > 0 ? `Missing required text: ${missingText.join(", ")}` : undefined),
+      kind: target.kind,
+      method,
+      name: target.name,
+      ok: response.ok && !parseError && !logicalFailure && missingText.length === 0,
+      path: target.path,
+      status: response.status,
+      summary: parseError ? { bytes, parseError } : target.kind === "json" ? summarizeValue(body) : {
+        bytes,
+        requiredTextFound: missingText.length === 0
+      },
+      url
+    };
+  } catch (error) {
+    return {
+      bytes: 0,
+      elapsedMs: Math.round(now() - startedAt),
+      error: error instanceof Error ? error.message : String(error),
+      kind: target.kind,
+      method,
+      name: target.name,
+      ok: false,
+      path: target.path,
+      url
+    };
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+};
+var runVoiceProofTargets = (targets, options) => mapVoiceProofTargetsWithConcurrency(targets, options.concurrency ?? 2, (target) => fetchVoiceProofTarget(target, options));
+var runVoiceCommandProofTarget = async (target, options) => {
+  const now = options.now ?? performance.now.bind(performance);
+  const startedAt = now();
+  const execution = await options.execute(target);
+  const stdout = execution.stdout ?? "";
+  const stderr = execution.stderr ?? "";
+  const status = execution.status;
+  const text = stdout.trim();
+  const bytes = encoder.encode(`${stdout}${stderr}`).byteLength;
+  let body = text;
+  let parseError;
+  if (text) {
+    const jsonStart = text.indexOf("{");
+    const jsonText = jsonStart >= 0 ? text.slice(jsonStart) : text;
+    try {
+      body = JSON.parse(jsonText);
+    } catch (error) {
+      parseError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  await options.writeArtifact?.({
+    content: `${JSON.stringify({
+      command: target.command,
+      parseError,
+      stderr,
+      stdout,
+      status,
+      summary: parseError ? undefined : body
+    }, null, 2)}
+`,
+    name: `${safeArtifactName(target.name)}.json`,
+    target
+  });
+  const logicalFailure = !parseError ? getVoiceProofTargetLogicalFailure(body) : undefined;
+  return {
+    body,
+    bytes,
+    command: target.command,
+    elapsedMs: Math.round(now() - startedAt),
+    error: parseError ?? logicalFailure ?? (status === 0 ? undefined : stderr.trim() || `Command exited ${status}`),
+    kind: "command",
+    name: target.name,
+    ok: status === 0 && !parseError && !logicalFailure,
+    status,
+    summary: parseError ? { bytes, parseError } : summarizeValue(body)
+  };
+};
+var runVoiceCommandProofTargets = (targets, options) => mapVoiceProofTargetsWithConcurrency(targets, options.concurrency ?? targets.length, (target) => runVoiceCommandProofTarget(target, options));
 // src/providerRouterTraces.ts
 var buildVoiceProviderRouterTraceEvent = (options) => ({
   at: options.at ?? options.event.at,
@@ -23690,9 +23902,9 @@ var flattenPayload = (value) => {
 };
 var toBase64 = (bytes) => Buffer.from(new Uint8Array(bytes)).toString("base64");
 var timingSafeEqual = (left, right) => {
-  const encoder = new TextEncoder;
-  const leftBytes = encoder.encode(left);
-  const rightBytes = encoder.encode(right);
+  const encoder2 = new TextEncoder;
+  const leftBytes = encoder2.encode(left);
+  const rightBytes = encoder2.encode(right);
   if (leftBytes.length !== rightBytes.length) {
     return false;
   }
@@ -23703,12 +23915,12 @@ var timingSafeEqual = (left, right) => {
   return diff === 0;
 };
 var signHmacSHA1Base64 = async (secret, payload) => {
-  const encoder = new TextEncoder;
-  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+  const encoder2 = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder2.encode(secret), {
     hash: "SHA-1",
     name: "HMAC"
   }, false, ["sign"]);
-  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  const signature = await crypto.subtle.sign("HMAC", key, encoder2.encode(payload));
   return toBase64(signature);
 };
 var sortedParamsForSignature = (body) => Object.entries(flattenPayload(body)).filter(([, value]) => value !== undefined && value !== null).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}${String(value)}`).join("");
@@ -25308,9 +25520,9 @@ var createPlivoMediaStreamBridge = (socket, options) => {
 };
 var toBase642 = (bytes) => Buffer5.from(new Uint8Array(bytes)).toString("base64");
 var timingSafeEqual2 = (left, right) => {
-  const encoder = new TextEncoder;
-  const leftBytes = encoder.encode(left);
-  const rightBytes = encoder.encode(right);
+  const encoder2 = new TextEncoder;
+  const leftBytes = encoder2.encode(left);
+  const rightBytes = encoder2.encode(right);
   if (leftBytes.length !== rightBytes.length) {
     return false;
   }
@@ -25321,12 +25533,12 @@ var timingSafeEqual2 = (left, right) => {
   return diff === 0;
 };
 var signHmacSHA256Base64 = async (secret, payload) => {
-  const encoder = new TextEncoder;
-  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+  const encoder2 = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder2.encode(secret), {
     hash: "SHA-256",
     name: "HMAC"
   }, false, ["sign"]);
-  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  const signature = await crypto.subtle.sign("HMAC", key, encoder2.encode(payload));
   return toBase642(signature);
 };
 var sortedParamsForSignature2 = (body) => {
@@ -37449,18 +37661,18 @@ var createVoiceMemoryStore = () => {
 import { Elysia as Elysia61 } from "elysia";
 var toHex6 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signVoiceOpsWebhookBody = async (input) => {
-  const encoder = new TextEncoder;
-  const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
+  const encoder2 = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder2.encode(input.secret), {
     hash: "SHA-256",
     name: "HMAC"
   }, false, ["sign"]);
-  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(`${input.timestamp}.${input.body}`));
+  const signature = await crypto.subtle.sign("HMAC", key, encoder2.encode(`${input.timestamp}.${input.body}`));
   return `sha256=${toHex6(new Uint8Array(signature))}`;
 };
 var timingSafeEqual3 = (left, right) => {
-  const encoder = new TextEncoder;
-  const leftBytes = encoder.encode(left);
-  const rightBytes = encoder.encode(right);
+  const encoder2 = new TextEncoder;
+  const leftBytes = encoder2.encode(left);
+  const rightBytes = encoder2.encode(right);
   if (leftBytes.length !== rightBytes.length) {
     return false;
   }
@@ -39384,9 +39596,12 @@ export {
   runVoiceReconnectContract,
   runVoiceRealCallProfileRecoveryLoop,
   runVoiceProviderRoutingContract,
+  runVoiceProofTargets,
   runVoiceProfileSwitchPolicyProof,
   runVoicePhoneAgentProductionSmokeContract,
   runVoiceOutcomeContractSuite,
+  runVoiceCommandProofTargets,
+  runVoiceCommandProofTarget,
   runVoiceCampaignReadinessProof,
   runVoiceCampaignProof,
   runVoiceCampaignDialerProof,
@@ -39522,6 +39737,7 @@ export {
   muteVoiceMonitorIssue,
   matchesVoiceOpsTaskAssignmentRule,
   markVoiceOpsTaskSLABreached,
+  mapVoiceProofTargetsWithConcurrency,
   loadVoiceRealCallProfileEvidenceFromTraceStore,
   loadVoiceObservabilityExportReplaySource,
   listVoiceRoutingEvents,
@@ -39531,6 +39747,7 @@ export {
   importVoiceCampaignRecipients,
   heartbeatVoiceOpsTask,
   hasVoiceOpsTaskSLABreach,
+  getVoiceProofTargetLogicalFailure,
   getVoiceLiveOpsControlStatus,
   getVoiceCampaignDialerProofStatus,
   getLatestVoiceTelephonyMediaReport,
@@ -39539,6 +39756,7 @@ export {
   formatVoiceProofTrendAge,
   filterVoiceTraceEvents,
   filterVoiceAuditEvents,
+  fetchVoiceProofTarget,
   failVoiceOpsTask,
   exportVoiceTrace,
   exportVoiceAuditTrail,

package/dist/proofRunner.d.ts

@@ -0,0 +1,79 @@
+export type VoiceProofTargetMethod = 'GET' | 'POST';
+export type VoiceProofTarget = {
+    accept?: string;
+    allowLogicalFail?: boolean;
+    body?: unknown;
+    kind: 'json' | 'text';
+    method?: VoiceProofTargetMethod;
+    name: string;
+    path: string;
+    requiredText?: string[];
+};
+export type VoiceProofTargetResult = {
+    body?: unknown;
+    bytes: number;
+    elapsedMs: number;
+    error?: string;
+    kind: VoiceProofTarget['kind'];
+    method: VoiceProofTargetMethod;
+    name: string;
+    ok: boolean;
+    path: string;
+    status?: number;
+    summary?: Record<string, unknown>;
+    url: string;
+};
+export type VoiceCommandProofTarget = {
+    command: string[];
+    kind: 'command';
+    name: string;
+};
+export type VoiceCommandProofExecutionResult = {
+    status: number;
+    stderr?: string;
+    stdout?: string;
+};
+export type VoiceCommandProofTargetResult = {
+    body?: unknown;
+    bytes: number;
+    command: string[];
+    elapsedMs: number;
+    error?: string;
+    kind: 'command';
+    name: string;
+    ok: boolean;
+    status?: number;
+    summary?: Record<string, unknown>;
+};
+export type VoiceProofTargetRunnerOptions = {
+    baseUrl: string;
+    fetch?: typeof fetch;
+    now?: () => number;
+    timeoutMs?: number;
+    writeArtifact?: (input: {
+        content: string;
+        name: string;
+        target: VoiceProofTarget;
+    }) => Promise<void> | void;
+};
+export type VoiceProofTargetRunOptions = VoiceProofTargetRunnerOptions & {
+    concurrency?: number;
+};
+export type VoiceCommandProofTargetRunnerOptions = {
+    execute: (target: VoiceCommandProofTarget) => Promise<VoiceCommandProofExecutionResult> | VoiceCommandProofExecutionResult;
+    now?: () => number;
+    writeArtifact?: (input: {
+        content: string;
+        name: string;
+        target: VoiceCommandProofTarget;
+    }) => Promise<void> | void;
+};
+export type VoiceCommandProofTargetRunOptions = VoiceCommandProofTargetRunnerOptions & {
+    concurrency?: number;
+};
+export declare const getVoiceProofTargetLogicalFailure: (value: unknown) => "Response status is \"fail\"." | "Response pass is false." | "Response ok is false." | undefined;
+export declare const mapVoiceProofTargetsWithConcurrency: <TInput, TOutput>(items: TInput[], limit: number, mapper: (item: TInput) => Promise<TOutput>) => Promise<TOutput[]>;
+export declare const fetchVoiceProofTarget: (target: VoiceProofTarget, options: VoiceProofTargetRunnerOptions) => Promise<VoiceProofTargetResult>;
+export declare const runVoiceProofTargets: (targets: VoiceProofTarget[], options: VoiceProofTargetRunOptions) => Promise<VoiceProofTargetResult[]>;
+export declare const runVoiceCommandProofTarget: (target: VoiceCommandProofTarget, options: VoiceCommandProofTargetRunnerOptions) => Promise<VoiceCommandProofTargetResult>;
+export declare const runVoiceCommandProofTargets: (targets: VoiceCommandProofTarget[], options: VoiceCommandProofTargetRunOptions) => Promise<VoiceCommandProofTargetResult[]>;

package/package.json

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