label: string;

match: (message: WhatsAppQaDriverObservedMessage) => boolean;

}>;

expectedSender?: (message: WhatsAppQaDriverObservedMessage) => boolean;

match: (message: WhatsAppQaDriverObservedMessage) => boolean;

observedAfter?: Date;

timeoutMs?: number;

observedAfter: params.observedAfter,

timeoutMs: params.timeoutMs ?? 45_000,

match: (candidate) =>

candidate.fromPhoneE164 === context.sutPhoneE164 && params.match(candidate),

(params.expectedSender?.(candidate) ?? candidate.fromPhoneE164 === context.sutPhoneE164) &&

params.match(candidate),

});

} catch (error) {

if (/\btimed out waiting for WhatsApp QA driver message\b/iu.test(formatErrorMessage(error))) {

sutAuthDir: string;

sutPhoneE164: string;

groupJid?: string;

onGatewayDebugPreserveFailure?: (error: unknown) => void;

onGatewayDebugPreserved?: () => void;

}): Promise<WhatsAppQaScenarioResult> {

const scenarioRun = params.scenario.buildRun();

if (scenarioRun.kind !== "approval" && scenarioRun.target === "group" && !params.groupJid) {

details: "no reply",

};

}

const reply = await params.driver.waitForMessage({

const reply = await waitForScenarioObservedMessage(scenarioContext, {

observedAfter: requestStartedAt,

timeoutMs: params.scenario.timeoutMs,

match: (message) =>

(scenarioRun.target === "group"

expectedSender: (message) =>

scenarioRun.target === "group"

? message.fromJid === params.groupJid

: message.fromPhoneE164 === params.sutPhoneE164) &&

messageMatches(message as WhatsAppObservedMessage, scenarioRun.matchText),

: message.fromPhoneE164 === params.sutPhoneE164,

match: (message) => messageMatches(message as WhatsAppObservedMessage, scenarioRun.matchText),

});

const observed: WhatsAppObservedMessage = {

...reply,

matchedScenario: true,

scenarioId: params.scenario.id,

scenarioTitle: params.scenario.title,

};

scenarioRun.verify?.(reply, scenarioContext);

params.observedMessages.push(observed);

const afterReplyDetails = await scenarioRun.afterReply?.(reply, scenarioContext);

const batchDetails = await assertWhatsAppScenarioMessageBatch({

alreadyRecordedMessageIds: new Set(observed.messageId ? [observed.messageId] : []),

alreadyRecordedMessageIds: new Set(reply.messageId ? [reply.messageId] : []),

context: scenarioContext,

observedAfter: requestStartedAt,

run: scenarioRun,

},

};

} catch (error) {

preservedGatewayDebug = true;

await gatewayHarness.stop({ preserveToDir: params.gatewayDebugDirPath }).catch(() => {});

try {

await gatewayHarness.stop({ preserveToDir: params.gatewayDebugDirPath });

preservedGatewayDebug = true;

params.onGatewayDebugPreserved?.();

} catch (preserveError) {

params.onGatewayDebugPreserveFailure?.(preserveError);

}

throw error;

} finally {

if (!preservedGatewayDebug) {

}

let driverAttempt = 1;

while (true) {

let scenarioGatewayDebugPreserved = false;

const scenarioGatewayDebugPreserveFailures: unknown[] = [];

try {

const result = await runWhatsAppScenario({

driver: activeDriver,

sutAccountId,

sutAuthDir,

sutPhoneE164: runtimeEnv.sutPhoneE164,

onGatewayDebugPreserved: () => {

scenarioGatewayDebugPreserved = true;

},

onGatewayDebugPreserveFailure: (error) => {

scenarioGatewayDebugPreserveFailures.push(error);

},

});

const recordedResult =

driverAttempt > 1

closeDriverSession = () => activeDriver.close();

continue;

}

preservedGatewayDebugArtifacts = true;

if (scenarioGatewayDebugPreserved) {

preservedGatewayDebugArtifacts = true;

}

for (const preserveError of scenarioGatewayDebugPreserveFailures) {

appendLiveLaneIssue(cleanupIssues, "gateway debug preserve failed", preserveError);

}

const result: WhatsAppQaScenarioResult = {

id: scenario.id,

title: scenario.title,

parseWhatsAppQaCredentialPayload,

renderWhatsAppQaMarkdown,

runWhatsAppStructuredInboundChecks,

waitForScenarioObservedMessage,

redactWhatsAppQaScenarioResults,

resolveWhatsAppQaMessageTargets,

resolveWhatsAppQaRuntimeEnv,