autokap 1.2.0 → 1.3.2

package/dist/opcode-runner.js

@@ -52,12 +52,19 @@ export class NoOpRecoveryChain {
     }
 }
 const MIN_CLIP_FINALIZATION_TIMEOUT_MS = 30000;
+const DEFAULT_VIDEO_RECORDING_RESOLUTION = { width: 1920, height: 1080 };
 function resolveOpcodeTimeoutMs(opcode) {
     if (opcode.kind === 'END_CLIP') {
         return Math.max(opcode.timeoutMs, MIN_CLIP_FINALIZATION_TIMEOUT_MS);
     }
     return opcode.timeoutMs;
 }
+function resolveRecordingCaptureResolution(artifactPlan) {
+    if (artifactPlan.mediaMode === 'video') {
+        return DEFAULT_VIDEO_RECORDING_RESOLUTION;
+    }
+    return artifactPlan.format?.captureResolution;
+}
 // ── Main execution function ─────────────────────────────────────────
 export async function executeProgram(program, createAdapter, options = {}) {
     const recoveryChain = options.recoveryChain ?? new NoOpRecoveryChain();
@@ -65,6 +72,7 @@ export async function executeProgram(program, createAdapter, options = {}) {
     const startTime = Date.now();
     const variantResults = new Array(program.variants.length);
     const healerPatches = [];
+    const opcodeTimings = [];
     const telemetry = {
         llmCallCount: 0,
         llmCostEur: 0,
@@ -90,7 +98,7 @@ export async function executeProgram(program, createAdapter, options = {}) {
                 variantId: variant.id,
                 message: `starting variant ${variant.id}`,
             });
-            const variantResult = await executeVariant(program, variant, createAdapter, recoveryChain, telemetry, healerPatches, options);
+            const variantResult = await executeVariant(program, variant, createAdapter, recoveryChain, telemetry, healerPatches, opcodeTimings, options);
             variantResults[currentIndex] = variantResult;
             options.onProgress?.({
                 type: 'variant_end',
@@ -112,12 +120,13 @@ export async function executeProgram(program, createAdapter, options = {}) {
         variantResults: completedVariantResults,
         telemetry,
         healerPatches: success ? healerPatches : [], // Only propagate patches on success
+        opcodeTimings,
         totalDurationMs: Date.now() - startTime,
         error: aborted ? 'aborted' : (success ? undefined : completedVariantResults.find(v => !v.success)?.error),
     };
 }
 // ── Variant execution ───────────────────────────────────────────────
-async function executeVariant(program, variant, createAdapter, recoveryChain, telemetry, healerPatches, options) {
+async function executeVariant(program, variant, createAdapter, recoveryChain, telemetry, healerPatches, opcodeTimings, options) {
     const startTime = Date.now();
     const breaker = new CircuitBreaker();
     const verifier = new ActionVerifier();
@@ -165,7 +174,7 @@ async function executeVariant(program, variant, createAdapter, recoveryChain, te
                 opcodeKind: opcode.kind,
                 message: opcode.description,
             });
-            const result = await executeOpcode(opcode, i, adapter, verifier, breaker, recoveryChain, telemetry, healerPatches, artifacts, options, variant.id, executionState, program.artifactPlan, program.mockDataGroups, variant, program.preconditions.credentials);
+            const result = await executeOpcode(opcode, i, adapter, verifier, breaker, recoveryChain, telemetry, healerPatches, opcodeTimings, artifacts, options, variant.id, executionState, program.artifactPlan, program.mockDataGroups, variant, program.preconditions.credentials);
             opcodeResults.push(result);
             telemetry.totalOpcodes++;
             if (result.status === 'recovered')
@@ -241,7 +250,7 @@ function softSkipResult(opcode, index, startTime, reason, telemetry) {
         error: reason,
     };
 }
-async function executeOpcode(opcode, index, adapter, verifier, breaker, recoveryChain, telemetry, healerPatches, artifacts, options, variantId, executionState, artifactPlan, mockDataGroups, currentVariant, credentials) {
+async function executeOpcode(opcode, index, adapter, verifier, breaker, recoveryChain, telemetry, healerPatches, opcodeTimings, artifacts, options, variantId, executionState, artifactPlan, mockDataGroups, currentVariant, credentials) {
     const startTime = Date.now();
     const effectiveTimeoutMs = resolveOpcodeTimeoutMs(opcode);
     const deadlineMs = startTime + effectiveTimeoutMs;
@@ -267,17 +276,33 @@ async function executeOpcode(opcode, index, adapter, verifier, breaker, recovery
             logger.debug(`[opcode ${index}] no budget left after captureBeforeState (deadline=${deadlineMs}, now=${Date.now()})`);
             if (isSoft)
                 return softSkipResult(opcode, index, startTime, reason, telemetry);
-            return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, reason);
+            return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, executionState, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, reason);
         }
+        // For mediaMode='video', capture pre-action timing + bbox metadata inside
+        // the active clip window only. Opcodes outside a clip are not part of the
+        // video output.
+        const preTiming = await capturePreActionTiming(opcode, adapter, executionState.activeClip, artifactPlan);
         logger.debug(`[opcode ${index}] action exec start — actionBudget ${actionBudgetMs}ms`);
         const actionStart = Date.now();
         const result = await withTimeout(() => executeOpcodeAction(opcode, index, adapter, artifacts, telemetry, currentVariant, executionState, artifactPlan, mockDataGroups, options, credentials), actionBudgetMs);
         logger.debug(`[opcode ${index}] action exec end — took ${Date.now() - actionStart}ms, success=${result.success}${result.error ? `, error=${result.error}` : ''}`);
+        if (preTiming) {
+            opcodeTimings.push({
+                stepIndex: index,
+                stepId: opcode.stepId,
+                opcodeKind: opcode.kind,
+                variantId,
+                clipId: preTiming.clipId,
+                timecodeStartMs: preTiming.timecodeStartMs,
+                timecodeEndMs: Math.max(0, Date.now() - preTiming.clipStartedAt),
+                bbox: preTiming.bbox,
+            });
+        }
         if (!result.success) {
             const reason = result.error ?? 'action failed';
             if (isSoft)
                 return softSkipResult(opcode, index, startTime, reason, telemetry);
-            return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, reason);
+            return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, executionState, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, reason);
         }
         // Verify postcondition
         const postconditionBudgetMs = getRemainingTimeMs(deadlineMs);
@@ -286,7 +311,7 @@ async function executeOpcode(opcode, index, adapter, verifier, breaker, recovery
             logger.debug(`[opcode ${index}] no budget left for postcondition check`);
             if (isSoft)
                 return softSkipResult(opcode, index, startTime, reason, telemetry);
-            return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, reason);
+            return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, executionState, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, reason);
         }
         const postStart = Date.now();
         const postcondition = await evaluatePostcondition(adapter, withClampedPostconditionTimeout(opcode.postcondition, postconditionBudgetMs));
