@absolutejs/voice 0.0.22-beta.409 → 0.0.22-beta.410

package/README.md

@@ -1456,6 +1456,34 @@ app.use(
 );
 ```
 
+Use `buildVoiceProofPack(...)` and `writeVoiceProofPack(...)` when the app needs a customer-owned proof artifact instead of demo-only file glue. Proof packs render JSON and Markdown, expose route helpers, and can be converted into observability export artifacts:
+
+```ts
+import {
+	buildVoiceProofPackFromObservabilityExport,
+	createVoiceProofPackRoutes,
+	writeVoiceProofPack
+} from '@absolutejs/voice';
+
+const exportReport = await buildVoiceObservabilityExport({
+	store: runtime.traces,
+	audit: runtime.audit
+});
+const proofPack = buildVoiceProofPackFromObservabilityExport(exportReport, {
+	runId: 'release-proof'
+});
+const written = await writeVoiceProofPack(proofPack, {
+	outputDir: '.voice-runtime/proof-pack'
+});
+
+app.use(createVoiceProofPackRoutes({ source: proofPack }));
+
+const exportWithProofPack = await buildVoiceObservabilityExport({
+	artifacts: written.artifacts,
+	store: runtime.traces
+});
+```
+
 This primitive does not start workers, create persistent storage, mount a dashboard, or prescribe a deploy workflow. It only gives self-hosted apps one clean readiness-proof runtime so JSON, HTML, gate checks, proof packs, and trend artifacts agree on the same fresh evidence window.
 
 Use `buildVoiceRealCallProfileEvidenceFromTraceEvents(...)` or `loadVoiceRealCallProfileEvidenceFromTraceStore(...)` when repeated real browser/phone sessions should drive profile defaults and provider/runtime recommendations. These helpers read ordinary trace events such as `session.error`, `provider.decision`, `client.live_latency`, `client.browser_media`, `client.telephony_media`, `client.barge_in`, and `turn_latency.stage`, then emit `VoiceProofTrendRealCallProfileEvidence[]` for `buildVoiceRealCallProfileHistoryReport(...)`.

package/dist/index.d.ts

@@ -206,4 +206,6 @@ export type { PlivoInboundMessage, PlivoMediaStreamBridge, PlivoMediaStreamBridg
 export type { VoiceTelephonyCarrierMatrix, VoiceTelephonyCarrierMatrixEntry, VoiceTelephonyCarrierMatrixInput, VoiceTelephonyCarrierMatrixOptions, VoiceTelephonyCarrierMatrixRoutesOptions, VoiceTelephonyCarrierMatrixStatus } from './telephony/matrix';
 export { shapeTelephonyAssistantText } from './telephony/response';
 export type { TelephonyResponseShapeMode, TelephonyResponseShapeOptions } from './telephony/response';
+export { buildVoiceProofPack, buildVoiceProofPackFromObservabilityExport, createVoiceProofPackArtifacts, createVoiceProofPackRoutes, renderVoiceProofPackMarkdown, writeVoiceProofPack } from './proofPack';
+export type { VoiceProofPack, VoiceProofPackEvidence, VoiceProofPackInput, VoiceProofPackRoutesOptions, VoiceProofPackSection, VoiceProofPackStatus, VoiceProofPackWriteResult } from './proofPack';
 export * from './types';

package/dist/index.js

@@ -39858,7 +39858,209 @@ var shapeTelephonyAssistantText = (text, options = {}) => {
   const limitedChars = clampChars(limitedWords, options.maxChars);
   return ensureTerminalPunctuation(normalizeWhitespace(limitedChars));
 };
+// src/proofPack.ts
+import { Elysia as Elysia66 } from "elysia";
+import { mkdir as mkdir5 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+var toGeneratedAt = (value) => value === undefined ? new Date().toISOString() : typeof value === "number" ? new Date(value).toISOString() : value;
+var summarizeProofPackSections = (sections) => {
+  let pass = 0;
+  let warn = 0;
+  let fail = 0;
+  for (const section of sections) {
+    const statuses = [
+      section.status,
+      ...(section.evidence ?? []).map((evidence) => evidence.status)
+    ].filter((status) => Boolean(status));
+    if (statuses.some((status) => status === "fail")) {
+      fail += 1;
+    } else if (statuses.some((status) => status === "warn")) {
+      warn += 1;
+    } else {
+      pass += 1;
+    }
+  }
+  return { fail, pass, sections: sections.length, warn };
+};
+var resolveProofPack = async (source) => {
+  const input = typeof source === "function" ? await source() : source;
+  return buildVoiceProofPack(input);
+};
+var buildVoiceProofPack = (input) => {
+  if ("status" in input && "ok" in input && "summary" in input && Array.isArray(input.sections)) {
+    return input;
+  }
+  const sections = input.sections ?? [];
+  const summary = summarizeProofPackSections(sections);
+  const status = summary.fail > 0 ? "fail" : summary.warn > 0 ? "warn" : "pass";
+  return {
+    artifacts: input.artifacts ?? [],
+    generatedAt: toGeneratedAt(input.generatedAt),
+    ok: status === "pass",
+    outputDir: input.outputDir,
+    runId: input.runId ?? `voice-proof-pack-${crypto.randomUUID()}`,
+    sections,
+    status,
+    summary
+  };
+};
+var buildVoiceProofPackFromObservabilityExport = (report, input = {}) => buildVoiceProofPack({
+  ...input,
+  artifacts: report.artifacts,
+  generatedAt: input.generatedAt ?? report.checkedAt,
+  sections: [
+    {
+      evidence: [
+        {
+          label: "Trace events",
+          status: report.summary.traceEvents > 0 ? "pass" : "warn",
+          value: report.summary.traceEvents
+        },
+        {
+          label: "Audit events",
+          status: report.summary.auditEvents > 0 ? "pass" : "warn",
+          value: report.summary.auditEvents
+        },
+        {
+          label: "Artifacts",
+          status: report.artifacts.some((artifact) => artifact.status === "fail") ? "fail" : report.artifacts.some((artifact) => artifact.status === "warn") ? "warn" : "pass",
+          value: report.artifacts.length
+        }
+      ],
+      status: report.status,
+      summary: "Customer-owned observability export evidence.",
+      title: "Observability export"
+    },
+    {
+      evidence: report.issues.map((issue) => ({
+        detail: issue.detail,
+        label: issue.label,
+        status: issue.severity,
+        value: issue.value
+      })),
+      status: report.status,
+      summary: report.issues.length === 0 ? "No export issues were reported." : `${report.issues.length} export issue(s) were reported.`,
+      title: "Export issues"
+    }
+  ]
+});
+var renderVoiceProofPackMarkdown = (proofPack) => {
+  const sections = proofPack.sections.map((section) => {
+    const evidence = (section.evidence ?? []).map((item) => {
+      const value = item.value === undefined ? "" : `: ${String(item.value)}`;
+      const href = item.href ? ` (${item.href})` : "";
+      const detail = item.detail ? ` - ${item.detail}` : "";
+      return `- ${item.label}${value}${href} - ${item.status ?? "pass"}${detail}`;
+    }).join(`
+`);
+    return [
+      `## ${section.title}`,
+      "",
+      section.summary ?? "",
+      "",
+      evidence
+    ].filter(Boolean).join(`
+`);
+  }).join(`
+
+`);
+  return [
+    "# AbsoluteJS Voice Proof Pack",
+    "",
+    `Run: ${proofPack.runId}`,
+    `Generated: ${proofPack.generatedAt}`,
+    `Status: ${proofPack.status}`,
+    "",
+    `Sections: ${proofPack.summary.sections}`,
+    `Passing sections: ${proofPack.summary.pass}`,
+    `Warning sections: ${proofPack.summary.warn}`,
+    `Failing sections: ${proofPack.summary.fail}`,
+    "",
+    sections
+  ].filter(Boolean).join(`
+`);
+};
+var writeVoiceProofPack = async (input, options = { outputDir: ".voice-runtime/proof-pack" }) => {
+  const proofPack = buildVoiceProofPack({
+    ...input,
+    outputDir: options.outputDir
+  });
+  const jsonPath = join4(options.outputDir, options.jsonFileName ?? "latest.json");
+  const markdownPath = join4(options.outputDir, options.markdownFileName ?? "latest.md");
+  await mkdir5(dirname3(jsonPath), { recursive: true });
+  await mkdir5(dirname3(markdownPath), { recursive: true });
+  await Promise.all([
+    Bun.write(jsonPath, JSON.stringify(proofPack, null, 2)),
+    Bun.write(markdownPath, renderVoiceProofPackMarkdown(proofPack))
+  ]);
+  return {
+    artifacts: createVoiceProofPackArtifacts({
+      jsonPath,
+      markdownPath,
+      proofPack
+    }),
+    jsonPath,
+    markdownPath,
+    proofPack
+  };
+};
+var createVoiceProofPackArtifacts = (input) => [
+  ...input.markdownPath ? [
+    {
+      generatedAt: input.proofPack.generatedAt,
+      id: "latest-proof-pack",
+      kind: "proof-pack",
+      label: "Latest proof pack",
+      metadata: {
+        proofPackStatus: input.proofPack.status,
+        runId: input.proofPack.runId
+      },
+      path: input.markdownPath,
+      required: false,
+      status: "pass"
+    }
+  ] : [],
+  ...input.jsonPath ? [
+    {
+      contentType: "application/json",
+      generatedAt: input.proofPack.generatedAt,
+      id: "latest-proof-pack-json",
+      kind: "proof-pack",
+      label: "Latest proof pack JSON",
+      metadata: {
+        proofPackStatus: input.proofPack.status,
+        runId: input.proofPack.runId
+      },
+      path: input.jsonPath,
+      required: false,
+      status: "pass"
+    }
+  ] : []
+];
+var createVoiceProofPackRoutes = (options) => {
+  const jsonPath = options.jsonPath ?? "/api/voice/proof-pack";
+  const markdownPath = options.markdownPath ?? "/voice/proof-pack.md";
+  const app = new Elysia66({ name: options.name ?? "voice-proof-pack" });
+  if (jsonPath !== false) {
+    app.get(jsonPath, async () => new Response(JSON.stringify(await resolveProofPack(options.source), null, 2), {
+      headers: {
+        "content-type": "application/json; charset=utf-8",
+        ...options.headers
+      }
+    }));
+  }
+  if (markdownPath !== false) {
+    app.get(markdownPath, async () => new Response(renderVoiceProofPackMarkdown(await resolveProofPack(options.source)), {
+      headers: {
+        "content-type": "text/markdown; charset=utf-8",
+        ...options.headers
+      }
+    }));
+  }
+  return app;
+};
 export {
+  writeVoiceProofPack,
   withVoiceOpsTaskId,
   withVoiceIntegrationEventId,
   voiceTelephonyOutcomeToRouteResult,
@@ -39993,6 +40195,7 @@ export {
   renderVoiceProviderCapabilityHTML,
   renderVoiceProofTrendRecommendationMarkdown,
   renderVoiceProofTrendRecommendationHTML,
+  renderVoiceProofPackMarkdown,
   renderVoiceProfileSwitchReadinessHTML,
   renderVoiceProfileSwitchPolicyProofHTML,
   renderVoiceProfileSwitchLiveDecisionHTML,
@@ -40259,6 +40462,8 @@ export {
   createVoiceProviderCapabilityHTMLHandler,
   createVoiceProofTrendRoutes,
   createVoiceProofTrendRecommendationRoutes,
+  createVoiceProofPackRoutes,
+  createVoiceProofPackArtifacts,
   createVoiceProofAssertion,
   createVoiceProfileTraceTagger,
   createVoiceProfileSwitchReadinessRoutes,
@@ -40477,6 +40682,8 @@ export {
   buildVoiceProofTrendReport,
   buildVoiceProofTrendRecommendationReport,
   buildVoiceProofTrendProfileSummaries,
+  buildVoiceProofPackFromObservabilityExport,
+  buildVoiceProofPack,
   buildVoiceProfileSwitchReadinessReport,
   buildVoiceProfileSwitchLiveDecisionReport,
   buildVoiceProductionReadinessReport,

package/dist/proofPack.d.ts

@@ -0,0 +1,92 @@
+import { Elysia } from 'elysia';
+import type { VoiceObservabilityExportArtifact, VoiceObservabilityExportReport } from './observabilityExport';
+export type VoiceProofPackStatus = 'fail' | 'pass' | 'warn';
+export type VoiceProofPackEvidence = {
+    detail?: string;
+    href?: string;
+    label: string;
+    status?: VoiceProofPackStatus;
+    value?: number | string;
+};
+export type VoiceProofPackSection = {
+    evidence?: VoiceProofPackEvidence[];
+    status?: VoiceProofPackStatus;
+    summary?: string;
+    title: string;
+};
+export type VoiceProofPack = {
+    artifacts: VoiceObservabilityExportArtifact[];
+    generatedAt: string;
+    ok: boolean;
+    outputDir?: string;
+    runId: string;
+    sections: VoiceProofPackSection[];
+    status: VoiceProofPackStatus;
+    summary: {
+        fail: number;
+        pass: number;
+        sections: number;
+        warn: number;
+    };
+};
+export type VoiceProofPackInput = {
+    artifacts?: VoiceObservabilityExportArtifact[];
+    generatedAt?: number | string;
+    outputDir?: string;
+    runId?: string;
+    sections?: VoiceProofPackSection[];
+};
+export type VoiceProofPackWriteResult = {
+    artifacts: VoiceObservabilityExportArtifact[];
+    jsonPath: string;
+    markdownPath: string;
+    proofPack: VoiceProofPack;
+};
+export type VoiceProofPackRoutesOptions = {
+    headers?: HeadersInit;
+    jsonPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    source: VoiceProofPack | VoiceProofPackInput | (() => VoiceProofPack | VoiceProofPackInput | Promise<VoiceProofPack | VoiceProofPackInput>);
+};
+export declare const buildVoiceProofPack: (input: VoiceProofPackInput | VoiceProofPack) => VoiceProofPack;
+export declare const buildVoiceProofPackFromObservabilityExport: (report: VoiceObservabilityExportReport, input?: Omit<VoiceProofPackInput, "artifacts" | "sections">) => VoiceProofPack;
+export declare const renderVoiceProofPackMarkdown: (proofPack: VoiceProofPack) => string;
+export declare const writeVoiceProofPack: (input: VoiceProofPackInput | VoiceProofPack, options?: {
+    jsonFileName?: string;
+    markdownFileName?: string;
+    outputDir: string;
+}) => Promise<VoiceProofPackWriteResult>;
+export declare const createVoiceProofPackArtifacts: (input: {
+    jsonPath?: string;
+    markdownPath?: string;
+    proofPack: VoiceProofPack;
+}) => VoiceObservabilityExportArtifact[];
+export declare const createVoiceProofPackRoutes: (options: VoiceProofPackRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/package.json

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