@absolutejs/voice 0.0.18 → 0.0.20

package/dist/testing/fixtures.d.ts

@@ -5,6 +5,7 @@ export type VoiceTestFixtureManifestEntry = {
     audioPath: string;
     expectedText: string;
     expectedTerms?: string[];
+    expectedTurnTexts?: string[];
     chunkDurationMs?: number;
     language?: string;
     difficulty?: 'clean' | 'noisy' | 'challenging';

package/dist/testing/index.d.ts

@@ -1,4 +1,6 @@
 export * from './accuracy';
 export * from './benchmark';
 export * from './fixtures';
+export * from './resilience';
+export * from './sessionBenchmark';
 export * from './stt';

package/dist/testing/index.js

@@ -434,9 +434,768 @@ var loadVoiceTestFixtures = async (fixtureDirectory) => {
     };
   }));
 };
+// src/store.ts
+var createId = () => crypto.randomUUID();
+var createVoiceSessionRecord = (id) => ({
+  committedTurnIds: [],
+  createdAt: Date.now(),
+  currentTurn: {
+    finalText: "",
+    partialText: "",
+    transcripts: []
+  },
+  id,
+  reconnect: { attempts: 0 },
+  status: "active",
+  transcripts: [],
+  turns: []
+});
+var resetVoiceSessionRecord = (id, existing) => ({
+  ...createVoiceSessionRecord(id),
+  metadata: existing?.metadata
+});
+var toVoiceSessionSummary = (session) => ({
+  createdAt: session.createdAt,
+  id: session.id,
+  lastActivityAt: session.lastActivityAt,
+  status: session.status,
+  turnCount: session.turns.length
+});
+
+// src/memoryStore.ts
+var createVoiceMemoryStore = () => {
+  const sessions = new Map;
+  const get = async (id) => sessions.get(id);
+  const getOrCreate = async (id) => {
+    let session = sessions.get(id);
+    if (!session) {
+      session = createVoiceSessionRecord(id);
+      sessions.set(id, session);
+    }
+    return session;
+  };
+  const set = async (id, value) => {
+    sessions.set(id, value);
+  };
+  const list = async () => Array.from(sessions.values()).map((session) => toVoiceSessionSummary(session)).sort((first, second) => (second.lastActivityAt ?? second.createdAt) - (first.lastActivityAt ?? first.createdAt));
+  const remove = async (id) => {
+    sessions.delete(id);
+  };
+  return { get, getOrCreate, list, remove, set };
+};
+
+// src/logger.ts
+var noop = () => {};
+var createNoopLogger = () => ({
+  debug: noop,
+  error: noop,
+  info: noop,
+  warn: noop
+});
+var resolveLogger = (logger) => ({
+  ...createNoopLogger(),
+  ...logger
+});
+
+// src/session.ts
+var DEFAULT_RECONNECT_TIMEOUT = 30000;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var toError = (value) => value instanceof Error ? value : new Error(String(value));
+var createEmptyCurrentTurn = () => ({
+  finalText: "",
+  partialText: "",
+  transcripts: []
+});
+var cloneTranscript = (transcript) => ({ ...transcript });
+var setTurnResult = (session, turnId, input) => {
+  session.turns = session.turns.map((turn) => turn.id === turnId ? {
+    ...turn,
+    assistantText: input.assistantText ?? turn.assistantText,
+    result: input.result ?? turn.result
+  } : turn);
+};
+var createVoiceSession = (options) => {
+  const logger = resolveLogger(options.logger);
+  const reconnect = {
+    maxAttempts: options.reconnect.maxAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS,
+    strategy: options.reconnect.strategy ?? "resume-last-turn",
+    timeout: options.reconnect.timeout ?? DEFAULT_RECONNECT_TIMEOUT
+  };
+  const turnDetection = {
+    silenceMs: options.turnDetection.silenceMs ?? DEFAULT_SILENCE_MS,
+    speechThreshold: options.turnDetection.speechThreshold ?? DEFAULT_SPEECH_THRESHOLD
+  };
+  let socket = options.socket;
+  let sttSession = null;
+  let silenceTimer = null;
+  let speechDetected = false;
+  const clearSilenceTimer = () => {
+    if (!silenceTimer) {
+      return;
+    }
+    clearTimeout(silenceTimer);
+    silenceTimer = null;
+  };
+  const send = async (message) => {
+    try {
+      await Promise.resolve(socket.send(JSON.stringify(message)));
+    } catch (error) {
+      logger.warn("voice socket send failed", {
+        error: toError(error).message,
+        sessionId: options.id,
+        type: message.type
+      });
+    }
+  };
+  const readSession = async () => options.store.getOrCreate(options.id);
+  const writeSession = async (mutate) => {
+    const session = await options.store.getOrCreate(options.id);
+    mutate(session);
+    await options.store.set(options.id, session);
+    return session;
+  };
+  const closeAdapter = async (reason) => {
+    if (!sttSession) {
+      return;
+    }
+    const activeSession = sttSession;
+    sttSession = null;
+    try {
+      await activeSession.close(reason);
+    } catch (error) {
+      logger.warn("voice stt close failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+    }
+  };
+  const scheduleSilenceCommit = () => {
+    if (silenceTimer) {
+      return;
+    }
+    silenceTimer = setTimeout(() => {
+      api.commitTurn("silence");
+    }, turnDetection.silenceMs);
+  };
+  const handleError = async (event) => {
+    await send({
+      message: event.error.message,
+      recoverable: event.recoverable,
+      type: "error"
+    });
+    if (!event.recoverable) {
+      await api.fail(event.error);
+    }
+  };
+  const handleClose = async (event) => {
+    if (event.recoverable === false) {
+      await api.fail(new Error(event.reason ?? "Speech-to-text session closed"));
+    }
+  };
+  const handlePartial = async (transcript) => {
+    await writeSession((session) => {
+      session.currentTurn.lastAudioAt = Date.now();
+      session.currentTurn.partialText = buildTurnText(session.currentTurn.transcripts, transcript.text);
+      session.lastActivityAt = Date.now();
+      session.status = "active";
+    });
+    await send({
+      transcript,
+      type: "partial"
+    });
+  };
+  const handleFinal = async (transcript) => {
+    await writeSession((session) => {
+      const alreadyPresent = session.currentTurn.transcripts.some((existing) => existing.id === transcript.id);
+      if (!alreadyPresent) {
+        session.currentTurn.transcripts = [
+          ...session.currentTurn.transcripts,
+          cloneTranscript(transcript)
+        ];
+        session.transcripts = [
+          ...session.transcripts,
+          cloneTranscript(transcript)
+        ];
+      }
+      session.currentTurn.finalText = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText);
+      session.currentTurn.lastAudioAt = Date.now();
+      session.lastActivityAt = Date.now();
+      session.status = "active";
+    });
+    await send({
+      transcript,
+      type: "final"
+    });
+  };
+  const ensureAdapter = async () => {
+    if (sttSession) {
+      return sttSession;
+    }
+    sttSession = await options.stt.open({
+      format: {
+        channels: 1,
+        container: "raw",
+        encoding: "pcm_s16le",
+        sampleRateHz: 16000
+      },
+      sessionId: options.id
+    });
+    sttSession.on("partial", ({ transcript }) => {
+      handlePartial(transcript);
+    });
+    sttSession.on("final", ({ transcript }) => {
+      handleFinal(transcript);
+    });
+    sttSession.on("endOfTurn", ({ reason }) => {
+      clearSilenceTimer();
+      api.commitTurn(reason);
+    });
+    sttSession.on("error", (event) => {
+      handleError(event);
+    });
+    sttSession.on("close", (event) => {
+      handleClose(event);
+    });
+    return sttSession;
+  };
+  const completeTurn = async (session, turn) => {
+    const output = await options.route.onTurn({
+      api,
+      context: options.context,
+      session,
+      turn
+    });
+    if (output?.assistantText) {
+      await writeSession((currentSession) => {
+        setTurnResult(currentSession, turn.id, {
+          assistantText: output.assistantText
+        });
+      });
+      await send({
+        text: output.assistantText,
+        turnId: turn.id,
+        type: "assistant"
+      });
+    }
+    if (output?.result !== undefined) {
+      await writeSession((currentSession) => {
+        setTurnResult(currentSession, turn.id, {
+          result: output.result
+        });
+      });
+    }
+    if (output?.complete) {
+      await api.complete(output.result);
+    }
+  };
+  const api = {
+    id: options.id,
+    close: async (reason) => {
+      clearSilenceTimer();
+      await closeAdapter(reason);
+      await Promise.resolve(socket.close(1000, reason));
+    },
+    commitTurn: async (reason = "manual") => {
+      clearSilenceTimer();
+      const session = await readSession();
+      if (session.status === "completed" || session.status === "failed") {
+        return;
+      }
+      const text = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText);
+      if (!text) {
+        return;
+      }
+      const turn = {
+        committedAt: Date.now(),
+        id: createId(),
+        text,
+        transcripts: session.currentTurn.transcripts.length > 0 ? session.currentTurn.transcripts.map(cloneTranscript) : [
+          {
+            id: createId(),
+            isFinal: false,
+            text
+          }
+        ]
+      };
+      const updatedSession = await writeSession((currentSession) => {
+        currentSession.committedTurnIds = [
+          ...currentSession.committedTurnIds,
+          turn.id
+        ];
+        currentSession.currentTurn = createEmptyCurrentTurn();
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "active";
+        currentSession.turns = [...currentSession.turns, turn];
+      });
+      speechDetected = false;
+      logger.info("voice turn committed", {
+        reason,
+        sessionId: options.id,
+        turnId: turn.id
+      });
+      await send({
+        turn,
+        type: "turn"
+      });
+      await completeTurn(updatedSession, turn);
+    },
+    complete: async (result) => {
+      clearSilenceTimer();
+      const session = await writeSession((currentSession) => {
+        if (currentSession.status === "completed") {
+          return;
+        }
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "completed";
+        if (result !== undefined && currentSession.turns.length > 0) {
+          const lastTurn = currentSession.turns.at(-1);
+          if (lastTurn) {
+            setTurnResult(currentSession, lastTurn.id, {
+              result
+            });
+          }
+        }
+      });
+      await send({
+        sessionId: options.id,
+        type: "complete"
+      });
+      await closeAdapter("complete");
+      speechDetected = false;
+      await options.route.onComplete({
+        api,
+        context: options.context,
+        session
+      });
+    },
+    connect: async (nextSocket) => {
+      socket = nextSocket;
+      const existingSession = await options.store.get(options.id);
+      let session = existingSession ?? createVoiceSessionRecord(options.id);
+      let shouldFireOnSession = !existingSession;
+      if (existingSession?.status === "reconnecting") {
+        const nextAttempts = existingSession.reconnect.attempts + 1;
+        const reconnectExpired = existingSession.reconnect.lastDisconnectAt !== undefined && Date.now() - existingSession.reconnect.lastDisconnectAt > reconnect.timeout;
+        const tooManyAttempts = nextAttempts > reconnect.maxAttempts;
+        if (reconnect.strategy === "fail" && (reconnectExpired || tooManyAttempts)) {
+          await api.fail(new Error("Voice session reconnect policy exhausted"));
+          return;
+        }
+        if (reconnect.strategy === "restart" && (reconnectExpired || tooManyAttempts)) {
+          session = resetVoiceSessionRecord(options.id, existingSession);
+          shouldFireOnSession = true;
+        } else {
+          session = {
+            ...existingSession,
+            reconnect: {
+              ...existingSession.reconnect,
+              attempts: nextAttempts
+            },
+            status: "active"
+          };
+        }
+      }
+      await options.store.set(options.id, session);
+      await send({
+        sessionId: options.id,
+        status: session.status,
+        type: "session"
+      });
+      if (shouldFireOnSession) {
+        await options.route.onSession?.({
+          api,
+          context: options.context,
+          session
+        });
+      }
+      if (session.status === "completed") {
+        await send({
+          sessionId: options.id,
+          type: "complete"
+        });
+        return;
+      }
+      await ensureAdapter();
+    },
+    disconnect: async (event) => {
+      clearSilenceTimer();
+      await closeAdapter(event?.reason);
+      if (reconnect.strategy === "fail") {
+        await api.fail(new Error(event?.reason ?? "Voice socket disconnected"));
+        return;
+      }
+      await writeSession((session) => {
+        if (session.status === "completed" || session.status === "failed") {
+          return;
+        }
+        session.lastActivityAt = Date.now();
+        session.reconnect.lastDisconnectAt = Date.now();
+        session.status = "reconnecting";
+      });
+      speechDetected = false;
+    },
+    fail: async (error) => {
+      clearSilenceTimer();
+      const session = await writeSession((currentSession) => {
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "failed";
+      });
+      const resolvedError = toError(error);
+      await send({
+        message: resolvedError.message,
+        recoverable: false,
+        type: "error"
+      });
+      await closeAdapter("failed");
+      speechDetected = false;
+      await options.route.onError?.({
+        api,
+        context: options.context,
+        error: resolvedError,
+        session,
+        sessionId: options.id
+      });
+    },
+    receiveAudio: async (audio) => {
+      const session = await readSession();
+      if (session.status === "completed" || session.status === "failed") {
+        return;
+      }
+      const adapter = await ensureAdapter();
+      const audioLevel = measureAudioLevel(audio);
+      await writeSession((currentSession) => {
+        currentSession.currentTurn.lastAudioAt = Date.now();
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "active";
+      });
+      if (audioLevel >= turnDetection.speechThreshold) {
+        speechDetected = true;
+        clearSilenceTimer();
+      } else if (speechDetected) {
+        const currentSession = await readSession();
+        const hasTurnText = Boolean(buildTurnText(currentSession.currentTurn.transcripts, currentSession.currentTurn.partialText));
+        if (hasTurnText) {
+          scheduleSilenceCommit();
+        }
+      }
+      await adapter.send(audio);
+    },
+    snapshot: async () => readSession()
+  };
+  return api;
+};
+
+// src/testing/resilience.ts
+var roundMetric2 = (value, digits = 4) => {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};
+var createMockSocket = () => ({
+  close: async () => {},
+  send: async () => {}
+});
+var createSpeechChunk = (sample) => new Int16Array(160).fill(sample);
+var createFakeAdapter = () => {
+  const listeners = {
+    close: [],
+    endOfTurn: [],
+    error: [],
+    final: [],
+    partial: []
+  };
+  const session = {
+    close: async () => {},
+    emit: async (event, payload) => {
+      for (const listener of listeners[event]) {
+        await listener(payload);
+      }
+    },
+    on: (event, handler) => {
+      listeners[event].push(handler);
+      return () => {
+        const index = listeners[event].indexOf(handler);
+        if (index >= 0) {
+          listeners[event].splice(index, 1);
+        }
+      };
+    },
+    send: async (_audio) => {}
+  };
+  return {
+    adapter: {
+      kind: "stt",
+      open: () => session
+    },
+    session
+  };
+};
+var runScenario = async (id, title, run) => {
+  const store = createVoiceMemoryStore();
+  const adapter = createFakeAdapter();
+  const turns = [];
+  const voice = createVoiceSession({
+    context: {},
+    id,
+    logger: {},
+    reconnect: {
+      maxAttempts: 2,
+      strategy: "resume-last-turn",
+      timeout: 5000
+    },
+    route: {
+      onComplete: async () => {},
+      onTurn: async ({ turn }) => {
+        turns.push(turn.text);
+      }
+    },
+    socket: createMockSocket(),
+    store,
+    stt: adapter.adapter,
+    turnDetection: {
+      silenceMs: 20,
+      speechThreshold: 0.01
+    }
+  });
+  await voice.connect(createMockSocket());
+  try {
+    await run({
+      adapter,
+      commit: async (text, transcriptId = `${id}-${turns.length}`) => {
+        await adapter.session.emit("final", {
+          receivedAt: Date.now(),
+          transcript: {
+            id: transcriptId,
+            isFinal: true,
+            text
+          },
+          type: "final"
+        });
+        await voice.receiveAudio(createSpeechChunk(16000));
+        await voice.receiveAudio(createSpeechChunk(0));
+        await Bun.sleep(60);
+      },
+      connectNewSocket: async () => {
+        await voice.connect(createMockSocket());
+      },
+      disconnect: async () => {
+        await voice.disconnect({
+          recoverable: true,
+          type: "close"
+        });
+      },
+      turns
+    });
+  } finally {
+    await voice.close("resilience-complete");
+  }
+  const uniqueTurns = new Set(turns.map((turn) => turn.toLowerCase()));
+  const replayedTurns = turns.length - uniqueTurns.size;
+  return {
+    actualTurns: turns,
+    id,
+    passes: replayedTurns === 0,
+    replayedTurns,
+    title
+  };
+};
+var runVoiceResilienceBenchmark = async () => {
+  const scenarios = await Promise.all([
+    runScenario("resume-no-replay", "Reconnect after first turn does not replay committed text", async ({ commit, connectNewSocket, disconnect }) => {
+      await commit("Reconnect should not duplicate prior turns");
+      await disconnect();
+      await connectNewSocket();
+      await commit("A second turn should still commit after resume");
+    }),
+    runScenario("duplicate-final-id", "Duplicate transcript ids do not create replayed turns", async ({ adapter, connectNewSocket, disconnect, turns, commit }) => {
+      await commit("Duplicate final ids should still produce one turn", "same-id");
+      await disconnect();
+      await connectNewSocket();
+      await adapter.session.emit("final", {
+        receivedAt: Date.now(),
+        transcript: {
+          id: "same-id",
+          isFinal: true,
+          text: "Duplicate final ids should still produce one turn"
+        },
+        type: "final"
+      });
+      if (turns.length === 1) {
+        await commit("Fresh transcripts should still commit later");
+      }
+    })
+  ]);
+  const passCount = scenarios.filter((scenario) => scenario.passes).length;
+  const replayFailures = scenarios.filter((scenario) => scenario.replayedTurns > 0).length;
+  return {
+    generatedAt: Date.now(),
+    scenarios,
+    summary: {
+      duplicateTurnRate: roundMetric2(scenarios.length > 0 ? replayFailures / scenarios.length : 0),
+      passCount,
+      passRate: roundMetric2(scenarios.length > 0 ? passCount / scenarios.length : 0),
+      replayFailureRate: roundMetric2(scenarios.length > 0 ? replayFailures / scenarios.length : 0),
+      scenarioCount: scenarios.length
+    }
+  };
+};
+// src/testing/sessionBenchmark.ts
+var average2 = (values) => values.length > 0 ? values.reduce((sum, value) => sum + value, 0) / values.length : 0;
+var roundMetric3 = (value, digits = 4) => {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};
+var chunkAudio2 = (audio, bytesPerChunk) => {
+  const chunks = [];
+  for (let offset = 0;offset < audio.byteLength; offset += bytesPerChunk) {
+    chunks.push(audio.slice(offset, offset + bytesPerChunk));
+  }
+  return chunks;
+};
+var createSilence2 = (byteLength) => new Uint8Array(byteLength);
+var createMockSocket2 = () => ({
+  close: async () => {},
+  send: async () => {}
+});
+var runVoiceSessionBenchmarkScenario = async (adapter, fixture) => {
+  const store = createVoiceMemoryStore();
+  const turns = [];
+  const session = createVoiceSession({
+    context: {},
+    id: `session-bench-${fixture.id}`,
+    logger: {},
+    reconnect: {
+      maxAttempts: 2,
+      strategy: "resume-last-turn",
+      timeout: 5000
+    },
+    route: {
+      onComplete: async () => {},
+      onTurn: async ({ turn }) => {
+        turns.push(turn.text);
+      }
+    },
+    socket: createMockSocket2(),
+    store,
+    stt: adapter,
+    turnDetection: {
+      silenceMs: fixture.silenceMs ?? DEFAULT_SILENCE_MS,
+      speechThreshold: fixture.speechThreshold ?? DEFAULT_SPEECH_THRESHOLD
+    }
+  });
+  const startedAt = Date.now();
+  let reconnectTriggered = false;
+  await session.connect(createMockSocket2());
+  try {
+    const chunkDurationMs = fixture.chunkDurationMs ?? 100;
+    const bytesPerMillisecond = fixture.format.sampleRateHz * fixture.format.channels * 2 / 1000;
+    const bytesPerChunk = Math.max(2, Math.floor(bytesPerMillisecond * chunkDurationMs));
+    const chunks = chunkAudio2(fixture.audio, bytesPerChunk);
+    for (const [index, chunk] of chunks.entries()) {
+      await session.receiveAudio(chunk);
+      await Bun.sleep(chunkDurationMs);
+      if (fixture.reconnectAtChunkIndex !== undefined && index === fixture.reconnectAtChunkIndex && !reconnectTriggered) {
+        reconnectTriggered = true;
+        await session.disconnect({
+          reason: "benchmark-reconnect",
+          recoverable: true,
+          type: "close"
+        });
+        await Bun.sleep(fixture.reconnectPauseMs ?? 150);
+        await session.connect(createMockSocket2());
+      }
+    }
+    const tailPaddingMs = fixture.tailPaddingMs ?? 1200;
+    if (tailPaddingMs > 0) {
+      const tailBytes = Math.max(2, Math.floor(bytesPerMillisecond * tailPaddingMs));
+      for (const chunk of chunkAudio2(createSilence2(tailBytes), bytesPerChunk)) {
+        await session.receiveAudio(chunk);
+        await Bun.sleep(chunkDurationMs);
+      }
+    }
+    await Bun.sleep(Math.max(1200, fixture.silenceMs ?? DEFAULT_SILENCE_MS));
+  } finally {
+    await session.close("session-benchmark-complete");
+  }
+  const duplicateTurnCount = Math.max(0, turns.length - new Set(turns.map((turn) => turn.toLowerCase())).size);
+  const turnResults = fixture.expectedTurnTexts.map((expectedText, index) => {
+    const actualText = turns[index];
+    if (!actualText) {
+      return {
+        actualText: "",
+        expectedText,
+        index,
+        passes: false
+      };
+    }
+    const accuracy = scoreTranscriptAccuracy(actualText, expectedText, fixture.transcriptThreshold ?? 0.35);
+    return {
+      actualText,
+      accuracy,
+      expectedText,
+      index,
+      passes: accuracy.passesThreshold
+    };
+  });
+  for (let index = fixture.expectedTurnTexts.length;index < turns.length; index += 1) {
+    turnResults.push({
+      actualText: turns[index] ?? "",
+      expectedText: undefined,
+      index,
+      passes: false
+    });
+  }
+  const turnCountDelta = turns.length - fixture.expectedTurnTexts.length;
+  return {
+    actualTurns: turns,
+    duplicateTurnCount,
+    elapsedMs: Date.now() - startedAt,
+    expectedTurns: fixture.expectedTurnTexts,
+    fixtureId: fixture.id,
+    passes: duplicateTurnCount === 0 && turnCountDelta === 0 && turnResults.every((result) => result.passes),
+    reconnectTriggered,
+    tags: fixture.tags ?? [],
+    title: fixture.title,
+    turnCountDelta,
+    turnResults
+  };
+};
+var summarizeVoiceSessionBenchmark = (adapterId, scenarios) => {
+  const passCount = scenarios.filter((scenario) => scenario.passes).length;
+  const reconnectScenarios = scenarios.filter((scenario) => scenario.reconnectTriggered);
+  const reconnectSuccessCount = reconnectScenarios.filter((scenario) => scenario.passes).length;
+  const turnAccuracies = scenarios.flatMap((scenario) => scenario.turnResults.map((turn) => turn.accuracy?.wordErrorRate).filter((value) => typeof value === "number"));
+  return {
+    adapterId,
+    averageElapsedMs: roundMetric3(average2(scenarios.map((scenario) => scenario.elapsedMs)), 2),
+    averageWordErrorRate: roundMetric3(average2(turnAccuracies)),
+    duplicateTurnRate: roundMetric3(scenarios.length > 0 ? scenarios.filter((scenario) => scenario.duplicateTurnCount > 0).length / scenarios.length : 0),
+    passCount,
+    passRate: roundMetric3(scenarios.length > 0 ? passCount / scenarios.length : 0),
+    reconnectSuccessRate: roundMetric3(reconnectScenarios.length > 0 ? reconnectSuccessCount / reconnectScenarios.length : 1),
+    scenarioCount: scenarios.length,
+    scenariosWithDuplicateTurns: scenarios.filter((scenario) => scenario.duplicateTurnCount > 0).length,
+    scenariosWithTurnCountMismatch: scenarios.filter((scenario) => scenario.turnCountDelta !== 0).length
+  };
+};
+var runVoiceSessionBenchmark = async (input) => {
+  const scenarioResults = [];
+  for (const scenario of input.scenarios) {
+    scenarioResults.push(await runVoiceSessionBenchmarkScenario(input.adapter, scenario));
+  }
+  return {
+    adapterId: input.adapterId,
+    generatedAt: Date.now(),
+    scenarios: scenarioResults,
+    summary: summarizeVoiceSessionBenchmark(input.adapterId, scenarioResults)
+  };
+};
 export {
+  summarizeVoiceSessionBenchmark,
   summarizeSTTBenchmark,
   scoreTranscriptAccuracy,
+  runVoiceSessionBenchmarkScenario,
+  runVoiceSessionBenchmark,
+  runVoiceResilienceBenchmark,
   runSTTAdapterFixture,
   runSTTAdapterBenchmark,
   mergeFinalTranscriptText,

package/dist/testing/resilience.d.ts

@@ -0,0 +1,20 @@
+export type VoiceResilienceScenarioResult = {
+    actualTurns: string[];
+    id: string;
+    passes: boolean;
+    replayedTurns: number;
+    title: string;
+};
+export type VoiceResilienceSummary = {
+    duplicateTurnRate: number;
+    passCount: number;
+    passRate: number;
+    replayFailureRate: number;
+    scenarioCount: number;
+};
+export type VoiceResilienceReport = {
+    generatedAt: number;
+    scenarios: VoiceResilienceScenarioResult[];
+    summary: VoiceResilienceSummary;
+};
+export declare const runVoiceResilienceBenchmark: () => Promise<VoiceResilienceReport>;

package/dist/testing/sessionBenchmark.d.ts

@@ -0,0 +1,61 @@
+import type { STTAdapter } from '../types';
+import { type VoiceTranscriptAccuracy } from './accuracy';
+import type { VoiceTestFixture } from './fixtures';
+export type VoiceSessionBenchmarkScenario = VoiceTestFixture & {
+    expectedTurnTexts: string[];
+    reconnectAtChunkIndex?: number;
+    reconnectPauseMs?: number;
+    silenceMs?: number;
+    speechThreshold?: number;
+    transcriptThreshold?: number;
+};
+export type VoiceSessionBenchmarkTurnResult = {
+    actualText: string;
+    accuracy?: VoiceTranscriptAccuracy;
+    expectedText?: string;
+    index: number;
+    passes: boolean;
+};
+export type VoiceSessionBenchmarkScenarioResult = {
+    actualTurns: string[];
+    duplicateTurnCount: number;
+    elapsedMs: number;
+    expectedTurns: string[];
+    fixtureId: string;
+    passes: boolean;
+    reconnectTriggered: boolean;
+    tags: string[];
+    title: string;
+    turnCountDelta: number;
+    turnResults: VoiceSessionBenchmarkTurnResult[];
+};
+export type VoiceSessionBenchmarkSummary = {
+    adapterId: string;
+    averageElapsedMs: number;
+    averageWordErrorRate: number;
+    duplicateTurnRate: number;
+    passCount: number;
+    passRate: number;
+    reconnectSuccessRate: number;
+    scenarioCount: number;
+    scenariosWithDuplicateTurns: number;
+    scenariosWithTurnCountMismatch: number;
+};
+export type VoiceSessionBenchmarkReport = {
+    adapterId: string;
+    generatedAt: number;
+    scenarios: VoiceSessionBenchmarkScenarioResult[];
+    summary: VoiceSessionBenchmarkSummary;
+};
+export declare const runVoiceSessionBenchmarkScenario: (adapter: STTAdapter, fixture: VoiceSessionBenchmarkScenario) => Promise<VoiceSessionBenchmarkScenarioResult>;
+export declare const summarizeVoiceSessionBenchmark: (adapterId: string, scenarios: VoiceSessionBenchmarkScenarioResult[]) => VoiceSessionBenchmarkSummary;
+export declare const runVoiceSessionBenchmark: (input: {
+    adapter: STTAdapter;
+    adapterId: string;
+    scenarios: VoiceSessionBenchmarkScenario[];
+}) => Promise<{
+    adapterId: string;
+    generatedAt: number;
+    scenarios: VoiceSessionBenchmarkScenarioResult[];
+    summary: VoiceSessionBenchmarkSummary;
+}>;

package/fixtures/README.md

@@ -0,0 +1,48 @@
+## Bundled Fixtures
+
+This directory contains small public benchmark fixtures for `@absolutejs/voice`.
+
+### Sources
+
+- `quietly-alone-clean.pcm`
+- `traveled-back-route-clean.pcm`
+- `rainstorms-noisy.pcm`
+
+These are derived from public-domain LibriSpeech material, with the noisy variant created by mixing synthetic noise into a clean base utterance for adapter comparison.
+
+- `stella-india-english37.pcm`
+- `stella-ghana-english507.pcm`
+- `stella-singapore-english655.pcm`
+- `stella-pakistan-english519.pcm`
+- `stella-jamaica-jamaican-creole-english1.pcm`
+- `stella-liberia-liberian-pidgin-english2.pcm`
+- `stella-sierra-leone-krio5.pcm`
+- `stella-bulgaria-bulgarian20.pcm`
+
+These are derived from the Speech Accent Archive at George Mason University using the shared "Please call Stella..." elicitation paragraph.
+
+Archive:
+
+- https://accent.gmu.edu/
+
+License:
+
+- https://creativecommons.org/licenses/by-nc-sa/2.0/
+
+Selected speaker pages:
+
+- https://accent.gmu.edu/browse_language.php?function=detail&speakerid=96
+- https://accent.gmu.edu/browse_language.php?function=detail&speakerid=1800
+- https://accent.gmu.edu/browse_language.php?function=detail&speakerid=3033
+- https://accent.gmu.edu/browse_language.php?function=detail&speakerid=1882
+- https://accent.gmu.edu/browse_language.php?function=detail&speakerid=967
+- https://accent.gmu.edu/browse_language.php?function=detail&speakerid=2141
+- https://accent.gmu.edu/browse_language.php?function=detail&speakerid=1140
+- https://accent.gmu.edu/browse_language.php?function=detail&speakerid=2691
+
+### Synthetic Multi-Turn Fixtures
+
+- `multiturn-two-clean.pcm`
+- `multiturn-three-mixed.pcm`
+
+These are synthetic conversation-style fixtures created by concatenating the bundled public-domain base clips with inserted silence to exercise turn commit behavior.

package/fixtures/manifest.json

@@ -28,5 +28,114 @@
 		"chunkDurationMs": 100,
 		"difficulty": "noisy",
 		"tags": ["noisy", "long", "synthetic-noise", "librispeech"]
+	},
+	{
+		"id": "stella-india-english37",
+		"title": "International English accent from India",
+		"audioPath": "stella-india-english37.pcm",
+		"expectedText": "PLEASE CALL STELLA ASK HER TO BRING THESE THINGS WITH HER FROM THE STORE SIX SPOONS OF FRESH SNOW PEAS FIVE THICK SLABS OF BLUE CHEESE AND MAYBE A SNACK FOR HER BROTHER BOB WE ALSO NEED A SMALL PLASTIC SNAKE AND A BIG TOY FROG FOR THE KIDS SHE CAN SCOOP THESE THINGS INTO THREE RED BAGS AND WE WILL GO MEET HER WEDNESDAY AT THE TRAIN STATION",
+		"expectedTerms": ["stella", "snow peas", "blue cheese", "brother bob", "plastic snake", "toy frog", "three red bags", "train station"],
+		"chunkDurationMs": 100,
+		"difficulty": "challenging",
+		"tags": ["accent", "challenging", "india", "international", "speech-accent-archive"]
+	},
+	{
+		"id": "stella-ghana-english507",
+		"title": "International English accent from Ghana",
+		"audioPath": "stella-ghana-english507.pcm",
+		"expectedText": "PLEASE CALL STELLA ASK HER TO BRING THESE THINGS WITH HER FROM THE STORE SIX SPOONS OF FRESH SNOW PEAS FIVE THICK SLABS OF BLUE CHEESE AND MAYBE A SNACK FOR HER BROTHER BOB WE ALSO NEED A SMALL PLASTIC SNAKE AND A BIG TOY FROG FOR THE KIDS SHE CAN SCOOP THESE THINGS INTO THREE RED BAGS AND WE WILL GO MEET HER WEDNESDAY AT THE TRAIN STATION",
+		"expectedTerms": ["stella", "snow peas", "blue cheese", "brother bob", "plastic snake", "toy frog", "three red bags", "train station"],
+		"chunkDurationMs": 100,
+		"difficulty": "challenging",
+		"tags": ["accent", "challenging", "ghana", "international", "speech-accent-archive"]
+	},
+	{
+		"id": "stella-singapore-english655",
+		"title": "International English accent from Singapore",
+		"audioPath": "stella-singapore-english655.pcm",
+		"expectedText": "PLEASE CALL STELLA ASK HER TO BRING THESE THINGS WITH HER FROM THE STORE SIX SPOONS OF FRESH SNOW PEAS FIVE THICK SLABS OF BLUE CHEESE AND MAYBE A SNACK FOR HER BROTHER BOB WE ALSO NEED A SMALL PLASTIC SNAKE AND A BIG TOY FROG FOR THE KIDS SHE CAN SCOOP THESE THINGS INTO THREE RED BAGS AND WE WILL GO MEET HER WEDNESDAY AT THE TRAIN STATION",
+		"expectedTerms": ["stella", "snow peas", "blue cheese", "brother bob", "plastic snake", "toy frog", "three red bags", "train station"],
+		"chunkDurationMs": 100,
+		"difficulty": "challenging",
+		"tags": ["accent", "challenging", "international", "singapore", "speech-accent-archive"]
+	},
+	{
+		"id": "stella-pakistan-english519",
+		"title": "International English accent from Pakistan",
+		"audioPath": "stella-pakistan-english519.pcm",
+		"expectedText": "PLEASE CALL STELLA ASK HER TO BRING THESE THINGS WITH HER FROM THE STORE SIX SPOONS OF FRESH SNOW PEAS FIVE THICK SLABS OF BLUE CHEESE AND MAYBE A SNACK FOR HER BROTHER BOB WE ALSO NEED A SMALL PLASTIC SNAKE AND A BIG TOY FROG FOR THE KIDS SHE CAN SCOOP THESE THINGS INTO THREE RED BAGS AND WE WILL GO MEET HER WEDNESDAY AT THE TRAIN STATION",
+		"expectedTerms": ["stella", "snow peas", "blue cheese", "brother bob", "plastic snake", "toy frog", "three red bags", "train station"],
+		"chunkDurationMs": 100,
+		"difficulty": "challenging",
+		"tags": ["accent", "challenging", "international", "pakistan", "speech-accent-archive"]
+	},
+	{
+		"id": "stella-jamaica-jamaican-creole-english1",
+		"title": "International English accent from Jamaica",
+		"audioPath": "stella-jamaica-jamaican-creole-english1.pcm",
+		"expectedText": "PLEASE CALL STELLA ASK HER TO BRING THESE THINGS WITH HER FROM THE STORE SIX SPOONS OF FRESH SNOW PEAS FIVE THICK SLABS OF BLUE CHEESE AND MAYBE A SNACK FOR HER BROTHER BOB WE ALSO NEED A SMALL PLASTIC SNAKE AND A BIG TOY FROG FOR THE KIDS SHE CAN SCOOP THESE THINGS INTO THREE RED BAGS AND WE WILL GO MEET HER WEDNESDAY AT THE TRAIN STATION",
+		"expectedTerms": ["stella", "snow peas", "blue cheese", "brother bob", "plastic snake", "toy frog", "three red bags", "train station"],
+		"chunkDurationMs": 100,
+		"difficulty": "challenging",
+		"tags": ["accent", "challenging", "international", "jamaica", "speech-accent-archive"]
+	},
+	{
+		"id": "stella-liberia-liberian-pidgin-english2",
+		"title": "International English accent from Liberia",
+		"audioPath": "stella-liberia-liberian-pidgin-english2.pcm",
+		"expectedText": "PLEASE CALL STELLA ASK HER TO BRING THESE THINGS WITH HER FROM THE STORE SIX SPOONS OF FRESH SNOW PEAS FIVE THICK SLABS OF BLUE CHEESE AND MAYBE A SNACK FOR HER BROTHER BOB WE ALSO NEED A SMALL PLASTIC SNAKE AND A BIG TOY FROG FOR THE KIDS SHE CAN SCOOP THESE THINGS INTO THREE RED BAGS AND WE WILL GO MEET HER WEDNESDAY AT THE TRAIN STATION",
+		"expectedTerms": ["stella", "snow peas", "blue cheese", "brother bob", "plastic snake", "toy frog", "three red bags", "train station"],
+		"chunkDurationMs": 100,
+		"difficulty": "challenging",
+		"tags": ["accent", "challenging", "international", "liberia", "speech-accent-archive"]
+	},
+	{
+		"id": "stella-sierra-leone-krio5",
+		"title": "International English accent from Sierra Leone",
+		"audioPath": "stella-sierra-leone-krio5.pcm",
+		"expectedText": "PLEASE CALL STELLA ASK HER TO BRING THESE THINGS WITH HER FROM THE STORE SIX SPOONS OF FRESH SNOW PEAS FIVE THICK SLABS OF BLUE CHEESE AND MAYBE A SNACK FOR HER BROTHER BOB WE ALSO NEED A SMALL PLASTIC SNAKE AND A BIG TOY FROG FOR THE KIDS SHE CAN SCOOP THESE THINGS INTO THREE RED BAGS AND WE WILL GO MEET HER WEDNESDAY AT THE TRAIN STATION",
+		"expectedTerms": ["stella", "snow peas", "blue cheese", "brother bob", "plastic snake", "toy frog", "three red bags", "train station"],
+		"chunkDurationMs": 100,
+		"difficulty": "challenging",
+		"tags": ["accent", "challenging", "international", "sierra-leone", "speech-accent-archive"]
+	},
+	{
+		"id": "stella-bulgaria-bulgarian20",
+		"title": "International English accent from Bulgaria",
+		"audioPath": "stella-bulgaria-bulgarian20.pcm",
+		"expectedText": "PLEASE CALL STELLA ASK HER TO BRING THESE THINGS WITH HER FROM THE STORE SIX SPOONS OF FRESH SNOW PEAS FIVE THICK SLABS OF BLUE CHEESE AND MAYBE A SNACK FOR HER BROTHER BOB WE ALSO NEED A SMALL PLASTIC SNAKE AND A BIG TOY FROG FOR THE KIDS SHE CAN SCOOP THESE THINGS INTO THREE RED BAGS AND WE WILL GO MEET HER WEDNESDAY AT THE TRAIN STATION",
+		"expectedTerms": ["stella", "snow peas", "blue cheese", "brother bob", "plastic snake", "toy frog", "three red bags", "train station"],
+		"chunkDurationMs": 100,
+		"difficulty": "challenging",
+		"tags": ["accent", "challenging", "bulgaria", "international", "speech-accent-archive"]
+	},
+	{
+		"id": "multiturn-two-clean",
+		"title": "Synthetic two-turn clean conversation",
+		"audioPath": "multiturn-two-clean.pcm",
+		"expectedText": "GO QUIETLY ALONE NO HARM WILL BEFALL YOU WE PASSED AROUND ATLANTA CROSSED THE CHATTAHOOCHEE AND TRAVELED BACK OVER THE SAME ROUTE ON WHICH WE HAD MADE THE ARDUOUS CAMPAIGN UNDER JOE JOHNSTON",
+		"expectedTerms": ["quietly alone", "atlanta", "chattahoochee", "joe johnston"],
+		"expectedTurnTexts": [
+			"GO QUIETLY ALONE NO HARM WILL BEFALL YOU",
+			"WE PASSED AROUND ATLANTA CROSSED THE CHATTAHOOCHEE AND TRAVELED BACK OVER THE SAME ROUTE ON WHICH WE HAD MADE THE ARDUOUS CAMPAIGN UNDER JOE JOHNSTON"
+		],
+		"chunkDurationMs": 100,
+		"difficulty": "clean",
+		"tags": ["clean", "conversation", "multi-turn", "synthetic"]
+	},
+	{
+		"id": "multiturn-three-mixed",
+		"title": "Synthetic three-turn mixed conversation",
+		"audioPath": "multiturn-three-mixed.pcm",
+		"expectedText": "GO QUIETLY ALONE NO HARM WILL BEFALL YOU SLIGHT RAINSTORMS ARE LIKELY TO BE ENCOUNTERED IN A TRIP ROUND THE MOUNTAIN BUT ONE MAY EASILY FIND SHELTER BENEATH WELL THATCHED TREES THAT SHED THE RAIN LIKE A ROOF GO QUIETLY ALONE NO HARM WILL BEFALL YOU",
+		"expectedTerms": ["quietly alone", "rainstorms", "thatched trees"],
+		"expectedTurnTexts": [
+			"GO QUIETLY ALONE NO HARM WILL BEFALL YOU",
+			"SLIGHT RAINSTORMS ARE LIKELY TO BE ENCOUNTERED IN A TRIP ROUND THE MOUNTAIN BUT ONE MAY EASILY FIND SHELTER BENEATH WELL THATCHED TREES THAT SHED THE RAIN LIKE A ROOF",
+			"GO QUIETLY ALONE NO HARM WILL BEFALL YOU"
+		],
+		"chunkDurationMs": 100,
+		"difficulty": "challenging",
+		"tags": ["conversation", "multi-turn", "noisy", "synthetic"]
 	}
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.18",
+	"version": "0.0.20",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",
@@ -16,9 +16,16 @@
 	"license": "CC BY-NC 4.0",
 	"author": "Alex Kahn",
 	"scripts": {
+		"bench:accents": "bun run ./scripts/benchmark-stt.ts all accents",
 		"bench:assemblyai": "bun run ./scripts/benchmark-stt.ts assemblyai",
+		"bench:assemblyai:accents": "bun run ./scripts/benchmark-stt.ts assemblyai accents",
 		"bench:deepgram": "bun run ./scripts/benchmark-stt.ts deepgram",
+		"bench:deepgram:accents": "bun run ./scripts/benchmark-stt.ts deepgram accents",
+		"bench:deepgram:sessions": "bun run ./scripts/benchmark-session.ts deepgram",
+		"bench:resilience": "bun run ./scripts/benchmark-resilience.ts",
+		"bench:sessions": "bun run ./scripts/benchmark-session.ts all",
 		"bench:stt": "bun run ./scripts/benchmark-stt.ts all",
+		"bench:assemblyai:sessions": "bun run ./scripts/benchmark-session.ts assemblyai",
 		"build": "rm -rf dist && bun build ./src/index.ts ./src/client/index.ts ./src/react/index.ts ./src/vue/index.ts ./src/svelte/index.ts ./src/angular/index.ts ./src/testing/index.ts --outdir dist --target bun --external elysia --external react --external vue --external @angular/core --external @absolutejs/absolute && bun build ./src/client/htmxBootstrap.ts --outdir dist/client --target browser --format esm && tsc --emitDeclarationOnly --project tsconfig.json",
 		"format": "prettier --write \"./**/*.{js,jsx,ts,tsx,json,md}\"",
 		"lint": "eslint ./src",