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

package/dist/index.js

@@ -10,6 +10,19 @@ var __name = (target, name) => {
   });
   return target;
 };
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
 var __typeError = (msg) => {
   throw TypeError(msg);
@@ -70,6 +83,115 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
 };
 var __require = import.meta.require;
 
+// src/calendarSlots.ts
+var exports_calendarSlots = {};
+__export(exports_calendarSlots, {
+  summarizeVoiceCalendarSlot: () => summarizeVoiceCalendarSlot,
+  generateVoiceCalendarSlots: () => generateVoiceCalendarSlots
+});
+var parseHHMM = (value) => {
+  const match = /^([0-9]{1,2}):([0-9]{2})$/u.exec(value);
+  if (!match)
+    throw new Error(`Invalid time string (expected HH:MM): ${value}`);
+  return Number(match[1]) * 60 + Number(match[2]);
+}, partsAt = (ms, timezone) => {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    day: "2-digit",
+    hour: "2-digit",
+    hour12: false,
+    minute: "2-digit",
+    month: "2-digit",
+    timeZone: timezone,
+    weekday: "short",
+    year: "numeric"
+  });
+  const map = {};
+  for (const part of formatter.formatToParts(new Date(ms))) {
+    if (part.type !== "literal")
+      map[part.type] = part.value;
+  }
+  const weekdayMap = {
+    Fri: 5,
+    Mon: 1,
+    Sat: 6,
+    Sun: 0,
+    Thu: 4,
+    Tue: 2,
+    Wed: 3
+  };
+  const hourValue = map.hour === "24" ? "00" : map.hour ?? "0";
+  return {
+    date: `${map.year}-${map.month}-${map.day}`,
+    minutes: Number(hourValue) * 60 + Number(map.minute ?? "0"),
+    weekday: weekdayMap[map.weekday ?? ""] ?? 0
+  };
+}, overlaps = (aStart, aEnd, bStart, bEnd) => aStart < bEnd && bStart < aEnd, generateVoiceCalendarSlots = (input) => {
+  if (input.durationMinutes <= 0) {
+    throw new Error("durationMinutes must be positive");
+  }
+  if (input.toMs <= input.fromMs)
+    return [];
+  const granularity = input.granularityMinutes ?? 15;
+  const buffer = input.bufferMinutes ?? 0;
+  const max = input.maxSlots ?? Infinity;
+  const hoursByDay = new Map;
+  for (const block of input.businessHours) {
+    const list = hoursByDay.get(block.weekday) ?? [];
+    list.push(block);
+    hoursByDay.set(block.weekday, list);
+  }
+  const blackoutDates = new Set((input.blackoutDates ?? []).map((b) => b.date));
+  const slots = [];
+  const stepMs = granularity * 60000;
+  const durationMs = input.durationMinutes * 60000;
+  const bufferMs = buffer * 60000;
+  let cursor = input.fromMs;
+  while (cursor + durationMs <= input.toMs && slots.length < max) {
+    const slotEnd = cursor + durationMs;
+    const startParts = partsAt(cursor, input.timezone);
+    if (blackoutDates.has(startParts.date)) {
+      cursor += stepMs;
+      continue;
+    }
+    const dayHours = hoursByDay.get(startParts.weekday);
+    if (!dayHours || dayHours.length === 0) {
+      cursor += stepMs;
+      continue;
+    }
+    const endParts = partsAt(slotEnd - 1, input.timezone);
+    const fitsHours = dayHours.some((block) => {
+      const startMin = parseHHMM(block.start);
+      const endMin = parseHHMM(block.end);
+      return startParts.minutes >= startMin && endParts.minutes < endMin && startParts.date === endParts.date;
+    });
+    if (!fitsHours) {
+      cursor += stepMs;
+      continue;
+    }
+    const collides = (input.bookedRanges ?? []).some((booked) => overlaps(cursor - bufferMs, slotEnd + bufferMs, booked.startMs, booked.endMs));
+    if (!collides) {
+      slots.push({
+        durationMinutes: input.durationMinutes,
+        endMs: slotEnd,
+        startMs: cursor
+      });
+    }
+    cursor += stepMs;
+  }
+  return slots;
+}, summarizeVoiceCalendarSlot = (slot, options = {}) => {
+  const formatter = new Intl.DateTimeFormat(options.locale ?? "en-US", {
+    day: "numeric",
+    hour: "numeric",
+    hour12: true,
+    minute: "2-digit",
+    month: "long",
+    timeZone: options.timezone,
+    weekday: "long"
+  });
+  return formatter.format(new Date(slot.startMs));
+};
+
 // src/audioConditioning.ts
 var DEFAULT_TARGET_LEVEL = 0.08;
 var DEFAULT_MAX_GAIN = 3;
