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

package/dist/callDisposition.d.ts

@@ -0,0 +1,38 @@
+export type VoiceCallDispositionTaxonomy = "sales" | "support" | "collections" | "survey" | "custom";
+export type VoiceCallDispositionDefinition = {
+    code: string;
+    label: string;
+    outcome: "positive" | "neutral" | "negative" | "no-contact";
+    retryable: boolean;
+    taxonomy?: VoiceCallDispositionTaxonomy;
+};
+export declare const DEFAULT_VOICE_CALL_DISPOSITIONS: VoiceCallDispositionDefinition[];
+export type VoiceCallDispositionTag = {
+    sessionId: string;
+    code: string;
+    taggedAt: number;
+    note?: string;
+};
+export type CreateVoiceCallDispositionTaggerOptions = {
+    taxonomy?: VoiceCallDispositionDefinition[];
+    allowMultiple?: boolean;
+    now?: () => number;
+};
+export declare const createVoiceCallDispositionTagger: (options?: CreateVoiceCallDispositionTaggerOptions) => {
+    definitionFor: (code: string) => VoiceCallDispositionDefinition | null;
+    definitions: VoiceCallDispositionDefinition[];
+    listAll: () => VoiceCallDispositionTag[];
+    listForSession: (sessionId: string) => VoiceCallDispositionTag[];
+    summarize: () => {
+        byCode: {
+            [k: string]: number;
+        };
+        byOutcome: Record<"negative" | "neutral" | "positive" | "no-contact", number>;
+        retryablePct: number;
+        totalSessions: number;
+        totalTagged: number;
+    };
+    tag: (sessionId: string, code: string, note?: string) => VoiceCallDispositionTag;
+    untag: (sessionId: string, code?: string) => number;
+};
+export type VoiceCallDispositionTagger = ReturnType<typeof createVoiceCallDispositionTagger>;

package/dist/callingWindow.d.ts

@@ -0,0 +1,26 @@
+export type VoiceCallingDayKey = "sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday";
+export type VoiceCallingTimeRange = {
+    start: string;
+    end: string;
+};
+export type VoiceCallingWindowOptions = {
+    timezone?: string;
+    allowedDays?: VoiceCallingDayKey[];
+    allowedHours?: VoiceCallingTimeRange | VoiceCallingTimeRange[];
+    blockedDates?: string[];
+    perDayHours?: Partial<Record<VoiceCallingDayKey, VoiceCallingTimeRange[]>>;
+    now?: () => Date;
+};
+export type VoiceCallingWindowVerdict = {
+    allowed: boolean;
+    reason?: "outside-hours" | "blocked-date" | "outside-day";
+    nextWindowAt?: number;
+};
+export declare const createVoiceCallingWindow: (options?: VoiceCallingWindowOptions) => {
+    allowedDays: VoiceCallingDayKey[];
+    canCallNow(at?: Date): VoiceCallingWindowVerdict;
+    nextWindowOpensAt(at?: Date): number;
+    timezone: string | undefined;
+};
+export type VoiceCallingWindow = ReturnType<typeof createVoiceCallingWindow>;
+export declare const VOICE_TCPA_DEFAULT_WINDOW: VoiceCallingWindowOptions;

package/dist/campaignTemplate.d.ts

@@ -0,0 +1,16 @@
+export type VoiceCampaignTemplateValue = string | number | boolean | null | undefined;
+export type VoiceCampaignTemplateScope = Record<string, VoiceCampaignTemplateValue | Record<string, VoiceCampaignTemplateValue>>;
+export type VoiceCampaignTemplateFilter = (value: VoiceCampaignTemplateValue, ...args: string[]) => VoiceCampaignTemplateValue;
+export type VoiceCampaignTemplateResolveResult = {
+    output: string;
+    missingVariables: string[];
+};
+export type ResolveVoiceCampaignTemplateOptions = {
+    scope: VoiceCampaignTemplateScope;
+    filters?: Record<string, VoiceCampaignTemplateFilter>;
+    fallback?: string;
+    strict?: boolean;
+};
+export declare const DEFAULT_VOICE_CAMPAIGN_TEMPLATE_FILTERS: Record<string, VoiceCampaignTemplateFilter>;
+export declare const resolveVoiceCampaignTemplate: (template: string, options: ResolveVoiceCampaignTemplateOptions) => VoiceCampaignTemplateResolveResult;
+export declare const collectVoiceCampaignTemplateVariables: (template: string) => string[];

