@absolutejs/voice 0.0.22-beta.510 → 0.0.22-beta.511

package/dist/index.d.ts

@@ -311,4 +311,14 @@ export { createVoiceRetryPolicy } from "./retryPolicy";
 export type { VoiceRetryAttempt, VoiceRetryDecision, VoiceRetryDispositionAction, VoiceRetryDispositionRule, VoiceRetryPolicy, CreateVoiceRetryPolicyOptions, } from "./retryPolicy";
 export { collectVoiceCampaignTemplateVariables, DEFAULT_VOICE_CAMPAIGN_TEMPLATE_FILTERS, resolveVoiceCampaignTemplate, } from "./campaignTemplate";
 export type { ResolveVoiceCampaignTemplateOptions, VoiceCampaignTemplateFilter, VoiceCampaignTemplateResolveResult, VoiceCampaignTemplateScope, VoiceCampaignTemplateValue, } from "./campaignTemplate";
+export { createVoiceWhisperChannel } from "./whisperChannel";
+export type { CreateVoiceWhisperChannelOptions, VoiceWhisperChannel, VoiceWhisperEvent, VoiceWhisperFrame, VoiceWhisperRoute, } from "./whisperChannel";
+export { createVoiceLiveCoach } from "./liveCoach";
+export type { CreateVoiceLiveCoachOptions, VoiceCoachNudge, VoiceCoachNudgeInjection, VoiceCoachNudgeKind, VoiceLiveCoach, } from "./liveCoach";
+export { createVoiceTranscriptAnnotator, DEFAULT_VOICE_ANNOTATION_KIND_SEVERITY, } from "./transcriptAnnotator";
+export type { CreateVoiceTranscriptAnnotatorOptions, VoiceTranscriptAnnotation, VoiceTranscriptAnnotationKind, VoiceTranscriptAnnotator, } from "./transcriptAnnotator";
+export { createVoiceSupervisorPresence } from "./supervisorPresence";
+export type { CreateVoiceSupervisorPresenceOptions, VoiceSupervisorPresence, VoiceSupervisorPresenceEvent, VoiceSupervisorRole, VoiceSupervisorWatcher, } from "./supervisorPresence";
+export { createVoiceSupervisorPermissions, VOICE_SUPERVISOR_TIER_CAPABILITIES, } from "./supervisorPermissions";
+export type { CreateVoiceSupervisorPermissionsOptions, VoiceSupervisorCapability, VoiceSupervisorPermission, VoiceSupervisorPermissionCheck, VoiceSupervisorPermissions, VoiceSupervisorTier, } from "./supervisorPermissions";
 export * from "./types";

package/dist/index.js

@@ -49171,6 +49171,437 @@ var collectVoiceCampaignTemplateVariables = (template) => {
   }
   return Array.from(set);
 };