@@ -49171,6 +49293,799 @@ 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;
+// src/calendarAdapter.ts
+var createVoiceInMemoryCalendarAdapter = (options) => {
+  const now = options.now ?? (() => Date.now());
+  const generateId = options.generateId ?? (() => `appt_${Math.random().toString(36).slice(2, 10)}`);
+  const appointments = new Map;
+  for (const range of options.bookedRanges ?? []) {
+    const id = generateId();
+    appointments.set(id, {
+      calendarId: "default",
+      createdAt: now(),
+      endMs: range.endMs,
+      id,
+      startMs: range.startMs,
+      status: "scheduled"
+    });
+  }
+  const liveRanges = () => Array.from(appointments.values()).filter((a) => a.status === "scheduled").map((a) => ({ endMs: a.endMs, startMs: a.startMs }));
+  return {
+    async book(input) {
+      const clash = liveRanges().some((r) => input.startMs < r.endMs && r.startMs < input.endMs);
+      if (clash)
+        throw new Error("Slot is already booked");
+      const id = generateId();
+      const appointment = {
+        calendarId: input.calendarId,
+        createdAt: now(),
+        endMs: input.endMs,
+        id,
+        startMs: input.startMs,
+        status: "scheduled",
+        ...input.title !== undefined ? { title: input.title } : {},
+        ...input.attendees !== undefined ? { attendees: input.attendees } : {},
+        ...input.notes !== undefined ? { notes: input.notes } : {},
+        ...input.metadata !== undefined ? { metadata: input.metadata } : {}
+      };
+      appointments.set(id, appointment);
+      return appointment;
+    },
+    async cancel(id) {
+      const existing = appointments.get(id);
+      if (!existing)
+        return null;
+      const cancelled = {
+        ...existing,
+        status: "cancelled"
+      };
+      appointments.set(id, cancelled);
+      return cancelled;
+    },
+    async get(id) {
+      return appointments.get(id) ?? null;
+    },
+    async listAvailability(query) {
+      const { generateVoiceCalendarSlots: generateVoiceCalendarSlots2 } = await Promise.resolve().then(() => exports_calendarSlots);
+      return generateVoiceCalendarSlots2({
+        bookedRanges: liveRanges(),
+        ...query.bufferMinutes !== undefined ? { bufferMinutes: query.bufferMinutes } : {},
+        businessHours: options.businessHours,
+        durationMinutes: query.durationMinutes,
+        fromMs: query.fromMs,
+        ...query.granularityMinutes !== undefined ? { granularityMinutes: query.granularityMinutes } : {},
+        ...query.maxSlots !== undefined ? { maxSlots: query.maxSlots } : {},
+        ...options.timezone !== undefined ? { timezone: options.timezone } : {},
+        toMs: query.toMs
+      });
+    },
+    providerName: "in-memory",
+    async reschedule(id, nextStartMs, nextEndMs) {
+      const existing = appointments.get(id);
+      if (!existing)
+        return null;
+      const others = liveRanges().filter((r) => r.startMs !== existing.startMs || r.endMs !== existing.endMs);
+      const clash = others.some((r) => nextStartMs < r.endMs && r.startMs < nextEndMs);
+      if (clash)
+        throw new Error("Cannot reschedule onto a booked slot");
+      const updated = {
+        ...existing,
+        endMs: nextEndMs,
+        startMs: nextStartMs
+      };
+      appointments.set(id, updated);
+      return updated;
+    }
+  };
+};
+// src/bookingFlow.ts
+var createVoiceBookingFlow = (options) => {
+  const initial = {
+    proposedSlots: [],
+    step: options.initialStep ?? (options.services ? "ask-service" : "ask-date")
+  };
+  let state = initial;
+  const listeners = new Set;
+  const setState = (next) => {
+    state = { ...state, ...next };
+    for (const listener of listeners)
+      listener(state);
+  };
+  const chooseService = (serviceId) => {
+    const services = options.services ?? [];
+    const service = services.find((s) => s.id === serviceId);
+    if (!service) {
+      setState({ error: `Unknown service: ${serviceId}`, step: "failed" });
+      return;
+    }
+    setState({
+      serviceDurationMinutes: service.durationMinutes,
+      serviceId: service.id,
+      step: "ask-date"
+    });
+  };
+  const proposeSlotsForDay = async (input) => {
+    const duration = state.serviceDurationMinutes ?? options.defaultDurationMinutes ?? 30;
+    const slots = await options.adapter.listAvailability({
+      calendarId: options.calendarId,
+      durationMinutes: duration,
+      fromMs: input.fromMs,
+      ...options.maxSlotsPerDay !== undefined ? { maxSlots: options.maxSlotsPerDay } : {},
+      toMs: input.toMs
+    });
+    setState({ proposedSlots: slots, step: slots.length > 0 ? "ask-time" : "ask-date" });
+    return slots;
+  };
+  const chooseSlot = (slotIndex) => {
+    const slot = state.proposedSlots[slotIndex];
+    if (!slot) {
+      setState({ error: "Invalid slot selection", step: "failed" });
+      return;
+    }
+    setState({ selectedSlot: slot, step: "confirm" });
+  };
+  const confirm = async (input = {}) => {
+    if (state.step !== "confirm" || !state.selectedSlot) {
+      setState({ error: "Nothing to confirm", step: "failed" });
+      return null;
+    }
+    setState({ step: "booking" });
+    try {
+      const appt = await options.adapter.book({
+        calendarId: options.calendarId,
+        endMs: state.selectedSlot.endMs,
+        startMs: state.selectedSlot.startMs,
+        ...input.attendees !== undefined ? { attendees: input.attendees } : {},
+        ...input.title !== undefined ? { title: input.title } : {},
+        ...input.notes !== undefined ? { notes: input.notes } : {}
+      });
+      setState({ appointment: appt, step: "booked" });
+      return appt;
+    } catch (error) {
+      setState({
+        error: error instanceof Error ? error.message : String(error),
+        step: "failed"
+      });
+      return null;
+    }
+  };
+  const reset = () => {
+    state = {
+      proposedSlots: [],
+      step: options.initialStep ?? (options.services ? "ask-service" : "ask-date")
+    };
+    for (const listener of listeners)
+      listener(state);
+  };
+  return {
+    chooseService,
+    chooseSlot,
+    confirm,
+    getState: () => state,
+    proposeSlotsForDay,
+    reset,
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(state);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+// src/noShowPredictor.ts
+var clamp = (value, min = 0, max = 1) => Math.max(min, Math.min(max, value));
+var scoreVoiceNoShowRisk = (input) => {
+  const now = input.now ?? (() => Date.now());
+  const leadHours = (input.appointmentStartMs - input.bookedAtMs) / 3600000;
+  const startDate = new Date(input.appointmentStartMs);
+  const weekday = startDate.getUTCDay();
+  const hour = startDate.getUTCHours();
+  const history = input.history ?? [];
+  const past = history.filter((r) => r.scheduledStartMs < input.appointmentStartMs);
+  const priorNoShows = past.filter((r) => r.outcome === "no-show").length;
+  const priorKept = past.filter((r) => r.outcome === "kept").length;
+  let score = 0.15;
+  const drivers = [];
+  if (leadHours > 72) {
+    score += 0.1;
+    drivers.push({ kind: "lead-time-hours", value: leadHours });
+  } else if (leadHours < 12) {
+    score -= 0.05;
+    drivers.push({ kind: "lead-time-hours", value: leadHours });
+  }
+  if (weekday === 1) {
+    score += 0.04;
+    drivers.push({ kind: "weekday", value: weekday });
+  }
+  if (weekday === 5) {
+    score += 0.03;
+    drivers.push({ kind: "weekday", value: weekday });
+  }
+  if (hour < 9 || hour >= 17) {
+    score += 0.04;
+    drivers.push({ kind: "hour-of-day", value: hour });
+  }
+  if (priorNoShows > 0) {
+    const delta = Math.min(0.5, priorNoShows * 0.2);
+    score += delta;
+    drivers.push({ kind: "prior-no-show-count", value: priorNoShows });
+  }
+  if (priorKept > 2 && priorNoShows === 0) {
+    score -= 0.08;
+    drivers.push({ kind: "prior-kept-count", value: priorKept });
+  }
+  if (input.reminderConfirmed === true) {
+    score -= 0.15;
+    drivers.push({ kind: "reminder-confirmed", value: true });
+  } else if (input.reminderConfirmed === false) {
+    score += 0.1;
+    drivers.push({ kind: "reminder-confirmed", value: false });
+  }
+  if (input.callbackDistanceHours !== undefined && input.callbackDistanceHours > 24) {
+    score += 0.06;
+    drivers.push({
+      kind: "callback-distance-hours",
+      value: input.callbackDistanceHours
+    });
+  }
+  if (input.weatherDisruption) {
+    score += 0.18;
+    drivers.push({ kind: "weather-disruption", value: true });
+  }
+  const finalScore = clamp(score);
+  const band = finalScore >= 0.55 ? "high" : finalScore >= 0.3 ? "moderate" : "low";
+  return { band, drivers, score: finalScore };
+};
+var summarizeVoiceNoShowVerdict = (verdict) => {
+  const pct = Math.round(verdict.score * 100);
+  const top = verdict.drivers.slice(0, 2).map((d) => d.kind).join(", ");
+  return `${verdict.band} risk (${pct}%)${top ? ` \u2014 driven by ${top}` : ""}`;
+};
+// src/reminderScheduler.ts
+var DEFAULT_VOICE_REMINDER_TRIGGERS = [
+  {
+    channel: "sms",
+    id: "remind-24h",
+    offsetMinutesBeforeStart: 24 * 60
+  },
+  {
+    channel: "sms",
+    id: "remind-2h",
+    offsetMinutesBeforeStart: 120
+  },
+  {
+    channel: "call",
+    id: "remind-call-30m",
+    offsetMinutesBeforeStart: 30,
+    retryOnFailure: true
+  }
+];
+var createVoiceReminderScheduler = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  const generateId = options.generateJobId ?? (() => `rem_${Math.random().toString(36).slice(2, 10)}`);
+  const defaultTriggers = options.defaultTriggers ?? DEFAULT_VOICE_REMINDER_TRIGGERS;
+  const maxAttempts = options.maxAttempts ?? 2;
+  const jobs = new Map;
+  const listeners = new Set;
+  const broadcast = (job) => {
+    for (const listener of listeners)
+      listener(job);
+  };
+  const schedule = (input) => {
+    const triggers = input.triggers.length > 0 ? input.triggers : defaultTriggers;
+    const at = now();
+    const created = [];
+    for (const trigger of triggers) {
+      const fireAt = input.appointmentStartMs - trigger.offsetMinutesBeforeStart * 60000;
+      if (fireAt <= at)
+        continue;
+      const job = {
+        appointmentId: input.appointmentId,
+        attempts: 0,
+        channel: trigger.channel,
+        id: generateId(),
+        scheduledAtMs: fireAt,
+        status: "pending",
+        triggerId: trigger.id,
+        ...input.metadata !== undefined ? { metadata: input.metadata } : {}
+      };
+      jobs.set(job.id, job);
+      created.push(job);
+      broadcast(job);
+    }
+    return created;
+  };
+  const due = (at = now()) => Array.from(jobs.values()).filter((j) => j.status === "pending" && j.scheduledAtMs <= at);
+  const markInFlight = (jobId) => {
+    const job = jobs.get(jobId);
+    if (!job || job.status !== "pending")
+      return false;
+    job.status = "in-flight";
+    job.attempts += 1;
+    broadcast(job);
+    return true;
+  };
+  const markSent = (jobId) => {
+    const job = jobs.get(jobId);
+    if (!job)
+      return false;
+    job.status = "sent";
+    broadcast(job);
+    return true;
+  };
+  const markFailed = (jobId, error) => {
+    const job = jobs.get(jobId);
+    if (!job)
+      return false;
+    job.lastError = error;
+    if (job.attempts < maxAttempts) {
+      job.status = "pending";
+      job.scheduledAtMs = now() + 5 * 60000;
+    } else {
+      job.status = "failed";
+    }
+    broadcast(job);
+    return true;
+  };
+  const cancelForAppointment = (appointmentId) => {
+    let count = 0;
+    for (const job of jobs.values()) {
+      if (job.appointmentId === appointmentId && (job.status === "pending" || job.status === "in-flight")) {
+        job.status = "cancelled";
+        broadcast(job);
+        count += 1;
+      }
+    }
+    return count;
+  };
+  return {
+    cancelForAppointment,
+    due,
+    list: (appointmentId) => Array.from(jobs.values()).filter((j) => !appointmentId || j.appointmentId === appointmentId),
+    markFailed,
+    markInFlight,
+    markSent,
+    schedule,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
 export {
   writeVoiceProofPack,
   writeVoiceMediaPipelineArtifacts,
@@ -49218,6 +50133,7 @@ export {
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
   summarizeVoiceOpsStatus,
+  summarizeVoiceNoShowVerdict,
   summarizeVoiceMediaPipelineReport,
   summarizeVoiceLiveLatency,
   summarizeVoiceIntegrationEvents,
@@ -49226,6 +50142,7 @@ export {
   summarizeVoiceCampaigns,
   summarizeVoiceCampaignDispositions,
   summarizeVoiceCallerTranscript,
+  summarizeVoiceCalendarSlot,
   summarizeVoiceBrowserMedia,
   summarizeVoiceBargeIn,
   summarizeVoiceAuditTrail,
@@ -49239,6 +50156,7 @@ export {
   shouldRetryCampaignAttempt,
   shapeTelephonyAssistantText,
   selectVoiceTraceEventsForPrune,
+  scoreVoiceNoShowRisk,
   saveVoiceIncidentBundleArtifact,
   runVoiceToolContractSuite,
   runVoiceToolContract,
@@ -49446,6 +50364,7 @@ export {
   getLatestVoiceTelephonyMediaReport,
   getLatestVoiceBrowserMediaReport,
   getDefaultVoiceTelephonyBenchmarkScenarios,
+  generateVoiceCalendarSlots,
   fromVapiAssistantConfig,
   formatVoiceProofTrendAge,
   formatVoiceCallPlayerTimestamp,
@@ -49521,6 +50440,7 @@ export {
   createVoiceWorkflowContractPreset,
   createVoiceWorkflowContractHandler,
   createVoiceWorkflowContract,
+  createVoiceWhisperChannel,
   createVoiceWebhookHandoffAdapter,
   createVoiceWebhookFanout,
   createVoiceWebhookDeliveryWorkerLoop,
@@ -49538,6 +50458,7 @@ export {
   createVoiceTurnLatencyHTMLHandler,
   createVoiceTransferCallTool,
   createVoiceTranscriptRedactor,
+  createVoiceTranscriptAnnotator,
   createVoiceTraceTimelineRoutes,
   createVoiceTraceSinkStore,
   createVoiceTraceSinkDeliveryWorkerLoop,
@@ -49572,6 +50493,8 @@ export {
   createVoiceTaskSLABreachedEvent,
   createVoiceTaskCreatedEvent,
   createVoiceTTSProviderRouter,
+  createVoiceSupervisorPresence,
+  createVoiceSupervisorPermissions,
   createVoiceSloThresholdProfile,
   createVoiceSloReadinessThresholdRoutes,
   createVoiceSloReadinessThresholdOptions,
@@ -49618,6 +50541,7 @@ export {
   createVoiceRetentionScheduler,
   createVoiceResilienceRoutes,
   createVoiceReplayTimelineHTMXRoute,
+  createVoiceReminderScheduler,
   createVoiceRedisTelnyxWebhookEventStore,
   createVoiceRedisTelephonyWebhookIdempotencyStore,
   createVoiceRedisTaskLeaseCoordinator,
@@ -49744,6 +50668,7 @@ export {
   createVoiceLiveOpsController,
   createVoiceLiveMonitorRoutes,
   createVoiceLiveLatencyRoutes,
+  createVoiceLiveCoach,
   createVoiceLiveCallViewerHTMXRoute,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
@@ -49757,6 +50682,7 @@ export {
   createVoiceIncidentBundleRoutes,
   createVoiceInMemoryRealCallProfileRecoveryJobStore,
   createVoiceInMemoryMonitorRegistry,
+  createVoiceInMemoryCalendarAdapter,
   createVoiceIVRSession,
   createVoiceHubSpotTaskUpdateSink,
   createVoiceHubSpotTaskSyncSinks,
@@ -49831,6 +50757,7 @@ export {
   createVoiceCRMActivitySink,
   createVoiceBrowserMediaRoutes,
   createVoiceBrowserCallProfileRoutes,
+  createVoiceBookingFlow,
   createVoiceBearerAuthVerifier,
   createVoiceBargeInRoutes,
   createVoiceBackchannelDriver,
@@ -50053,10 +50980,12 @@ 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,
   TURN_PROFILE_DEFAULTS,
+  DEFAULT_VOICE_REMINDER_TRIGGERS,
   DEFAULT_VOICE_REDACTION_PATTERNS,
   DEFAULT_VOICE_PROOF_TREND_PROFILE_DEFINITIONS,
   DEFAULT_VOICE_PROOF_TRENDS_MAX_AGE_MS,
@@ -50065,5 +50994,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
 };