package/dist/dncRegistry.d.ts

@@ -0,0 +1,38 @@
+export type VoiceDNCSource = "internal" | "regulatory" | "imported";
+export type VoiceDNCEntry = {
+    phoneNumber: string;
+    source: VoiceDNCSource;
+    reason?: string;
+    addedAt: number;
+    expiresAt?: number;
+};
+export type VoiceDNCLookupVerdict = {
+    blocked: boolean;
+    entry: VoiceDNCEntry | null;
+    matchedFromExternal?: boolean;
+};
+export type VoiceDNCExternalLookup = (phoneNumber: string) => Promise<VoiceDNCEntry | null> | VoiceDNCEntry | null;
+export type CreateVoiceDNCRegistryOptions = {
+    entries?: VoiceDNCEntry[];
+    externalLookup?: VoiceDNCExternalLookup;
+    now?: () => number;
+};
+export declare const createVoiceDNCRegistry: (options?: CreateVoiceDNCRegistryOptions) => {
+    block: (phoneNumber: string, options?: {
+        source?: VoiceDNCSource;
+        reason?: string;
+        expiresAt?: number;
+    }) => VoiceDNCEntry;
+    check(phoneNumber: string): Promise<VoiceDNCLookupVerdict>;
+    checkSync(phoneNumber: string): VoiceDNCLookupVerdict;
+    has(phoneNumber: string): boolean;
+    snapshot(): VoiceDNCEntry[];
+    unblock: (phoneNumber: string) => boolean;
+};
+export type VoiceDNCRegistry = ReturnType<typeof createVoiceDNCRegistry>;
+export declare const importVoiceDNCFromCSV: (csv: string, options?: {
+    phoneColumn?: string;
+    reasonColumn?: string;
+    source?: VoiceDNCSource;
+    now?: () => number;
+}) => VoiceDNCEntry[];

package/dist/index.d.ts

@@ -301,4 +301,14 @@ export { createVoicePostCallSurvey, DEFAULT_VOICE_POST_CALL_SURVEY_QUESTIONS, su
 export type { VoicePostCallSurvey, VoicePostCallSurveyAnswer, VoicePostCallSurveyQuestion, VoicePostCallSurveyResponse, CreateVoicePostCallSurveyOptions, } from "./postCallSurvey";
 export { collectVoiceDTMFInput, validateVoiceDTMFLuhn, VOICE_DTMF_DIGITS, } from "./dtmfCollector";
 export type { VoiceDTMFCollector, VoiceDTMFCollectorState, VoiceDTMFDigit, CreateVoiceDTMFCollectorOptions, } from "./dtmfCollector";
+export { createVoiceDNCRegistry, importVoiceDNCFromCSV, } from "./dncRegistry";
+export type { VoiceDNCEntry, VoiceDNCExternalLookup, VoiceDNCLookupVerdict, VoiceDNCRegistry, VoiceDNCSource, CreateVoiceDNCRegistryOptions, } from "./dncRegistry";
+export { createVoiceCallingWindow, VOICE_TCPA_DEFAULT_WINDOW, } from "./callingWindow";
+export type { VoiceCallingDayKey, VoiceCallingTimeRange, VoiceCallingWindow, VoiceCallingWindowOptions, VoiceCallingWindowVerdict, } from "./callingWindow";
+export { createVoiceCallDispositionTagger, DEFAULT_VOICE_CALL_DISPOSITIONS, } from "./callDisposition";
+export type { VoiceCallDispositionDefinition, VoiceCallDispositionTag, VoiceCallDispositionTagger, VoiceCallDispositionTaxonomy, CreateVoiceCallDispositionTaggerOptions, } from "./callDisposition";
+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 * from "./types";

package/dist/index.js

@@ -48561,6 +48561,616 @@ var validateVoiceDTMFLuhn = (digits) => {
   }
   return sum % 10 === 0;
 };