@@ -295,13 +320,13 @@ async function executeOpcode(opcode, index, adapter, verifier, breaker, recovery
             const reason = `postcondition failed: ${postcondition.reason}`;
             if (isSoft)
                 return softSkipResult(opcode, index, startTime, reason, telemetry);
-            return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, reason);
+            return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, executionState, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, reason);
         }
         // Verify action had effect (for interaction opcodes)
         if (isInteraction) {
             const verification = await verifier.verifyAfterAction(adapter);
             if (!verification.hadEffect && opcode.postcondition.type !== 'always' && opcode.postcondition.type !== 'any_change') {
-                return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, `action had no effect: ${verification.summary}`);
+                return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, executionState, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, `action had no effect: ${verification.summary}`);
             }
         }
         // Record successful mock data application
@@ -310,6 +335,17 @@ async function executeOpcode(opcode, index, adapter, verifier, breaker, recovery
                 telemetry.mockDataGroupResults = {};
             telemetry.mockDataGroupResults[opcode.groupName] = 'applied';
         }
+        // AUT-57 — for `mediaMode='video'`, every visible interaction (CLICK,
+        // SCROLL, NAVIGATE, etc.) gets a deterministic post-action settle. This
+        // gives the page time to finish smooth-scroll / route transitions /
+        // animations BEFORE the next opcode starts (typically a SLEEP narration
+        // anchor). The recorded video then has a natural breath after each
+        // action and the voice always lands on a settled visual.
+        if (artifactPlan.mediaMode === 'video'
+            && executionState.activeClip
+            && isVideoVisibleInteraction(opcode)) {
+            await sleep(VIDEO_POST_ACTION_SETTLE_MS);
+        }
         breaker.recordSuccess(index);
         return {
             opcodeIndex: index,
@@ -323,11 +359,33 @@ async function executeOpcode(opcode, index, adapter, verifier, breaker, recovery
         const errorMsg = err instanceof Error ? err.message : String(err);
         if (isSoft)
             return softSkipResult(opcode, index, startTime, errorMsg, telemetry);
-        return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, errorMsg);
+        return handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, executionState, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, errorMsg);
     }
 }