+// src/whisperChannel.ts
+var createVoiceWhisperChannel = (options) => {
+  const now = options.now ?? (() => Date.now());
+  const defaultRoute = options.defaultRoute ?? "agent-only";
+  const duckLevel = options.duckCallerToLevel ?? 0.25;
+  const maxConcurrent = options.maxConcurrentWhispers ?? 1;
+  const active = new Map;
+  const listeners = new Set;
+  const broadcast = (event) => {
+    for (const listener of listeners)
+      listener(event);
+  };
+  const start = (supervisorId, route = defaultRoute) => {
+    if (active.has(supervisorId))
+      return active.get(supervisorId);
+    if (active.size >= maxConcurrent) {
+      throw new Error(`Whisper channel already at max concurrent (${maxConcurrent})`);
+    }
+    const entry = {
+      route,
+      startedAt: now(),
+      supervisorId
+    };
+    active.set(supervisorId, entry);
+    broadcast({ at: entry.startedAt, supervisorId, type: "started" });
+    if (route === "agent-only") {
+      broadcast({
+        at: entry.startedAt,
+        level: duckLevel,
+        supervisorId,
+        type: "ducked"
+      });
+    }
+    return entry;
+  };
+  const stop = (supervisorId) => {
+    if (!active.has(supervisorId))
+      return false;
+    active.delete(supervisorId);
+    broadcast({ at: now(), supervisorId, type: "stopped" });
+    return true;
+  };
+  const pushFrame = (frame) => {
+    const entry = active.get(frame.supervisorId);
+    if (!entry)
+      return "drop";
+    if (entry.route === "drop")
+      return "drop";
+    broadcast({ frame, type: "frame" });
+    return entry.route;
+  };
+  return {
+    activeSupervisors: () => Array.from(active.keys()),
+    isWhispering: (supervisorId) => active.has(supervisorId),
+    pushFrame,
+    routeFor: (supervisorId) => active.get(supervisorId)?.route ?? null,
+    sessionId: options.sessionId,
+    setRoute(supervisorId, route) {
+      const entry = active.get(supervisorId);
+      if (!entry)
+        return false;
+      entry.route = route;
+      return true;
+    },
+    start,
+    stop,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+// src/liveCoach.ts
+var DEFAULT_TEMPLATES = {
+  correction: "Supervisor correction (do not repeat this verbatim; weave it into your next response): {{text}}",
+  hint: "Supervisor hint: {{text}}",
+  knowledge: "Reference information from supervisor: {{text}}",
+  "script-line": "Supervisor-approved phrasing to use next: {{text}}",
+  warning: "Supervisor warning: {{text}}. Adjust your approach."
+};
+var createVoiceLiveCoach = (options) => {
+  const now = options.now ?? (() => Date.now());
+  const generateId = options.generateId ?? (() => `nudge_${Math.random().toString(36).slice(2, 10)}`);
+  const role = options.injectionRole ?? "system";
+  const templates = { ...DEFAULT_TEMPLATES, ...options.templateForKind ?? {} };
+  const nudges = [];
+  const listeners = new Set;
+  const push = (input) => {
+    const nudge = {
+      acknowledged: false,
+      createdAt: now(),
+      id: input.id ?? generateId(),
+      injected: false,
+      kind: input.kind,
+      sessionId: options.sessionId,
+      supervisorId: input.supervisorId,
+      text: input.text,
+      ...input.expiresAt !== undefined ? { expiresAt: input.expiresAt } : options.defaultExpiryMs !== undefined ? { expiresAt: now() + options.defaultExpiryMs } : {}
+    };
+    nudges.push(nudge);
+    for (const listener of listeners)
+      listener(nudge);
+    return nudge;
+  };
+  const pending = () => {
+    const at = now();
+    return nudges.filter((n) => !n.injected && !n.acknowledged && (n.expiresAt === undefined || n.expiresAt > at));
+  };
+  const consumeForInjection = () => {
+    const at = now();
+    const ready = pending();
+    const result = [];
+    for (const nudge of ready) {
+      const template = templates[nudge.kind] ?? DEFAULT_TEMPLATES[nudge.kind];
+      const content = template.replace(/\{\{text\}\}/gu, nudge.text);
+      nudge.injected = true;
+      nudge.injectedAt = at;
+      result.push({
+        content,
+        metadata: {
+          kind: nudge.kind,
+          nudgeId: nudge.id,
+          supervisorId: nudge.supervisorId
+        },
+        role
+      });
+    }
+    return result;
+  };
+  const acknowledge = (id) => {
+    const nudge = nudges.find((n) => n.id === id);
+    if (!nudge)
+      return false;
+    nudge.acknowledged = true;
+    nudge.acknowledgedAt = now();
+    return true;
+  };
+  return {
+    acknowledge,
+    consumeForInjection,
+    history: () => nudges.slice(),
+    pending,
+    push,
+    sessionId: options.sessionId,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+// src/transcriptAnnotator.ts
+var DEFAULT_VOICE_ANNOTATION_KIND_SEVERITY = {
+  "compliance-concern": "major",
+  custom: "info",
+  "follow-up-needed": "minor",
+  "great-recovery": "info",
+  "knowledge-gap": "minor",
+  "missed-objection": "minor",
+  "tone-issue": "minor"
+};
+var createVoiceTranscriptAnnotator = (options) => {
+  const now = options.now ?? (() => Date.now());
+  const generateId = options.generateId ?? (() => `ann_${Math.random().toString(36).slice(2, 10)}`);
+  const annotations = [];
+  const add = (input) => {
+    if (input.kind === "custom" && !input.customLabel) {
+      throw new Error("customLabel is required for kind=custom");
+    }
+    const annotation = {
+      createdAt: now(),
+      id: input.id ?? generateId(),
+      kind: input.kind,
+      rangeStartMs: input.rangeStartMs,
+      sessionId: options.sessionId,
+      severity: input.severity ?? DEFAULT_VOICE_ANNOTATION_KIND_SEVERITY[input.kind],
+      supervisorId: input.supervisorId,
+      ...input.customLabel !== undefined ? { customLabel: input.customLabel } : {},
+      ...input.rangeEndMs !== undefined ? { rangeEndMs: input.rangeEndMs } : {},
+      ...input.text !== undefined ? { text: input.text } : {},
+      ...input.turnId !== undefined ? { turnId: input.turnId } : {}
+    };
+    annotations.push(annotation);
+    return annotation;
+  };
+  const remove = (id) => {
+    const idx = annotations.findIndex((a) => a.id === id);
+    if (idx === -1)
+      return false;
+    annotations.splice(idx, 1);
+    return true;
+  };
+  const list = (filter) => annotations.filter((a) => {
+    if (filter?.kind && a.kind !== filter.kind)
+      return false;
+    if (filter?.supervisorId && a.supervisorId !== filter.supervisorId) {
+      return false;
+    }
+    if (filter?.severity && a.severity !== filter.severity)
+      return false;
+    if (filter?.fromMs !== undefined && a.rangeStartMs < filter.fromMs) {
+      return false;
+    }
+    if (filter?.toMs !== undefined && a.rangeStartMs > filter.toMs) {
+      return false;
+    }
+    return true;
+  });
+  const summarize = () => {
+    const byKind = {};
+    const bySeverity = {
+      info: 0,
+      major: 0,
+      minor: 0
+    };
+    for (const a of annotations) {
+      byKind[a.kind] = (byKind[a.kind] ?? 0) + 1;
+      bySeverity[a.severity] += 1;
+    }
+    return { byKind, bySeverity, total: annotations.length };
+  };
+  return {
+    add,
+    list,
+    remove,
+    sessionId: options.sessionId,
+    summarize
+  };
+};
+// src/supervisorPresence.ts
+var createVoiceSupervisorPresence = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  const staleAfter = options.staleAfterMs ?? 30000;
+  const bySession = new Map;
+  const listeners = new Set;
+  const emit2 = (event) => {
+    for (const listener of listeners)
+      listener(event);
+  };
+  const ensureSession = (sessionId) => {
+    let map = bySession.get(sessionId);
+    if (!map) {
+      map = new Map;
+      bySession.set(sessionId, map);
+    }
+    return map;
+  };
+  const pruneStaleFromSession = (sessionId, sessionWatchers) => {
+    const at = now();
+    for (const [id, w] of sessionWatchers) {
+      if (at - w.lastSeenAt > staleAfter) {
+        sessionWatchers.delete(id);
+        emit2({ at, sessionId, supervisorId: id, type: "leave" });
+      }
+    }
+  };
+  const join5 = (input) => {
+    const sessionWatchers = ensureSession(input.sessionId);
+    pruneStaleFromSession(input.sessionId, sessionWatchers);
+    const at = now();
+    const watcher = {
+      joinedAt: at,
+      lastSeenAt: at,
+      role: input.role ?? "viewer",
+      sessionId: input.sessionId,
+      supervisorId: input.supervisorId,
+      ...input.displayName !== undefined ? { displayName: input.displayName } : {}
+    };
+    sessionWatchers.set(input.supervisorId, watcher);
+    emit2({ type: "join", watcher });
+    return watcher;
+  };
+  const leave = (sessionId, supervisorId) => {
+    const sessionWatchers = bySession.get(sessionId);
+    if (!sessionWatchers?.delete(supervisorId))
+      return false;
+    if (sessionWatchers.size === 0)
+      bySession.delete(sessionId);
+    emit2({ at: now(), sessionId, supervisorId, type: "leave" });
+    return true;
+  };
+  const heartbeat = (sessionId, supervisorId) => {
+    const watcher = bySession.get(sessionId)?.get(supervisorId);
+    if (!watcher)
+      return false;
+    const at = now();
+    watcher.lastSeenAt = at;
+    emit2({ at, sessionId, supervisorId, type: "heartbeat" });
+    return true;
+  };
+  const setRole = (sessionId, supervisorId, role) => {
+    const watcher = bySession.get(sessionId)?.get(supervisorId);
+    if (!watcher)
+      return false;
+    if (watcher.role === role)
+      return true;
+    const from = watcher.role;
+    watcher.role = role;
+    emit2({
+      at: now(),
+      from,
+      sessionId,
+      supervisorId,
+      to: role,
+      type: "role-change"
+    });
+    return true;
+  };
+  const list = (sessionId) => {
+    const sessionWatchers = bySession.get(sessionId);
+    if (!sessionWatchers)
+      return [];
+    pruneStaleFromSession(sessionId, sessionWatchers);
+    return Array.from(sessionWatchers.values());
+  };
+  return {
+    heartbeat,
+    join: join5,
+    leave,
+    list,
+    setRole,
+    sessionsWatchedBy(supervisorId) {
+      const out = [];
+      for (const [sessionId, map] of bySession) {
+        if (map.has(supervisorId))
+          out.push(sessionId);
+      }
+      return out;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+// src/supervisorPermissions.ts
+var TIER_CAPABILITIES = {
+  annotate: ["monitor", "annotate"],
+  coach: ["monitor", "annotate", "coach"],
+  "full-control": [
+    "monitor",
+    "annotate",
+    "coach",
+    "whisper",
+    "barge",
+    "takeover",
+    "release",
+    "end-call",
+    "view-pii",
+    "export-recording"
+  ],
+  "monitor-only": ["monitor"],
+  whisper: ["monitor", "annotate", "coach", "whisper"]
+};
+var createVoiceSupervisorPermissions = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  const store = new Map;
+  for (const permission of options.permissions ?? []) {
+    store.set(permission.supervisorId, permission);
+  }
+  const defaultTier = options.defaultTier ?? null;
+  const get = (supervisorId) => {
+    const permission = store.get(supervisorId);
+    if (!permission) {
+      return defaultTier ? { supervisorId, tier: defaultTier } : null;
+    }
+    if (permission.expiresAt !== undefined && permission.expiresAt <= now()) {
+      return null;
+    }
+    return permission;
+  };
+  const capabilitiesFor = (supervisorId) => {
+    const permission = get(supervisorId);
+    if (!permission)
+      return [];
+    const base = new Set(TIER_CAPABILITIES[permission.tier]);
+    for (const extra of permission.extraCapabilities ?? [])
+      base.add(extra);
+    for (const denied of permission.deniedCapabilities ?? [])
+      base.delete(denied);
+    return Array.from(base);
+  };
+  const can = (supervisorId, capability) => {
+    const permission = store.get(supervisorId);
+    if (!permission) {
+      if (!defaultTier)
+        return { allowed: false, reason: "no-permission" };
+    } else if (permission.expiresAt !== undefined && permission.expiresAt <= now()) {
+      return { allowed: false, reason: "expired" };
+    } else if (permission.deniedCapabilities?.includes(capability)) {
+      return { allowed: false, reason: "denied" };
+    }
+    if (capabilitiesFor(supervisorId).includes(capability)) {
+      return { allowed: true };
+    }
+    return { allowed: false, reason: "tier-too-low" };
+  };
+  const grant = (supervisorId, tier, options2 = {}) => {
+    const permission = {
+      supervisorId,
+      tier,
+      ...options2.extraCapabilities !== undefined ? { extraCapabilities: options2.extraCapabilities } : {},
+      ...options2.deniedCapabilities !== undefined ? { deniedCapabilities: options2.deniedCapabilities } : {},
+      ...options2.expiresAt !== undefined ? { expiresAt: options2.expiresAt } : {}
+    };
+    store.set(supervisorId, permission);
+    return permission;
+  };
+  const revoke = (supervisorId) => store.delete(supervisorId);
+  const enforce = (supervisorId, capability) => {
+    const verdict = can(supervisorId, capability);
+    if (!verdict.allowed) {
+      throw new Error(`Supervisor ${supervisorId} cannot ${capability}: ${verdict.reason ?? "denied"}`);
+    }
+  };
+  return {
+    can,
+    capabilitiesFor,
+    enforce,
+    get,
+    grant,
+    revoke,
+    tiers: () => Object.keys(TIER_CAPABILITIES)
+  };
+};
+var VOICE_SUPERVISOR_TIER_CAPABILITIES = TIER_CAPABILITIES;
 export {
   writeVoiceProofPack,
   writeVoiceMediaPipelineArtifacts,
@@ -49521,6 +49952,7 @@ export {
   createVoiceWorkflowContractPreset,
   createVoiceWorkflowContractHandler,
   createVoiceWorkflowContract,
+  createVoiceWhisperChannel,
   createVoiceWebhookHandoffAdapter,
   createVoiceWebhookFanout,
   createVoiceWebhookDeliveryWorkerLoop,
@@ -49538,6 +49970,7 @@ export {
   createVoiceTurnLatencyHTMLHandler,
   createVoiceTransferCallTool,
   createVoiceTranscriptRedactor,
+  createVoiceTranscriptAnnotator,
   createVoiceTraceTimelineRoutes,
   createVoiceTraceSinkStore,
   createVoiceTraceSinkDeliveryWorkerLoop,
@@ -49572,6 +50005,8 @@ export {
   createVoiceTaskSLABreachedEvent,
   createVoiceTaskCreatedEvent,
   createVoiceTTSProviderRouter,
+  createVoiceSupervisorPresence,
+  createVoiceSupervisorPermissions,
   createVoiceSloThresholdProfile,
   createVoiceSloReadinessThresholdRoutes,
   createVoiceSloReadinessThresholdOptions,
@@ -49744,6 +50179,7 @@ export {
   createVoiceLiveOpsController,
   createVoiceLiveMonitorRoutes,
   createVoiceLiveLatencyRoutes,
+  createVoiceLiveCoach,
   createVoiceLiveCallViewerHTMXRoute,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
@@ -50053,6 +50489,7 @@ export {
   VOICE_WEBHOOK_TIMESTAMP_HEADER,
   VOICE_WEBHOOK_SIGNATURE_HEADER,
   VOICE_TCPA_DEFAULT_WINDOW,
+  VOICE_SUPERVISOR_TIER_CAPABILITIES,
   VOICE_LIVE_OPS_ACTIONS,
   VOICE_DTMF_DIGITS,
   VOICE_CALLER_MEMORY_KEY,
@@ -50065,5 +50502,6 @@ export {
   DEFAULT_VOICE_POST_CALL_SURVEY_QUESTIONS,
   DEFAULT_VOICE_CAMPAIGN_TEMPLATE_FILTERS,
   DEFAULT_VOICE_CALL_DISPOSITIONS,
+  DEFAULT_VOICE_ANNOTATION_KIND_SEVERITY,
   BROWSER_NOISE_SUPPRESSOR_PRESETS
 };

package/dist/liveCoach.d.ts

@@ -0,0 +1,43 @@
+export type VoiceCoachNudgeKind = "hint" | "correction" | "warning" | "script-line" | "knowledge";
+export type VoiceCoachNudge = {
+    id: string;
+    sessionId: string;
+    supervisorId: string;
+    kind: VoiceCoachNudgeKind;
+    text: string;
+    createdAt: number;
+    injected: boolean;
+    injectedAt?: number;
+    acknowledged: boolean;
+    acknowledgedAt?: number;
+    expiresAt?: number;
+};
+export type VoiceCoachNudgeInjection = {
+    role: "system" | "developer";
+    content: string;
+    metadata: {
+        nudgeId: string;
+        supervisorId: string;
+        kind: VoiceCoachNudgeKind;
+    };
+};
+export type CreateVoiceLiveCoachOptions = {
+    sessionId: string;
+    injectionRole?: "system" | "developer";
+    templateForKind?: Partial<Record<VoiceCoachNudgeKind, string>>;
+    defaultExpiryMs?: number;
+    generateId?: () => string;
+    now?: () => number;
+};
+export declare const createVoiceLiveCoach: (options: CreateVoiceLiveCoachOptions) => {
+    acknowledge: (id: string) => boolean;
+    consumeForInjection: () => VoiceCoachNudgeInjection[];
+    history: () => VoiceCoachNudge[];
+    pending: () => VoiceCoachNudge[];
+    push: (input: Omit<VoiceCoachNudge, "id" | "createdAt" | "injected" | "acknowledged" | "sessionId"> & {
+        id?: string;
+    }) => VoiceCoachNudge;
+    sessionId: string;
+    subscribe(listener: (nudge: VoiceCoachNudge) => void): () => void;
+};
+export type VoiceLiveCoach = ReturnType<typeof createVoiceLiveCoach>;

package/dist/supervisorPermissions.d.ts

@@ -0,0 +1,33 @@
+export type VoiceSupervisorCapability = "monitor" | "annotate" | "coach" | "whisper" | "barge" | "takeover" | "release" | "end-call" | "view-pii" | "export-recording";
+export type VoiceSupervisorTier = "monitor-only" | "annotate" | "coach" | "whisper" | "full-control";
+export type VoiceSupervisorPermission = {
+    supervisorId: string;
+    tier: VoiceSupervisorTier;
+    extraCapabilities?: VoiceSupervisorCapability[];
+    deniedCapabilities?: VoiceSupervisorCapability[];
+    expiresAt?: number;
+};
+export type VoiceSupervisorPermissionCheck = {
+    allowed: boolean;
+    reason?: "no-permission" | "expired" | "denied" | "tier-too-low";
+};
+export type CreateVoiceSupervisorPermissionsOptions = {
+    defaultTier?: VoiceSupervisorTier;
+    permissions?: VoiceSupervisorPermission[];
+    now?: () => number;
+};
+export declare const createVoiceSupervisorPermissions: (options?: CreateVoiceSupervisorPermissionsOptions) => {
+    can: (supervisorId: string, capability: VoiceSupervisorCapability) => VoiceSupervisorPermissionCheck;
+    capabilitiesFor: (supervisorId: string) => VoiceSupervisorCapability[];
+    enforce: (supervisorId: string, capability: VoiceSupervisorCapability) => void;
+    get: (supervisorId: string) => VoiceSupervisorPermission | null;
+    grant: (supervisorId: string, tier: VoiceSupervisorTier, options?: {
+        extraCapabilities?: VoiceSupervisorCapability[];
+        deniedCapabilities?: VoiceSupervisorCapability[];
+        expiresAt?: number;
+    }) => VoiceSupervisorPermission;
+    revoke: (supervisorId: string) => boolean;
+    tiers: () => VoiceSupervisorTier[];
+};
+export type VoiceSupervisorPermissions = ReturnType<typeof createVoiceSupervisorPermissions>;
+export declare const VOICE_SUPERVISOR_TIER_CAPABILITIES: Record<VoiceSupervisorTier, VoiceSupervisorCapability[]>;

package/dist/supervisorPresence.d.ts

@@ -0,0 +1,49 @@
+export type VoiceSupervisorRole = "viewer" | "coach" | "whisperer" | "owner";
+export type VoiceSupervisorWatcher = {
+    supervisorId: string;
+    sessionId: string;
+    joinedAt: number;
+    lastSeenAt: number;
+    role: VoiceSupervisorRole;
+    displayName?: string;
+};
+export type VoiceSupervisorPresenceEvent = {
+    type: "join";
+    watcher: VoiceSupervisorWatcher;
+} | {
+    type: "leave";
+    supervisorId: string;
+    sessionId: string;
+    at: number;
+} | {
+    type: "role-change";
+    supervisorId: string;
+    sessionId: string;
+    from: VoiceSupervisorRole;
+    to: VoiceSupervisorRole;
+    at: number;
+} | {
+    type: "heartbeat";
+    supervisorId: string;
+    sessionId: string;
+    at: number;
+};
+export type CreateVoiceSupervisorPresenceOptions = {
+    staleAfterMs?: number;
+    now?: () => number;
+};
+export declare const createVoiceSupervisorPresence: (options?: CreateVoiceSupervisorPresenceOptions) => {
+    heartbeat: (sessionId: string, supervisorId: string) => boolean;
+    join: (input: {
+        supervisorId: string;
+        sessionId: string;
+        role?: VoiceSupervisorRole;
+        displayName?: string;
+    }) => VoiceSupervisorWatcher;
+    leave: (sessionId: string, supervisorId: string) => boolean;
+    list: (sessionId: string) => VoiceSupervisorWatcher[];
+    setRole: (sessionId: string, supervisorId: string, role: VoiceSupervisorRole) => boolean;
+    sessionsWatchedBy(supervisorId: string): string[];
+    subscribe(listener: (event: VoiceSupervisorPresenceEvent) => void): () => void;
+};
+export type VoiceSupervisorPresence = ReturnType<typeof createVoiceSupervisorPresence>;

package/dist/transcriptAnnotator.d.ts

@@ -0,0 +1,41 @@
+export type VoiceTranscriptAnnotationKind = "great-recovery" | "missed-objection" | "compliance-concern" | "tone-issue" | "knowledge-gap" | "follow-up-needed" | "custom";
+export type VoiceTranscriptAnnotation = {
+    id: string;
+    sessionId: string;
+    supervisorId: string;
+    kind: VoiceTranscriptAnnotationKind;
+    customLabel?: string;
+    text?: string;
+    turnId?: string;
+    rangeStartMs: number;
+    rangeEndMs?: number;
+    createdAt: number;
+    severity: "info" | "minor" | "major";
+};
+export type CreateVoiceTranscriptAnnotatorOptions = {
+    sessionId: string;
+    generateId?: () => string;
+    now?: () => number;
+};
+export declare const DEFAULT_VOICE_ANNOTATION_KIND_SEVERITY: Record<VoiceTranscriptAnnotationKind, VoiceTranscriptAnnotation["severity"]>;
+export declare const createVoiceTranscriptAnnotator: (options: CreateVoiceTranscriptAnnotatorOptions) => {
+    add: (input: Omit<VoiceTranscriptAnnotation, "id" | "createdAt" | "sessionId" | "severity"> & {
+        severity?: VoiceTranscriptAnnotation["severity"];
+        id?: string;
+    }) => VoiceTranscriptAnnotation;
+    list: (filter?: {
+        kind?: VoiceTranscriptAnnotationKind;
+        supervisorId?: string;
+        severity?: VoiceTranscriptAnnotation["severity"];
+        fromMs?: number;
+        toMs?: number;
+    }) => VoiceTranscriptAnnotation[];
+    remove: (id: string) => boolean;
+    sessionId: string;
+    summarize: () => {
+        byKind: Partial<Record<VoiceTranscriptAnnotationKind, number>>;
+        bySeverity: Record<"info" | "minor" | "major", number>;
+        total: number;
+    };
+};
+export type VoiceTranscriptAnnotator = ReturnType<typeof createVoiceTranscriptAnnotator>;

package/dist/whisperChannel.d.ts

@@ -0,0 +1,50 @@
+export type VoiceWhisperFrame = {
+    sessionId: string;
+    supervisorId: string;
+    pcm: ArrayBuffer | Uint8Array;
+    sampleRate: number;
+    timestamp: number;
+};
+export type VoiceWhisperRoute = "agent-only" | "agent-and-caller" | "drop";
+export type VoiceWhisperEvent = {
+    type: "started";
+    supervisorId: string;
+    at: number;
+} | {
+    type: "stopped";
+    supervisorId: string;
+    at: number;
+} | {
+    type: "frame";
+    frame: VoiceWhisperFrame;
+} | {
+    type: "ducked";
+    supervisorId: string;
+    level: number;
+    at: number;
+};
+export type CreateVoiceWhisperChannelOptions = {
+    sessionId: string;
+    defaultRoute?: VoiceWhisperRoute;
+    duckCallerToLevel?: number;
+    maxConcurrentWhispers?: number;
+    now?: () => number;
+};
+type ActiveWhisper = {
+    supervisorId: string;
+    route: VoiceWhisperRoute;
+    startedAt: number;
+};
+export declare const createVoiceWhisperChannel: (options: CreateVoiceWhisperChannelOptions) => {
+    activeSupervisors: () => string[];
+    isWhispering: (supervisorId: string) => boolean;
+    pushFrame: (frame: VoiceWhisperFrame) => VoiceWhisperRoute;
+    routeFor: (supervisorId: string) => VoiceWhisperRoute | null;
+    sessionId: string;
+    setRoute(supervisorId: string, route: VoiceWhisperRoute): boolean;
+    start: (supervisorId: string, route?: VoiceWhisperRoute) => ActiveWhisper | undefined;
+    stop: (supervisorId: string) => boolean;
+    subscribe(listener: (event: VoiceWhisperEvent) => void): () => void;
+};
+export type VoiceWhisperChannel = ReturnType<typeof createVoiceWhisperChannel>;
+export {};

package/package.json

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