+// src/dncRegistry.ts
+var normalizePhone = (phone) => {
+  const trimmed = phone.trim();
+  if (!trimmed)
+    throw new Error("Phone number is required");
+  const digitsOnly = trimmed.replace(/[\s().-]/gu, "");
+  if (!/^\+?\d+$/u.test(digitsOnly)) {
+    throw new Error(`Invalid phone number: ${phone}`);
+  }
+  return digitsOnly.startsWith("+") ? digitsOnly : `+${digitsOnly}`;
+};
+var createVoiceDNCRegistry = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  const store = new Map;
+  for (const entry of options.entries ?? []) {
+    store.set(normalizePhone(entry.phoneNumber), {
+      ...entry,
+      phoneNumber: normalizePhone(entry.phoneNumber)
+    });
+  }
+  const isExpired = (entry, at) => entry.expiresAt !== undefined && entry.expiresAt <= at;
+  const block = (phoneNumber, options2 = {}) => {
+    const normalized = normalizePhone(phoneNumber);
+    const entry = {
+      addedAt: now(),
+      phoneNumber: normalized,
+      source: options2.source ?? "internal",
+      ...options2.reason !== undefined ? { reason: options2.reason } : {},
+      ...options2.expiresAt !== undefined ? { expiresAt: options2.expiresAt } : {}
+    };
+    store.set(normalized, entry);
+    return entry;
+  };
+  const unblock = (phoneNumber) => {
+    const normalized = normalizePhone(phoneNumber);
+    return store.delete(normalized);
+  };
+  const localLookup = (phoneNumber) => {
+    const normalized = normalizePhone(phoneNumber);
+    const entry = store.get(normalized);
+    if (!entry)
+      return null;
+    if (isExpired(entry, now())) {
+      store.delete(normalized);
+      return null;
+    }
+    return entry;
+  };
+  return {
+    block,
+    async check(phoneNumber) {
+      const local = localLookup(phoneNumber);
+      if (local)
+        return { blocked: true, entry: local };
+      if (!options.externalLookup) {
+        return { blocked: false, entry: null };
+      }
+      const remote = await options.externalLookup(normalizePhone(phoneNumber));
+      if (!remote)
+        return { blocked: false, entry: null };
+      return { blocked: true, entry: remote, matchedFromExternal: true };
+    },
+    checkSync(phoneNumber) {
+      const local = localLookup(phoneNumber);
+      return local ? { blocked: true, entry: local } : { blocked: false, entry: null };
+    },
+    has(phoneNumber) {
+      return localLookup(phoneNumber) !== null;
+    },
+    snapshot() {
+      const at = now();
+      const live = [];
+      for (const entry of store.values()) {
+        if (!isExpired(entry, at))
+          live.push(entry);
+      }
+      return live;
+    },
+    unblock
+  };
+};
+var importVoiceDNCFromCSV = (csv, options = {}) => {
+  const lines = csv.split(/\r?\n/u).filter((line) => line.trim().length > 0);
+  if (lines.length === 0)
+    return [];
+  const header = (lines[0] ?? "").split(",").map((h) => h.trim().toLowerCase());
+  const phoneCol = options.phoneColumn?.toLowerCase() ?? "phone";
+  const reasonCol = options.reasonColumn?.toLowerCase() ?? "reason";
+  const phoneIdx = header.indexOf(phoneCol);
+  const reasonIdx = header.indexOf(reasonCol);
+  if (phoneIdx === -1) {
+    throw new Error(`Phone column not found in CSV header: ${phoneCol}`);
+  }
+  const now = options.now ?? (() => Date.now());
+  const at = now();
+  const entries = [];
+  for (let i = 1;i < lines.length; i++) {
+    const row = (lines[i] ?? "").split(",").map((cell) => cell.trim());
+    const phone = row[phoneIdx];
+    if (!phone)
+      continue;
+    entries.push({
+      addedAt: at,
+      phoneNumber: normalizePhone(phone),
+      source: options.source ?? "imported",
+      ...reasonIdx >= 0 && row[reasonIdx] ? { reason: row[reasonIdx] } : {}
+    });
+  }
+  return entries;
+};
+// src/callingWindow.ts
+var DAY_INDEX = {
+  friday: 5,
+  monday: 1,
+  saturday: 6,
+  sunday: 0,
+  thursday: 4,
+  tuesday: 2,
+  wednesday: 3
+};
+var DAY_KEYS = [
+  "sunday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday"
+];
+var parseTime = (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}`);
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  if (hour < 0 || hour > 23) {
+    throw new RangeError(`Hour out of range: ${value}`);
+  }
+  if (minute < 0 || minute > 59) {
+    throw new RangeError(`Minute out of range: ${value}`);
+  }
+  return { hour, minute };
+};
+var minutesOf = (range) => {
+  const start = parseTime(range.start);
+  const end = parseTime(range.end);
+  return {
+    end: end.hour * 60 + end.minute,
+    start: start.hour * 60 + start.minute
+  };
+};
+var parts = (date, 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(date)) {
+    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 {
+    day: map.day ?? "00",
+    minutes: Number(hourValue) * 60 + Number(map.minute ?? "0"),
+    month: map.month ?? "00",
+    weekday: weekdayMap[map.weekday ?? ""] ?? 0,
+    year: map.year ?? "0000"
+  };
+};
+var createVoiceCallingWindow = (options = {}) => {
+  const now = options.now ?? (() => new Date);
+  const allowedDayIndexes = new Set((options.allowedDays ?? [
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday"
+  ]).map((d) => DAY_INDEX[d]));
+  const blockedDates = new Set(options.blockedDates ?? []);
+  const baseRanges = !options.allowedHours ? [{ end: "21:00", start: "08:00" }] : Array.isArray(options.allowedHours) ? options.allowedHours : [options.allowedHours];
+  const baseMinutes = baseRanges.map(minutesOf);
+  const perDayMinutes = new Map;
+  for (const [key, ranges] of Object.entries(options.perDayHours ?? {})) {
+    if (!ranges)
+      continue;
+    perDayMinutes.set(DAY_INDEX[key], ranges.map(minutesOf));
+  }
+  const rangesFor = (weekday) => perDayMinutes.get(weekday) ?? baseMinutes;
+  const isAllowedAt = (date) => {
+    const p = parts(date, options.timezone);
+    const isoDate = `${p.year}-${p.month}-${p.day}`;
+    if (blockedDates.has(isoDate)) {
+      return { allowed: false, reason: "blocked-date" };
+    }
+    if (!allowedDayIndexes.has(p.weekday)) {
+      return { allowed: false, reason: "outside-day" };
+    }
+    const ranges = rangesFor(p.weekday);
+    for (const range of ranges) {
+      if (p.minutes >= range.start && p.minutes < range.end) {
+        return { allowed: true };
+      }
+    }
+    return { allowed: false, reason: "outside-hours" };
+  };
+  const findNextOpening = (from) => {
+    const cursor = new Date(from.getTime());
+    for (let step = 0;step < 14 * 24 * 60; step++) {
+      const verdict = isAllowedAt(cursor);
+      if (verdict.allowed)
+        return cursor.getTime();
+      cursor.setTime(cursor.getTime() + 60000);
+    }
+    return cursor.getTime();
+  };
+  return {
+    allowedDays: [...allowedDayIndexes].map((idx) => DAY_KEYS[idx]),
+    canCallNow(at) {
+      const date = at ?? now();
+      const verdict = isAllowedAt(date);
+      if (verdict.allowed)
+        return verdict;
+      return { ...verdict, nextWindowAt: findNextOpening(date) };
+    },
+    nextWindowOpensAt(at) {
+      const date = at ?? now();
+      const verdict = isAllowedAt(date);
+      if (verdict.allowed)
+        return date.getTime();
+      return findNextOpening(date);
+    },
+    timezone: options.timezone
+  };
+};
+var VOICE_TCPA_DEFAULT_WINDOW = {
+  allowedDays: ["monday", "tuesday", "wednesday", "thursday", "friday"],
+  allowedHours: { end: "21:00", start: "08:00" }
+};
+// src/callDisposition.ts
+var DEFAULT_VOICE_CALL_DISPOSITIONS = [
+  {
+    code: "sale",
+    label: "Sale closed",
+    outcome: "positive",
+    retryable: false,
+    taxonomy: "sales"
+  },
+  {
+    code: "qualified-lead",
+    label: "Qualified lead",
+    outcome: "positive",
+    retryable: false,
+    taxonomy: "sales"
+  },
+  {
+    code: "callback-requested",
+    label: "Callback requested",
+    outcome: "neutral",
+    retryable: true,
+    taxonomy: "sales"
+  },
+  {
+    code: "not-interested",
+    label: "Not interested",
+    outcome: "negative",
+    retryable: false,
+    taxonomy: "sales"
+  },
+  {
+    code: "do-not-call",
+    label: "Do not call",
+    outcome: "negative",
+    retryable: false,
+    taxonomy: "sales"
+  },
+  {
+    code: "voicemail-left",
+    label: "Voicemail left",
+    outcome: "no-contact",
+    retryable: true,
+    taxonomy: "sales"
+  },
+  {
+    code: "no-answer",
+    label: "No answer",
+    outcome: "no-contact",
+    retryable: true,
+    taxonomy: "sales"
+  },
+  {
+    code: "busy",
+    label: "Line busy",
+    outcome: "no-contact",
+    retryable: true,
+    taxonomy: "sales"
+  },
+  {
+    code: "wrong-number",
+    label: "Wrong number",
+    outcome: "negative",
+    retryable: false,
+    taxonomy: "sales"
+  },
+  {
+    code: "resolved",
+    label: "Issue resolved",
+    outcome: "positive",
+    retryable: false,
+    taxonomy: "support"
+  },
+  {
+    code: "escalated",
+    label: "Escalated to human",
+    outcome: "neutral",
+    retryable: false,
+    taxonomy: "support"
+  },
+  {
+    code: "payment-promised",
+    label: "Payment promised",
+    outcome: "positive",
+    retryable: false,
+    taxonomy: "collections"
+  },
+  {
+    code: "dispute-raised",
+    label: "Dispute raised",
+    outcome: "negative",
+    retryable: false,
+    taxonomy: "collections"
+  }
+];
+var createVoiceCallDispositionTagger = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  const definitions = options.taxonomy ?? DEFAULT_VOICE_CALL_DISPOSITIONS;
+  const byCode = new Map(definitions.map((d) => [d.code, d]));
+  const allowMultiple = options.allowMultiple ?? false;
+  const tags = new Map;
+  const tag = (sessionId, code, note) => {
+    if (!byCode.has(code)) {
+      throw new Error(`Unknown disposition code: ${code}`);
+    }
+    const entry = {
+      code,
+      sessionId,
+      taggedAt: now(),
+      ...note !== undefined ? { note } : {}
+    };
+    const existing = tags.get(sessionId) ?? [];
+    if (!allowMultiple) {
+      tags.set(sessionId, [entry]);
+    } else {
+      tags.set(sessionId, [...existing, entry]);
+    }
+    return entry;
+  };
+  const untag = (sessionId, code) => {
+    const existing = tags.get(sessionId);
+    if (!existing)
+      return 0;
+    if (code === undefined) {
+      tags.delete(sessionId);
+      return existing.length;
+    }
+    const filtered = existing.filter((t) => t.code !== code);
+    const removed = existing.length - filtered.length;
+    if (filtered.length === 0)
+      tags.delete(sessionId);
+    else
+      tags.set(sessionId, filtered);
+    return removed;
+  };
+  const listForSession = (sessionId) => tags.get(sessionId)?.slice() ?? [];
+  const listAll = () => {
+    const flat = [];
+    for (const list of tags.values())
+      flat.push(...list);
+    return flat;
+  };
+  const summarize = () => {
+    const byCodeCount = new Map;
+    const byOutcomeCount = { negative: 0, neutral: 0, "no-contact": 0, positive: 0 };
+    let retryableTagged = 0;
+    let totalTagged = 0;
+    for (const list of tags.values()) {
+      for (const entry of list) {
+        totalTagged += 1;
+        byCodeCount.set(entry.code, (byCodeCount.get(entry.code) ?? 0) + 1);
+        const def = byCode.get(entry.code);
+        if (!def)
+          continue;
+        byOutcomeCount[def.outcome] += 1;
+        if (def.retryable)
+          retryableTagged += 1;
+      }
+    }
+    return {
+      byCode: Object.fromEntries(byCodeCount),
+      byOutcome: byOutcomeCount,
+      retryablePct: totalTagged === 0 ? 0 : retryableTagged / totalTagged,
+      totalSessions: tags.size,
+      totalTagged
+    };
+  };
+  return {
+    definitionFor: (code) => byCode.get(code) ?? null,
+    definitions,
+    listAll,
+    listForSession,
+    summarize,
+    tag,
+    untag
+  };
+};
+// src/retryPolicy.ts
+var DEFAULT_RULES = [
+  { action: "retry", cooldownMs: 4 * 60 * 60 * 1000, disposition: "voicemail-left" },
+  { action: "retry", cooldownMs: 30 * 60 * 1000, disposition: "no-answer" },
+  { action: "retry", cooldownMs: 10 * 60 * 1000, disposition: "busy" },
+  { action: "retry", cooldownMs: 24 * 60 * 60 * 1000, disposition: "callback-requested" },
+  { action: "abandon", disposition: "do-not-call" },
+  { action: "abandon", disposition: "not-interested" },
+  { action: "abandon", disposition: "wrong-number" },
+  { action: "abandon", disposition: "sale" }
+];
+var createVoiceRetryPolicy = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  const maxAttempts = options.maxAttempts ?? 3;
+  const baseCooldown = options.defaultCooldownMs ?? 30 * 60 * 1000;
+  const jitter = options.jitterMs ?? 60 * 1000;
+  const backoff = options.backoffMultiplier ?? 1.5;
+  const escalateAfter = options.escalateAfterAttempts ?? Infinity;
+  const rulesByDisposition = new Map;
+  for (const rule of options.rules ?? DEFAULT_RULES) {
+    rulesByDisposition.set(rule.disposition, rule);
+  }
+  const decide = (history, lastDisposition) => {
+    const rule = rulesByDisposition.get(lastDisposition);
+    const attemptCount = history.length;
+    const max = rule?.maxAttemptsOverride ?? maxAttempts;
+    if (attemptCount >= escalateAfter) {
+      return {
+        action: "escalate",
+        reason: `${attemptCount} attempts without contact`
+      };
+    }
+    if (!rule || rule.action === "abandon") {
+      return { action: "abandon", reason: "non-retryable" };
+    }
+    if (rule.action === "escalate") {
+      return { action: "escalate", reason: lastDisposition };
+    }
+    if (attemptCount >= max) {
+      return { action: "abandon", reason: "max-attempts" };
+    }
+    const cooldown = rule.cooldownMs ?? baseCooldown;
+    const exponent = Math.pow(backoff, Math.max(0, attemptCount - 1));
+    const jitterDelta = jitter > 0 ? Math.floor(Math.random() * jitter) : 0;
+    const retryAt = now() + Math.round(cooldown * exponent) + jitterDelta;
+    return {
+      action: "retry",
+      attemptNumber: attemptCount + 1,
+      retryAt
+    };
+  };
+  return {
+    decide,
+    maxAttempts,
+    rules: () => Array.from(rulesByDisposition.values()),
+    updateRule(rule) {
+      rulesByDisposition.set(rule.disposition, rule);
+    }
+  };
+};
+// src/campaignTemplate.ts
+var lookupPath = (scope, path) => {
+  const parts2 = path.split(".");
+  let cursor = scope;
+  for (const part of parts2) {
+    if (cursor === null || cursor === undefined)
+      return;
+    if (typeof cursor !== "object")
+      return;
+    cursor = cursor[part];
+  }
+  return cursor;
+};
+var escapeSpeech = (text) => text.replace(/[<&>"]/gu, (char) => {
+  switch (char) {
+    case "&":
+      return "&amp;";
+    case "<":
+      return "&lt;";
+    case ">":
+      return "&gt;";
+    case '"':
+      return "&quot;";
+    default:
+      return char;
+  }
+});
+var formatPhone = (phone) => {
+  const digits = phone.replace(/\D/gu, "");
+  if (digits.length === 10) {
+    return `(${digits.slice(0, 3)}) ${digits.slice(3, 6)}-${digits.slice(6)}`;
+  }
+  if (digits.length === 11 && digits.startsWith("1")) {
+    return `+1 (${digits.slice(1, 4)}) ${digits.slice(4, 7)}-${digits.slice(7)}`;
+  }
+  return phone;
+};
+var formatDate = (value, locale) => {
+  if (value === null || value === undefined)
+    return "";
+  const date = new Date(typeof value === "number" ? value : String(value));
+  if (Number.isNaN(date.getTime()))
+    return String(value);
+  return date.toLocaleDateString(locale ?? "en-US", {
+    day: "numeric",
+    month: "long",
+    year: "numeric"
+  });
+};
+var DEFAULT_VOICE_CAMPAIGN_TEMPLATE_FILTERS = {
+  capitalize: (value) => {
+    if (value === null || value === undefined || value === "")
+      return value ?? "";
+    const text = String(value);
+    return text.charAt(0).toUpperCase() + text.slice(1);
+  },
+  currency: (value, currency = "USD") => {
+    if (typeof value !== "number")
+      return String(value ?? "");
+    return new Intl.NumberFormat("en-US", {
+      currency,
+      style: "currency"
+    }).format(value);
+  },
+  date: (value, locale) => formatDate(value, locale),
+  default: (value, fallback) => value === null || value === undefined || value === "" ? fallback ?? "" : value,
+  lower: (value) => String(value ?? "").toLowerCase(),
+  phone: (value) => formatPhone(String(value ?? "")),
+  ssml: (value) => escapeSpeech(String(value ?? "")),
+  upper: (value) => String(value ?? "").toUpperCase()
+};
+var renderValue = (value, filters, filterChain) => {
+  let cursor = value;
+  for (const segment of filterChain) {
+    const parts2 = segment.split(":");
+    const name = (parts2[0] ?? "").trim();
+    if (!name)
+      continue;
+    const args = parts2.slice(1).join(":").split(",").map((a) => a.trim()).filter((a) => a.length > 0);
+    const filter = filters[name];
+    if (!filter)
+      throw new Error(`Unknown template filter: ${name}`);
+    cursor = filter(cursor, ...args);
+  }
+  if (cursor === null || cursor === undefined)
+    return "";
+  return String(cursor);
+};
+var resolveVoiceCampaignTemplate = (template, options) => {
+  const filters = {
+    ...DEFAULT_VOICE_CAMPAIGN_TEMPLATE_FILTERS,
+    ...options.filters ?? {}
+  };
+  const missing = new Set;
+  const output = template.replace(/\{\{([^{}]+)\}\}/gu, (match, expression) => {
+    const segments = expression.split("|").map((part) => part.trim());
+    const path = segments[0] ?? "";
+    const value = lookupPath(options.scope, path);
+    if (value === undefined) {
+      missing.add(path);
+      if (options.strict) {
+        throw new Error(`Missing template variable: ${path}`);
+      }
+      return options.fallback ?? "";
+    }
+    return renderValue(value, filters, segments.slice(1));
+  });
+  return { missingVariables: Array.from(missing), output };
+};
+var collectVoiceCampaignTemplateVariables = (template) => {
+  const set = new Set;
+  const matches = template.matchAll(/\{\{([^{}]+)\}\}/gu);
+  for (const match of matches) {
+    const expression = match[1] ?? "";
+    const path = (expression.split("|")[0] ?? "").trim();
+    if (path)
+      set.add(path);
+  }
+  return Array.from(set);
+};
 export {
   writeVoiceProofPack,
   writeVoiceMediaPipelineArtifacts,
@@ -48668,6 +49278,7 @@ export {
   resolveVoiceMonitorIssue,
   resolveVoiceDiagnosticsTraceFilter,
   resolveVoiceDashboardRenderers,
+  resolveVoiceCampaignTemplate,
   resolveVoiceAuditTrailFilter,
   resolveVoiceAuditDeliveryFilter,
   resolveVoiceAssistantMode,
@@ -48825,6 +49436,7 @@ export {
   isVoiceOpsTaskOverdue,
   isPhoneOnDNC,
   interleaveStereoPcm,
+  importVoiceDNCFromCSV,
   importVoiceCampaignRecipients,
   heartbeatVoiceOpsTask,
   hasVoiceOpsTaskSLABreach,
@@ -49002,6 +49614,7 @@ export {
   createVoiceRoutingDecisionSummary,
   createVoiceRouteAuth,
   createVoiceReviewSavedEvent,
+  createVoiceRetryPolicy,
   createVoiceRetentionScheduler,
   createVoiceResilienceRoutes,
   createVoiceReplayTimelineHTMXRoute,
@@ -49196,6 +49809,7 @@ export {
   createVoiceDeliveryRuntime,
   createVoiceDataControlRoutes,
   createVoiceDTMFTool,
+  createVoiceDNCRegistry,
   createVoiceCostDashboardHTMXRoute,
   createVoiceCostAccountant,
   createVoiceCompetitiveCoverageRoutes,
@@ -49205,11 +49819,13 @@ export {
   createVoiceCampaignTelephonyOutcomeHandler,
   createVoiceCampaignRoutes,
   createVoiceCampaign,
+  createVoiceCallingWindow,
   createVoiceCallerMemoryNamespace,
   createVoiceCallReviewRecorder,
   createVoiceCallReviewFromSession,
   createVoiceCallReviewFromLiveTelephonyReport,
   createVoiceCallPlayer,
+  createVoiceCallDispositionTagger,
   createVoiceCallDebuggerRoutes,
   createVoiceCallCompletedEvent,
   createVoiceCRMActivitySink,
@@ -49285,6 +49901,7 @@ export {
   compareVoiceEvalBaseline,
   compareVoiceCostScenarios,
   collectVoiceDTMFInput,
+  collectVoiceCampaignTemplateVariables,
   claimVoiceOpsTask,
   buildVoiceTraceReplay,
   buildVoiceTraceDeliveryReport,
@@ -49435,6 +50052,7 @@ export {
   acknowledgeVoiceMonitorIssue,
   VOICE_WEBHOOK_TIMESTAMP_HEADER,
   VOICE_WEBHOOK_SIGNATURE_HEADER,
+  VOICE_TCPA_DEFAULT_WINDOW,
   VOICE_LIVE_OPS_ACTIONS,
   VOICE_DTMF_DIGITS,
   VOICE_CALLER_MEMORY_KEY,
@@ -49445,5 +50063,7 @@ export {
   DEFAULT_VOICE_PROMPT_INJECTION_RULES,
   DEFAULT_VOICE_PRICE_BOOK,
   DEFAULT_VOICE_POST_CALL_SURVEY_QUESTIONS,
+  DEFAULT_VOICE_CAMPAIGN_TEMPLATE_FILTERS,
+  DEFAULT_VOICE_CALL_DISPOSITIONS,
   BROWSER_NOISE_SUPPRESSOR_PRESETS
 };

package/dist/retryPolicy.d.ts

@@ -0,0 +1,38 @@
+export type VoiceRetryDispositionAction = "retry" | "abandon" | "escalate";
+export type VoiceRetryDispositionRule = {
+    disposition: string;
+    action: VoiceRetryDispositionAction;
+    cooldownMs?: number;
+    maxAttemptsOverride?: number;
+};
+export type VoiceRetryAttempt = {
+    disposition: string;
+    at: number;
+};
+export type VoiceRetryDecision = {
+    action: "retry";
+    attemptNumber: number;
+    retryAt: number;
+} | {
+    action: "abandon";
+    reason: "max-attempts" | "non-retryable" | "explicit";
+} | {
+    action: "escalate";
+    reason: string;
+};
+export type CreateVoiceRetryPolicyOptions = {
+    maxAttempts?: number;
+    defaultCooldownMs?: number;
+    jitterMs?: number;
+    backoffMultiplier?: number;
+    rules?: VoiceRetryDispositionRule[];
+    escalateAfterAttempts?: number;
+    now?: () => number;
+};
+export declare const createVoiceRetryPolicy: (options?: CreateVoiceRetryPolicyOptions) => {
+    decide: (history: VoiceRetryAttempt[], lastDisposition: string) => VoiceRetryDecision;
+    maxAttempts: number;
+    rules: () => VoiceRetryDispositionRule[];
+    updateRule(rule: VoiceRetryDispositionRule): void;
+};
+export type VoiceRetryPolicy = ReturnType<typeof createVoiceRetryPolicy>;

package/package.json

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