+/** Post-action breathing room (ms) injected between visible interactions
+ * inside a `mediaMode='video'` clip. See `executeOpcode` for context. */
+const VIDEO_POST_ACTION_SETTLE_MS = 500;
+const DEFAULT_VIDEO_CLIP_ID = 'main';
+const VIDEO_VISIBLE_INTERACTIONS = new Set([
+    'NAVIGATE',
+    'CLICK',
+    'DOUBLE_CLICK',
+    'TYPE',
+    'HOVER',
+    'SCROLL',
+    'PRESS_KEY',
+    'DRAG',
+    'SELECT_OPTION',
+    'CHECK',
+]);
+function isVideoVisibleInteraction(opcode) {
+    return VIDEO_VISIBLE_INTERACTIONS.has(opcode.kind);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 // ── Failure handling with recovery ──────────────────────────────────
-async function handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, errorMsg) {
+async function handleFailure(opcode, index, adapter, verifier, isInteraction, breaker, recoveryChain, telemetry, healerPatches, options, executionState, variantId, currentVariant, startTime, deadlineMs, effectiveTimeoutMs, errorMsg) {
     const breakerState = breaker.recordFailure(index, opcode.maxFailures);
     if (breakerState.tripped) {
         telemetry.circuitBreakerTrips++;
@@ -363,6 +421,8 @@ async function handleFailure(opcode, index, adapter, verifier, isInteraction, br
         remainingTimeMs,
         maxDeterministicRetries: Math.max(0, opcode.maxFailures - breakerState.opcodeFailures),
         currentVariant,
+        allowPageReload: !executionState.activeClip,
+        suppressPageReloads: Boolean(executionState.activeClip),
     });
     if (recovery.llmResult) {
         telemetry.llmCallCount++;
@@ -423,6 +483,7 @@ async function executeOpcodeAction(opcode, opcodeIndex, adapter, artifacts, tele
             case 'TYPE':
             case 'PRESS_KEY':
             case 'WAIT_FOR':
+            case 'SLEEP':
             case 'SET_LOCALE':
             case 'SET_THEME':
             case 'SCROLL':
@@ -435,7 +496,12 @@ async function executeOpcodeAction(opcode, opcodeIndex, adapter, artifacts, tele
             case 'INJECT_MOCK_DATA':
             case 'REMOVE_ELEMENT':
             case 'SET_ATTRIBUTE':
-                return executeOpcodeCoreAction(opcode, adapter, { currentVariant, mockDataGroups, credentials });
+                return executeOpcodeCoreAction(opcode, adapter, {
+                    currentVariant,
+                    mockDataGroups,
+                    credentials,
+                    suppressPageReloads: Boolean(executionState.activeClip),
+                });
             case 'ASSERT_ROUTE':
                 return evaluateImmediateAssertion(await evaluatePostcondition(adapter, {
                     type: 'route_matches',
@@ -555,22 +621,33 @@ async function executeOpcodeAction(opcode, opcodeIndex, adapter, artifacts, tele
                 });
                 break;
             }
-            case 'BEGIN_CLIP':
+            case 'BEGIN_CLIP': {
                 if (executionState.activeClip) {
                     return { success: false, error: 'cannot start a new clip before the previous one ends' };
                 }
+                const recordingMode = artifactPlan.mediaMode === 'video' ? 'video' : 'clip';
                 executionState.activeClip = {
-                    clipId: opcode.clipId,
+                    clipId: opcode.clipId ?? (recordingMode === 'video' ? DEFAULT_VIDEO_CLIP_ID : undefined),
                     clipName: opcode.clipName,
+                    startedAt: Date.now(),
                 };
-                await adapter.beginRecording({ mediaMode: 'clip' });
+                await adapter.beginRecording({
+                    mediaMode: recordingMode,
+                    captureResolution: resolveRecordingCaptureResolution(artifactPlan),
+                    captureFps: artifactPlan.format?.captureFps,
+                });
                 break;
+            }
             case 'END_CLIP': {
                 const clipIdentity = resolveClipIdentity(executionState.activeClip, opcode);
                 const recording = await adapter.endRecording();
                 executionState.activeClip = undefined;
+                // Match the artifact's mediaMode to the program's so the upload route
+                // routes opcode-video clips to the AUT-57 storage path
+                // (`raw/{videoId}/{clipId}.mp4`) instead of the legacy clip flow.
+                const artifactMediaMode = artifactPlan.mediaMode === 'video' ? 'video' : 'clip';
                 artifacts.push({
-                    mediaMode: 'clip',
+                    mediaMode: artifactMediaMode,
                     buffer: recording.buffer,
                     mimeType: recording.mimeType,
                     durationMs: recording.durationMs,
@@ -600,7 +677,52 @@ async function executeOpcodeAction(opcode, opcodeIndex, adapter, artifacts, tele
         };
     }
 }
-// ── Helpers ─────────────────────────────────────────────────────────
+/**
+ * Snapshot per-opcode timing + element bbox before the action runs. Returns
+ * null when no timing should be emitted (mediaMode != video, or no active
+ * clip context). The bbox is only resolved for visible interaction opcodes
+ * (CLICK / DOUBLE_CLICK / TYPE / HOVER) — other opcodes record `bbox: null`.
+ */
+async function capturePreActionTiming(opcode, adapter, activeClip, artifactPlan) {
+    if (artifactPlan.mediaMode !== 'video')
+        return null;
+    if (!activeClip || activeClip.startedAt === undefined)
+        return null;
+    const now = Date.now();
+    const timecodeStartMs = Math.max(0, now - activeClip.startedAt);
+    let bbox = null;
+    const selector = getZoomTargetSelector(opcode);
+    if (selector && adapter.getElementBoundingBox) {
+        try {
+            bbox = await adapter.getElementBoundingBox(selector);
+        }
+        catch {
+            bbox = null;
+        }
+    }
+    return {
+        clipId: activeClip.clipId,
+        clipStartedAt: activeClip.startedAt,
+        timecodeStartMs,
+        bbox,
+    };
+}
+/**
+ * Selector to anchor video timing metadata on, or undefined if the opcode has
+ * no meaningful visible target. Limited to interaction opcodes that the user's
+ * eye tracks during a video demo.
+ */
+function getZoomTargetSelector(opcode) {
+    switch (opcode.kind) {
+        case 'CLICK':
+        case 'DOUBLE_CLICK':
+        case 'TYPE':
+        case 'HOVER':
+            return opcode.selector;
+        default:
+            return undefined;
+    }
+}
 async function withTimeout(fn, timeoutMs) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => reject(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);

package/dist/openrouter-tts.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Output formats accepted by OpenRouter's `/audio/speech` endpoint
+ * (April 2026 docs). Only `mp3` and `pcm` are supported — narrower than
+ * OpenAI's direct API which also exposes opus/aac/flac/wav.
+ */
+export type TtsResponseFormat = 'mp3' | 'pcm';
+export interface TtsClientConfig {
+    apiKey: string;
+    /** Override base URL — useful for tests or pointing at OpenAI directly. Default: OpenRouter. */
+    baseUrl?: string;
+    /** Default model for this client. Default: `openai/gpt-4o-mini-tts`. */
+    defaultModel?: string;
+    /** Per-request timeout. Default: 30s. */
+    timeoutMs?: number;
+    /** Number of retry attempts on transient HTTP failures (5xx, network). Default: 2. */
+    maxRetries?: number;
+}
+export interface TtsRequest {
+    /** Text to synthesize. The provider rejects empty strings; keep chunks under ~4k chars. */
+    text: string;
+    /** Voice handle, e.g. 'nova', 'alloy', 'echo'. Provider-specific. */
+    voice: string;
+    /** Optional model override. Defaults to client.defaultModel. */
+    model?: string;
+    /** Output container/codec. Default: 'mp3'. */
+    format?: TtsResponseFormat;
+    /** Speaking-rate multiplier (0.25..4.0). Provider may clamp. Default: 1.0. */
+    speed?: number;
+    /** Optional abort signal for cancellation. */
+    signal?: AbortSignal;
+}
+export interface TtsResponse {
+    /** Raw audio bytes in the requested format. */
+    audioBuffer: Buffer;
+    /** Mime type matching the requested format. */
+    mimeType: string;
+    /** Audio duration in ms, measured via ffprobe on the produced buffer. */
+    durationMs: number;
+    /** Effective model used. */
+    model: string;
+    /** Voice used. */
+    voice: string;
+}
+export declare class TtsError extends Error {
+    readonly status?: number | undefined;
+    readonly providerBody?: string | undefined;
+    constructor(message: string, status?: number | undefined, providerBody?: string | undefined);
+}
+/**
+ * POST a single TTS chunk to the configured provider, retry on 5xx / network
+ * errors up to `maxRetries`, then probe the resulting buffer for duration.
+ *
+ * Throws `TtsError` (with HTTP status when available) on permanent failure.
+ */
+export declare function generateTtsChunk(config: TtsClientConfig, request: TtsRequest): Promise<TtsResponse>;
+/**
+ * Mutable indirection used by `generateTtsChunk` to find its dependencies.
+ * Tests reach into this object to swap `probeAudioDurationMs` for a fake
+ * (ESM exports are immutable bindings, so a plain `vi.spyOn` on the named
+ * export does not affect the in-module reference).
+ */
+export declare const ttsTestHooks: {
+    probeAudioDurationMs: (audioBuffer: Buffer, format: TtsResponseFormat) => Promise<number>;
+};
+/**
+ * Write the buffer to a tempfile, run ffprobe to get the format duration,
+ * clean up. Errors propagate (caller can wrap as TtsError if needed).
+ *
+ * Exported under both the legacy name (`probeAudioDurationMs`) and via the
+ * `ttsTestHooks` indirection so unit tests can override it.
+ */
+export declare const probeAudioDurationMs: typeof defaultProbeAudioDurationMs;
+declare function defaultProbeAudioDurationMs(audioBuffer: Buffer, format: TtsResponseFormat): Promise<number>;
+export {};

package/dist/openrouter-tts.js

@@ -0,0 +1,218 @@
+/**
+ * AUT-57 — OpenRouter TTS client.
+ *
+ * Posts a single chunk of narration text to OpenRouter's `/audio/speech`
+ * endpoint (mirrors the OpenAI shape) and returns the audio buffer + measured
+ * duration. Word-level timestamps are NOT returned by this provider; the
+ * caller derives per-word timings separately for animated subtitles.
+ *
+ * The default model is `openai/gpt-4o-mini-tts` (chosen in the AUT-57 plan as
+ * the V1 baseline — good EN voices, OpenRouter-billed). Override via the
+ * caller if a benchmark identifies a better trade-off.
+ *
+ * **Pure module** — no Node-only imports beyond `node:fs` / `node:os` /
+ * `node:path` / `node:child_process` (used only for duration probing). Safe
+ * to import from both the CLI and the Next.js server runtime.
+ */
+import { execFile } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
+/**
+ * Default TTS model. Matches the exact slug listed under
+ * `GET /models?output_modalities=speech` (April 2026):
+ *   - openai/gpt-4o-mini-tts-2025-12-15
+ *   - mistralai/voxtral-mini-tts-2603
+ *   - google/gemini-3.1-flash-tts-preview
+ *   - hexgrad/kokoro-82m, sesame/csm-1b, zyphra/zonos-*, canopylabs/orpheus-*
+ *
+ * gpt-4o-mini-tts ranks well on EN voice quality and is the AUT-57 baseline.
+ * The PR #3 spec explicitly calls it out — pivot per benchmark in PR #4 if
+ * a cheaper / better fit emerges.
+ */
+const DEFAULT_TTS_MODEL = 'openai/gpt-4o-mini-tts-2025-12-15';
+const DEFAULT_RESPONSE_FORMAT = 'mp3';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_RETRIES = 2;
+const FORMAT_MIME_TYPES = {
+    mp3: 'audio/mpeg',
+    pcm: 'audio/pcm',
+};
+const FORMAT_FILE_EXTENSIONS = {
+    mp3: 'mp3',
+    pcm: 'pcm',
+};
+export class TtsError extends Error {
+    status;
+    providerBody;
+    constructor(message, status, providerBody) {
+        super(message);
+        this.status = status;
+        this.providerBody = providerBody;
+        this.name = 'TtsError';
+    }
+}
+/**
+ * POST a single TTS chunk to the configured provider, retry on 5xx / network
+ * errors up to `maxRetries`, then probe the resulting buffer for duration.
+ *
+ * Throws `TtsError` (with HTTP status when available) on permanent failure.
+ */
+export async function generateTtsChunk(config, request) {
+    if (!request.text.trim()) {
+        throw new TtsError('TTS request rejected: empty text');
+    }
+    const baseUrl = config.baseUrl ?? OPENROUTER_BASE_URL;
+    const model = request.model ?? config.defaultModel ?? DEFAULT_TTS_MODEL;
+    const format = request.format ?? DEFAULT_RESPONSE_FORMAT;
+    const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxRetries = Math.max(0, config.maxRetries ?? DEFAULT_MAX_RETRIES);
+    const audioBuffer = await fetchAudioWithRetry({
+        baseUrl,
+        apiKey: config.apiKey,
+        model,
+        voice: request.voice,
+        text: request.text,
+        format,
+        speed: request.speed,
+        timeoutMs,
+        maxRetries,
+        abortSignal: request.signal,
+    });
+    const durationMs = await ttsTestHooks.probeAudioDurationMs(audioBuffer, format);
+    return {
+        audioBuffer,
+        mimeType: FORMAT_MIME_TYPES[format],
+        durationMs,
+        model,
+        voice: request.voice,
+    };
+}
+async function fetchAudioWithRetry(params) {
+    let lastErr = null;
+    for (let attempt = 0; attempt <= params.maxRetries; attempt++) {
+        try {
+            return await fetchAudio(params);
+        }
+        catch (err) {
+            lastErr = err;
+            if (err instanceof TtsError && err.status && err.status < 500 && err.status !== 429) {
+                // 4xx (other than 429) is permanent — don't retry.
+                throw err;
+            }
+            if (attempt < params.maxRetries) {
+                await sleep(backoffMs(attempt));
+                continue;
+            }
+        }
+    }
+    if (lastErr instanceof Error)
+        throw lastErr;
+    throw new TtsError('TTS request failed after retries');
+}
+async function fetchAudio(params) {
+    const url = `${params.baseUrl.replace(/\/$/, '')}/audio/speech`;
+    const controller = new AbortController();
+    const timeoutHandle = setTimeout(() => controller.abort(), params.timeoutMs);
+    // If caller passed an external signal, abort our internal controller too.
+    const externalAbort = () => controller.abort();
+    if (params.abortSignal) {
+        if (params.abortSignal.aborted)
+            controller.abort();
+        else
+            params.abortSignal.addEventListener('abort', externalAbort, { once: true });
+    }
+    try {
+        const body = {
+            model: params.model,
+            input: params.text,
+            voice: params.voice,
+            response_format: params.format,
+        };
+        if (typeof params.speed === 'number' && Number.isFinite(params.speed)) {
+            body.speed = params.speed;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${params.apiKey}`,
+                'Content-Type': 'application/json',
+                Accept: FORMAT_MIME_TYPES[params.format],
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const text = await safeReadBody(response);
+            throw new TtsError(`TTS request failed: ${response.status} ${response.statusText}`, response.status, text);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        if (arrayBuffer.byteLength === 0) {
+            throw new TtsError('TTS provider returned empty body');
+        }
+        return Buffer.from(arrayBuffer);
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+        if (params.abortSignal) {
+            params.abortSignal.removeEventListener('abort', externalAbort);
+        }
+    }
+}
+async function safeReadBody(response) {
+    try {
+        return (await response.text()).slice(0, 2000);
+    }
+    catch {
+        return undefined;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoffMs(attempt) {
+    // 250ms, 500ms, 1s, ... capped at 5s.
+    return Math.min(5000, 250 * Math.pow(2, attempt));
+}
+/**
+ * Mutable indirection used by `generateTtsChunk` to find its dependencies.
+ * Tests reach into this object to swap `probeAudioDurationMs` for a fake
+ * (ESM exports are immutable bindings, so a plain `vi.spyOn` on the named
+ * export does not affect the in-module reference).
+ */
+export const ttsTestHooks = {
+    probeAudioDurationMs: defaultProbeAudioDurationMs,
+};
+/**
+ * Write the buffer to a tempfile, run ffprobe to get the format duration,
+ * clean up. Errors propagate (caller can wrap as TtsError if needed).
+ *
+ * Exported under both the legacy name (`probeAudioDurationMs`) and via the
+ * `ttsTestHooks` indirection so unit tests can override it.
+ */
+export const probeAudioDurationMs = defaultProbeAudioDurationMs;
+async function defaultProbeAudioDurationMs(audioBuffer, format) {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'autokap-tts-'));
+    const audioPath = path.join(tmpDir, `chunk.${FORMAT_FILE_EXTENSIONS[format]}`);
+    try {
+        await fs.writeFile(audioPath, audioBuffer);
+        const { stdout } = await execFileAsync('ffprobe', [
+            '-v', 'error',
+            '-show_entries', 'format=duration',
+            '-of', 'default=noprint_wrappers=1:nokey=1',
+            audioPath,
+        ]);
+        const seconds = parseFloat(stdout.trim());
+        if (!Number.isFinite(seconds) || seconds <= 0) {
+            throw new TtsError(`ffprobe could not measure audio duration (got "${stdout.trim()}")`);
+        }
+        return Math.round(seconds * 1000);
+    }
+    finally {
+        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+//# sourceMappingURL=openrouter-tts.js.map

package/dist/postcondition.js

@@ -60,32 +60,7 @@ async function checkRouteMatches(adapter, pattern) {
     try {
         const { pathname, search } = new URL(url);
         const fullPath = pathname + search;
-        // Support glob-like patterns: ** matches anything (incl. slashes / empty),
-        // * matches a single path segment, ? matches one non-slash char.
-        // Tokenize in one pass so the `*` rewrite doesn't clobber the `*` produced
-        // by the `**` rewrite (e.g. `/home**` must compile to `^/home.*$`, not
-        // `^/home.[^/]*$` which would reject `/home` itself).
-        let regexStr = '';
-        for (let i = 0; i < pattern.length; i++) {
-            const ch = pattern[i];
-            if (ch === '*' && pattern[i + 1] === '*') {
-                regexStr += '.*';
-                i++;
-            }
-            else if (ch === '*') {
-                regexStr += '[^/]*';
-            }
-            else if (ch === '?') {
-                regexStr += '[^/]';
-            }
-            else if (/[.+^${}()|[\]\\]/.test(ch)) {
-                regexStr += `\\${ch}`;
-            }
-            else {
-                regexStr += ch;
-            }
-        }
-        const regex = new RegExp(`^${regexStr}$`);
+        const regex = compileRoutePattern(pattern);
         if (regex.test(fullPath) || regex.test(pathname)) {
             return { passed: true, reason: `URL "${fullPath}" matches pattern "${pattern}"` };
         }
@@ -95,6 +70,41 @@ async function checkRouteMatches(adapter, pattern) {
         return { passed: false, reason: `invalid URL "${url}" or pattern "${pattern}"` };
     }
 }
+function compileRoutePattern(pattern) {
+    // `route_matches` historically used glob syntax, but generated programs and
+    // ASSERT_ROUTE docs may provide anchored regexes such as `^/$`. Treat only
+    // anchored patterns as raw regex to avoid changing common globs like
+    // `/pricing*`.
+    if (pattern.startsWith('^') || pattern.endsWith('$')) {
+        return new RegExp(pattern);
+    }
+    // Support glob-like patterns: ** matches anything (incl. slashes / empty),
+    // * matches a single path segment, ? matches one non-slash char.
+    // Tokenize in one pass so the `*` rewrite doesn't clobber the `*` produced
+    // by the `**` rewrite (e.g. `/home**` must compile to `^/home.*$`, not
+    // `^/home.[^/]*$` which would reject `/home` itself).
+    let regexStr = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '*' && pattern[i + 1] === '*') {
+            regexStr += '.*';
+            i++;
+        }
+        else if (ch === '*') {
+            regexStr += '[^/]*';
+        }
+        else if (ch === '?') {
+            regexStr += '[^/]';
+        }
+        else if (/[.+^${}()|[\]\\]/.test(ch)) {
+            regexStr += `\\${ch}`;
+        }
+        else {
+            regexStr += ch;
+        }
+    }
+    return new RegExp(`^${regexStr}$`);
+}
 async function checkElementVisible(adapter, selector) {
     // Primary check: use Playwright waitFor (fast, reliable)
     try {