@mindscraft/branch-video-agent-cli 0.4.6 → 0.5.0

package/dist/playtest/runner.js

@@ -11,24 +11,31 @@ function locatorFor(frame, spec) {
         return frame.getByTestId(spec.testId);
     return frame.locator(spec.selector);
 }
-async function runWebStep(frame, step) {
+function remainingBudget(deadline) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0)
+        throw new PlaytestError('SCENARIO_TIMEOUT', 'Scenario deadline elapsed');
+    return remaining;
+}
+async function runWebStep(frame, step, deadline) {
     const locator = locatorFor(frame, step.locator);
+    const timeout = remainingBudget(deadline);
     if (step.action === 'click')
-        await locator.click();
+        await locator.click({ timeout });
     else if (step.action === 'fill')
-        await locator.fill(step.value);
+        await locator.fill(step.value, { timeout });
     else if (step.action === 'selectOption')
-        await locator.selectOption(step.value);
+        await locator.selectOption(step.value, { timeout });
     else if (step.action === 'check')
-        await locator.setChecked(step.checked ?? true);
+        await locator.setChecked(step.checked ?? true, { timeout });
     else if (step.action === 'press')
-        await locator.press(step.key);
+        await locator.press(step.key, { timeout });
     else if (step.action === 'dragTo')
-        await locator.dragTo(locatorFor(frame, step.target));
+        await locator.dragTo(locatorFor(frame, step.target), { timeout });
     else if (step.action === 'setInputFiles')
-        await locator.setInputFiles(step.files);
+        await locator.setInputFiles(step.files, { timeout });
     else
-        await locator.waitFor({ state: step.state ?? 'visible', timeout: step.timeoutMs });
+        await locator.waitFor({ state: step.state ?? 'visible', timeout: step.timeoutMs && step.timeoutMs > 0 ? Math.min(step.timeoutMs, timeout) : timeout });
 }
 function appendInstrumentationQuery(rawUrl) {
     const url = new URL(rawUrl);
@@ -153,42 +160,74 @@ export async function startPlayback(frame, entryNodeId, entryNodeType, timeout)
         }
     }
 }
-async function assertNodeMedia(frame, node) {
-    if (node.type === 'video') {
-        const video = frame.locator('video').first();
-        await video.waitFor({ state: 'visible' });
-        const state = await video.evaluate(async (element) => {
-            if (element.readyState < 1) {
-                await new Promise((resolve, reject) => {
-                    const timer = globalThis.setTimeout(() => reject(new Error('loadedmetadata timeout')), 10000);
-                    element.addEventListener('loadedmetadata', () => { globalThis.clearTimeout(timer); resolve(); }, { once: true });
-                    element.addEventListener('error', () => { globalThis.clearTimeout(timer); reject(new Error('video error')); }, { once: true });
-                });
-            }
-            const before = element.currentTime;
-            await element.play().catch(() => undefined);
-            await new Promise((resolve) => globalThis.setTimeout(resolve, 200));
-            return { readyState: element.readyState, duration: element.duration, progressed: element.currentTime > before };
-        });
-        if (state.readyState < 1 || !Number.isFinite(state.duration)) {
-            throw new PlaytestError('MEDIA_LOAD_FAILED', `Video media failed on node ${node.id}`, state);
-        }
-    }
-    if (node.type === 'image') {
-        const image = frame.locator('img').filter({ visible: true }).first();
-        await image.waitFor({ state: 'visible' });
-        const loaded = await image.evaluate((element) => element.complete && element.naturalWidth > 0);
-        if (!loaded)
-            throw new PlaytestError('MEDIA_LOAD_FAILED', `Image media failed on node ${node.id}`);
+function mainMedia(frame, node) {
+    return frame.locator(`[data-bv-media-role="main"][data-bv-media-node-id=${JSON.stringify(node.id)}]`);
+}
+export async function assertNodeMedia(frame, node, deadline) {
+    if (node.type === 'video' || node.type === 'image') {
+        const media = mainMedia(frame, node);
+        await media.waitFor({ state: 'visible', timeout: remainingBudget(deadline) });
+        const element = await media.elementHandle({ timeout: remainingBudget(deadline) });
+        if (!element)
+            throw new PlaytestError('NODE_MEDIA_CHANGED', `Main media disappeared on ${node.id}`);
+        const state = await element.evaluate(async (element, input) => {
+            const end = Date.now() + input.timeout;
+            const source = element.src;
+            do {
+                const current = globalThis.document.querySelector('[data-bv-node-id]')?.getAttribute('data-bv-node-id');
+                if (!element.isConnected || current !== input.nodeId || element.src !== source
+                    || element.getAttribute('data-bv-media-node-id') !== input.nodeId)
+                    return { status: 'changed', current };
+                if (input.type === 'image') {
+                    if (element.complete)
+                        return { status: element.naturalWidth > 0 ? 'loaded' : 'error', source };
+                }
+                else {
+                    if (element.error)
+                        return { status: 'error', error: element.error.code };
+                    if (element.readyState >= 2 && Number.isFinite(element.duration) && element.currentSrc === source)
+                        return { status: 'loaded', source };
+                }
+                await new Promise(resolve => globalThis.setTimeout(resolve, Math.min(50, Math.max(1, end - Date.now()))));
+            } while (Date.now() < end);
+            return { status: 'timeout', readyState: element.readyState, source };
+        }, { nodeId: node.id, type: node.type, timeout: remainingBudget(deadline) });
+        if (state.status === 'changed')
+            throw new PlaytestError('NODE_MEDIA_CHANGED', `Node or media source changed while loading ${node.id}`, state);
+        if (state.status !== 'loaded')
+            throw new PlaytestError('MEDIA_LOAD_FAILED', `Main ${node.type} media failed on node ${node.id}`, state);
+        return { element, source: state.source, nodeId: node.id };
     }
     if (node.type === 'web') {
-        await frame.locator('iframe[title="Web 页面"]').waitFor({ state: 'visible' });
+        await frame.locator('iframe[title="Web 页面"]').waitFor({ state: 'visible', timeout: remainingBudget(deadline) });
     }
 }
+export async function driveVerifiedVideo(media, trigger, time) {
+    if (!media)
+        throw new PlaytestError('NODE_MEDIA_CHANGED', 'Video was not verified before driving it');
+    const valid = await media.element.evaluate((element, input) => {
+        const current = globalThis.document.querySelector('[data-bv-node-id]')?.getAttribute('data-bv-node-id');
+        if (!element.isConnected || current !== input.nodeId || element.getAttribute('data-bv-media-node-id') !== input.nodeId
+            || element.src !== input.source || element.currentSrc !== input.source || element.readyState < 2 || element.error
+            || !Number.isFinite(element.duration))
+            return false;
+        if (input.trigger === 'time')
+            element.currentTime = Number(input.time) + 0.05;
+        else if (input.trigger === 'complete' && element.duration > 0)
+            element.currentTime = Math.max(0, element.duration - 0.01);
+        if (input.trigger !== 'complete-interaction')
+            element.dispatchEvent(new globalThis.Event('timeupdate', { bubbles: true }));
+        if (input.trigger !== 'time')
+            element.dispatchEvent(new globalThis.Event('ended', { bubbles: true }));
+        return true;
+    }, { source: media.source, nodeId: media.nodeId, trigger, time });
+    if (!valid)
+        throw new PlaytestError('NODE_MEDIA_CHANGED', `Verified video changed before driving ${media.nodeId}`);
+}
 async function readObservedMessages(frame) {
     return frame.evaluate(() => globalThis.__bvPlaytestObservedMessages || []).catch(() => []);
 }
-async function executeWebEdge(frame, node, edge, contract) {
+export async function executeWebEdge(frame, node, edge, contract, deadline) {
     const explicitRoutes = new Set((node.branchConfig?.rules || [])
         .filter((rule) => rule.trigger?.type === 'message')
         .map((rule) => String(rule.trigger.value)));
@@ -197,19 +236,44 @@ async function executeWebEdge(frame, node, edge, contract) {
         : contract.webResults.find((candidate) => candidate.nodeId === edge.from && !explicitRoutes.has(candidate.routeValue));
     if (!recipe)
         throw new PlaytestError('WEB_PLAYTEST_RECIPE_MISSING', `No recipe for ${edge.from}:${String(edge.trigger.value)}`);
-    const webFrame = frame.childFrames().find((candidate) => candidate.url() !== 'about:blank');
+    const handle = await frame.locator('iframe[title="Web 页面"]').elementHandle({ timeout: remainingBudget(deadline) });
+    const webFrame = await handle?.contentFrame();
     if (!webFrame)
         throw new PlaytestError('WEB_FRAME_LOAD_FAILED', `Web iframe did not load on node ${edge.from}`);
+    const sourceId = await handle.evaluate((element) => {
+        const browserWindow = globalThis;
+        browserWindow.__bvPlaytestWebSources ||= new WeakMap();
+        const id = (browserWindow.__bvPlaytestWebSourceSequence || 0) + 1;
+        browserWindow.__bvPlaytestWebSourceSequence = id;
+        browserWindow.__bvPlaytestWebSources.set(element.contentWindow, id);
+        return id;
+    });
     const before = (await readObservedMessages(frame)).length;
-    for (const step of recipe.steps)
-        await runWebStep(webFrame, step);
+    for (let index = 0; index < recipe.steps.length; index += 1) {
+        const step = recipe.steps[index];
+        try {
+            await runWebStep(webFrame, step, deadline);
+        }
+        catch (error) {
+            // A final passive wait may lose its iframe when the real result navigates.
+            // Missing actions, wrong/stale messages and unrelated detach remain failures.
+            const message = error instanceof Error ? error.message : String(error);
+            const emitted = (await readObservedMessages(frame)).slice(before);
+            if (!(index === recipe.steps.length - 1 && step.action === 'waitFor'
+                && /frame.*detach/i.test(message) && webFrame.isDetached()
+                && emitted.some(entry => entry.sourceId === sourceId && matchesRawMessage(entry, recipe.rawMessage))))
+                throw error;
+        }
+    }
     try {
         await frame.waitForFunction((payload) => {
-            const { start, rawMessage } = payload;
+            const { start, rawMessage, sourceId } = payload;
             const messages = (globalThis.__bvPlaytestObservedMessages || []).slice(start);
             const expectedEvent = rawMessage.eventName;
             const expectedValue = rawMessage.value ?? rawMessage.data?.value ?? rawMessage.data;
             return messages.some((entry) => {
+                if (entry.sourceId !== sourceId)
+                    return false;
                 const actual = entry.data;
                 const eventName = actual?.eventName ?? actual?.type ?? actual?.event;
                 const value = actual?.value
@@ -223,14 +287,14 @@ async function executeWebEdge(frame, node, edge, contract) {
                 const comparableExpected = typeof expectedValue === 'string' || typeof expectedValue === 'number' ? String(expectedValue) : expectedValue;
                 return eventName === expectedEvent && JSON.stringify(comparableActual) === JSON.stringify(comparableExpected);
             });
-        }, { start: before, rawMessage: recipe.rawMessage }, { timeout: 10000 });
+        }, { start: before, rawMessage: recipe.rawMessage, sourceId }, { timeout: remainingBudget(deadline) });
     }
     catch {
         const observed = (await readObservedMessages(frame)).slice(before);
         throw new PlaytestError('WEB_MESSAGE_NOT_EMITTED', `Web actions did not emit the expected raw message for ${edge.from}:${recipe.routeValue}`, { observed });
     }
     const emitted = (await readObservedMessages(frame)).slice(before);
-    if (!emitted.some((message) => matchesRawMessage(message, recipe.rawMessage))) {
+    if (!emitted.some((message) => message.sourceId === sourceId && matchesRawMessage(message, recipe.rawMessage))) {
         throw new PlaytestError('WEB_MESSAGE_NOT_EMITTED', `Expected Web raw message was not recorded for ${edge.from}:${recipe.routeValue}`);
     }
 }
@@ -253,18 +317,18 @@ function chooseResultOption(interaction, result) {
     }
     return wrong.length ? [wrong[0]] : options.slice(-1).map((option) => String(option.id));
 }
-async function clickAction(frame, action) {
+async function clickAction(frame, action, deadline) {
     const control = frame.locator(`[data-bv-action="${action}"]`).first();
     const nestedButton = control.locator('button').first();
     if (await nestedButton.count())
-        await nestedButton.click();
+        await nestedButton.click({ timeout: remainingBudget(deadline) });
     else
-        await control.click();
+        await control.click({ timeout: remainingBudget(deadline) });
 }
 function normalizeSettlementResult(value) {
     return String(value ?? '').trim().toLowerCase();
 }
-async function executeScoreSettlement(frame, interaction, edge) {
+async function executeScoreSettlement(frame, interaction, edge, deadline) {
     const target = (edge.trigger.type === 'legacy' || edge.trigger.type === 'result')
         ? normalizeSettlementResult(edge.trigger.value) : '';
     if (!edge.default && !['score_s', 'score_a', 'score_b', 'default'].includes(target)) {
@@ -284,12 +348,12 @@ async function executeScoreSettlement(frame, interaction, edge) {
         if (matchedLegacy) {
             throw new PlaytestError('SETTLEMENT_DEFAULT_NOT_REACHED', `Score settlement result ${actual} has an explicit branch`);
         }
-        await clickAction(frame, 'confirm-settlement');
+        await clickAction(frame, 'confirm-settlement', deadline);
         return;
     }
     if (actual !== target)
         throw new PlaytestError('SETTLEMENT_RESULT_MISMATCH', `Score settlement result ${actual} does not match ${target}`, { actual, target });
-    await clickAction(frame, 'confirm-settlement');
+    await clickAction(frame, 'confirm-settlement', deadline);
 }
 export async function completeAvgPlayback(frame, nodeId, deadline) {
     if (Date.now() >= deadline)
@@ -314,7 +378,14 @@ export async function completeAvgPlayback(frame, nodeId, deadline) {
             const remaining = deadline - Date.now();
             if (remaining <= 0)
                 break;
-            await next.click({ timeout: remaining });
+            try {
+                await next.click({ timeout: Math.min(5000, remaining) });
+            }
+            catch (error) {
+                throw new PlaytestError('AVG_NEXT_CONTROL_BLOCKED', `AVG next control is not clickable on ${nodeId}`, {
+                    nodeId, step: state.step, cause: error instanceof Error ? error.message : String(error),
+                });
+            }
             clickedStep = state.step;
         }
         const remaining = deadline - Date.now();
@@ -323,7 +394,7 @@ export async function completeAvgPlayback(frame, nodeId, deadline) {
     }
     throw new PlaytestError(observedAvg ? 'AVG_COMPLETION_TIMEOUT' : 'AVG_PLAYTEST_PROTOCOL_UNSUPPORTED', `AVG ${nodeId} did not expose completion within the remaining scenario budget`, { nodeId, clickedStep });
 }
-async function executeNativeInteraction(frame, node, edge, contract, deadline) {
+async function executeNativeInteraction(frame, node, edge, contract, deadline, media) {
     const interaction = (node.interactions || []).find((candidate) => candidate.id === edge.ownerId);
     if (!interaction)
         throw new PlaytestError('INTERACTION_NOT_RENDERED', `Interaction ${edge.ownerId} is absent from node ${edge.from}`);
@@ -336,30 +407,25 @@ async function executeNativeInteraction(frame, node, edge, contract, deadline) {
             owner: 'node',
             ownerId: node.id,
             trigger: { type: 'message', value: interaction.trigger.value },
-        }, contract);
+        }, contract, deadline);
     }
     else if (interaction.trigger?.type === 'time' && node.type === 'video') {
-        await frame.locator('video').first().evaluate((element, time) => {
-            element.currentTime = time + 0.05;
-            element.dispatchEvent(new globalThis.Event('timeupdate', { bubbles: true }));
-        }, Number(interaction.trigger.value || 0));
+        await driveVerifiedVideo(media, 'time', Number(interaction.trigger.value || 0));
     }
     else if (interaction.trigger?.type === 'time' && Number(interaction.trigger.value || 0) > 0) {
         await frame.page().waitForTimeout(Number(interaction.trigger.value) * 1000 + 50);
     }
     else if (interaction.trigger?.type === 'complete' && node.type === 'video') {
-        await frame.locator('video').first().evaluate((element) => {
-            element.dispatchEvent(new globalThis.Event('ended', { bubbles: true }));
-        });
+        await driveVerifiedVideo(media, 'complete-interaction');
     }
-    await frame.locator(`[data-bv-interaction-id="${edge.ownerId}"]`).waitFor({ state: 'attached' });
+    await frame.locator(`[data-bv-interaction-id="${edge.ownerId}"]`).waitFor({ state: 'attached', timeout: remainingBudget(deadline) });
     if (edge.trigger.type === 'timeout') {
         await frame.page().waitForTimeout((Number(interaction.timeLimit || 0) + 2.5) * 1000);
         return;
     }
     const interactionType = String(interaction.interactive?.type || '');
     if (interactionType === 'score_settlement') {
-        await executeScoreSettlement(frame, interaction, edge);
+        await executeScoreSettlement(frame, interaction, edge, deadline);
         return;
     }
     const legacy = edge.trigger.type === 'legacy' ? String(edge.trigger.value) : undefined;
@@ -379,9 +445,9 @@ async function executeNativeInteraction(frame, node, edge, contract, deadline) {
         const ids = (interaction.interactive?.chainOptions || []).map((option) => String(option.id));
         const orderedIds = resultValue === 'correct' ? ids : [...ids].reverse();
         for (const optionId of orderedIds) {
-            await frame.locator(`[data-bv-option-id="${optionId}"]`).first().click();
+            await frame.locator(`[data-bv-option-id="${optionId}"]`).first().click({ timeout: remainingBudget(deadline) });
         }
-        await clickAction(frame, 'submit');
+        await clickAction(frame, 'submit', deadline);
         return;
     }
     if (interactionType === 'blank_fill') {
@@ -392,9 +458,9 @@ async function executeNativeInteraction(frame, node, edge, contract, deadline) {
             const correctId = String(blank.correctOptionId || '');
             const wrongId = String(options.find((option) => String(option.id) !== correctId)?.id || correctId);
             const optionId = resultValue === 'incorrect' || (resultValue === 'partial' && index > 0) ? wrongId : correctId;
-            await frame.locator(`[data-bv-option-id="${optionId}"]`).first().dragTo(frame.locator(`[data-bv-blank-id="${blank.id}"]`));
+            await frame.locator(`[data-bv-option-id="${optionId}"]`).first().dragTo(frame.locator(`[data-bv-blank-id="${blank.id}"]`), { timeout: remainingBudget(deadline) });
         }
-        await clickAction(frame, 'submit');
+        await clickAction(frame, 'submit', deadline);
         return;
     }
     if (interactionType === 'input_fill') {
@@ -405,15 +471,15 @@ async function executeNativeInteraction(frame, node, edge, contract, deadline) {
             const answer = shouldBeWrong ? '__wrong__' : (blank.correctAnswers?.[0] ?? 'playtest');
             const control = frame.locator(`[data-bv-blank-id="${blank.id}"]`);
             if (blank.type === 'number') {
-                await control.click();
+                await control.click({ timeout: remainingBudget(deadline) });
                 for (const key of String(answer))
-                    await control.press(key);
+                    await control.press(key, { timeout: remainingBudget(deadline) });
             }
             else {
-                await control.fill(String(answer));
+                await control.fill(String(answer), { timeout: remainingBudget(deadline) });
             }
         }
-        await clickAction(frame, 'submit');
+        await clickAction(frame, 'submit', deadline);
         return;
     }
     let optionIds = [];
@@ -436,17 +502,17 @@ async function executeNativeInteraction(frame, node, edge, contract, deadline) {
         for (const optionId of optionIds) {
             const option = frame.locator(`[data-bv-option-id="${optionId}"]`);
             if (await option.count())
-                await option.first().click();
+                await option.first().click({ timeout: remainingBudget(deadline) });
             else {
                 const optionText = interaction.interactive?.options?.find((candidate) => String(candidate.id) === optionId)?.text;
                 if (!optionText)
                     throw new PlaytestError('INTERACTION_DRIVER_UNSUPPORTED', `No real control for option ${optionId} in interaction ${edge.ownerId}`);
-                await frame.getByText(String(optionText), { exact: true }).click();
+                await frame.getByText(String(optionText), { exact: true }).click({ timeout: remainingBudget(deadline) });
             }
         }
         const submit = frame.locator('[data-bv-action="submit"]');
         if (await submit.isVisible().catch(() => false))
-            await clickAction(frame, 'submit');
+            await clickAction(frame, 'submit', deadline);
         return;
     }
     const inputs = frame.locator(`[data-bv-interaction-id="${edge.ownerId}"] input`);
@@ -454,65 +520,81 @@ async function executeNativeInteraction(frame, node, edge, contract, deadline) {
         const blanks = interaction.interactive?.blanks || [];
         for (let index = 0; index < await inputs.count(); index += 1) {
             const answer = blanks[index]?.correctAnswers?.[0] ?? blanks[index]?.answer ?? blanks[index]?.correctAnswer ?? blanks[index]?.answers?.[0] ?? 'playtest';
-            await inputs.nth(index).fill(String(edge.trigger.value === 'incorrect' ? '__wrong__' : answer));
+            await inputs.nth(index).fill(String(edge.trigger.value === 'incorrect' ? '__wrong__' : answer), { timeout: remainingBudget(deadline) });
         }
-        await clickAction(frame, 'submit');
+        await clickAction(frame, 'submit', deadline);
         return;
     }
     throw new PlaytestError('INTERACTION_DRIVER_UNSUPPORTED', `No real DOM driver is available for ${edge.ownerId}:${edge.trigger.type}`);
 }
-async function executeEdge(frame, edge, options, deadline) {
+export async function executeEdge(frame, edge, options, deadline) {
     const node = getNode(options.script, edge.from);
-    await assertNodeMedia(frame, node);
+    const media = await assertNodeMedia(frame, node, deadline);
+    const sameNode = edge.from === edge.to && edge.actionType !== 'end';
+    let beforeSequence = 0;
+    if (sameNode) {
+        if (node.type !== 'video' || !media || !['loop', 'goto'].includes(edge.actionType)
+            || await media.element.getAttribute('data-bv-video-action-protocol') !== '1') {
+            throw new PlaytestError('EDGE_EFFECT_OBSERVATION_UNSUPPORTED', `No reliable same-node effect observation for ${edge.id}`);
+        }
+        beforeSequence = Number(await media.element.getAttribute('data-bv-video-action-sequence') || 0);
+    }
     if (edge.owner === 'interaction') {
-        await executeNativeInteraction(frame, node, edge, options.contract, deadline);
+        await executeNativeInteraction(frame, node, edge, options.contract, deadline, media);
     }
     else if (node.type === 'avg' && (edge.trigger.type === 'complete' || edge.default)) {
         await completeAvgPlayback(frame, edge.from, deadline);
     }
     else if (node.type === 'web' && (edge.trigger.type === 'message' || edge.default)) {
-        await executeWebEdge(frame, node, edge, options.contract);
+        await executeWebEdge(frame, node, edge, options.contract, deadline);
     }
     else if (node.type === 'video' && edge.trigger.type === 'time') {
-        await frame.locator('video').first().evaluate((element, time) => {
-            element.currentTime = time + 0.05;
-            element.dispatchEvent(new globalThis.Event('timeupdate', { bubbles: true }));
-        }, Number(edge.trigger.value));
+        await driveVerifiedVideo(media, 'time', Number(edge.trigger.value));
     }
     else if (node.type === 'video' && edge.trigger.type === 'complete') {
-        await frame.locator('video').first().evaluate((element) => {
-            if (Number.isFinite(element.duration) && element.duration > 0)
-                element.currentTime = Math.max(0, element.duration - 0.01);
-            element.dispatchEvent(new globalThis.Event('timeupdate', { bubbles: true }));
-            element.dispatchEvent(new globalThis.Event('ended', { bubbles: true }));
-        });
+        await driveVerifiedVideo(media, 'complete');
     }
     else if (edge.trigger.type === 'enter') {
         // Start/enter transitions are produced by the runtime itself.
     }
     else if (node.type === 'image' && edge.trigger.type === 'complete') {
         const durationMs = (node.config?.slides || []).reduce((sum, slide) => sum + Number(slide.duration || 0) * 1000, 0);
-        await frame.page().waitForTimeout(Math.min(durationMs + 250, options.limits.scenarioTimeoutMs / 2));
+        await frame.page().waitForTimeout(Math.min(durationMs + 250, remainingBudget(deadline)));
     }
     else {
         throw new PlaytestError('EDGE_DRIVER_UNSUPPORTED', `No real runtime driver for edge ${edge.id}`);
     }
-    if (edge.actionType === 'end') {
+    if (sameNode) {
+        const segment = edge.action.segment;
+        const time = edge.actionType === 'loop' ? segment?.start ?? 0
+            : typeof edge.action.time === 'number' && edge.action.time >= 0 ? edge.action.time : 0;
+        const end = edge.actionType === 'loop' ? segment?.end ?? await media.element.evaluate((video) => video.duration) : undefined;
         try {
-            await frame.waitForFunction(() => (globalThis.document.querySelector('[data-bv-ended]')?.getAttribute('data-bv-ended') === 'true'), undefined, { timeout: Math.min(10000, options.limits.scenarioTimeoutMs) });
+            await frame.waitForFunction(({ element, sequence, nodeId, type, time, end, source }) => {
+                if (!element?.isConnected || element.src !== source || element.currentSrc !== source || element.error
+                    || element.getAttribute('data-bv-media-node-id') !== nodeId
+                    || globalThis.document.querySelector('[data-bv-node-id]')?.getAttribute('data-bv-node-id') !== nodeId
+                    || Number(element.getAttribute('data-bv-video-action-sequence') || 0) <= sequence)
+                    return false;
+                const action = JSON.parse(element.getAttribute('data-bv-video-action') || 'null');
+                return action?.nodeId === nodeId && action.type === type && action.time === time && action.end === end
+                    && Number.isFinite(action.position) && Math.abs(action.position - time) <= 0.5;
+            }, { element: media.element, sequence: beforeSequence, nodeId: edge.from, type: edge.actionType, time, end, source: media.source }, { timeout: remainingBudget(deadline) });
         }
         catch {
-            throw new PlaytestError('ROUTE_TARGET_MISMATCH', `Edge ${edge.id} did not reach the ended state`);
+            throw new PlaytestError('SAME_NODE_EFFECT_NOT_OBSERVED', `No new matching runtime action receipt for ${edge.id}`);
         }
     }
-    else if (edge.actionType === 'seek' && node.type === 'video' && Number.isFinite(Number(edge.action.time))) {
-        await frame.waitForFunction((expectedTime) => {
-            const video = globalThis.document.querySelector('video');
-            return video && Math.abs(Number(video.currentTime) - Number(expectedTime)) < 0.5;
-        }, Number(edge.action.time), { timeout: Math.min(10000, options.limits.scenarioTimeoutMs) });
+    else if (edge.actionType === 'end') {
+        try {
+            await frame.waitForFunction(() => (globalThis.document.querySelector('[data-bv-ended]')?.getAttribute('data-bv-ended') === 'true'), undefined, { timeout: remainingBudget(deadline) });
+        }
+        catch {
+            throw new PlaytestError('ROUTE_TARGET_MISMATCH', `Edge ${edge.id} did not reach the ended state`);
+        }
     }
     else {
-        await waitForNode(frame, edge.to, Math.min(10000, options.limits.scenarioTimeoutMs));
+        await waitForNode(frame, edge.to, remainingBudget(deadline));
     }
 }
 async function createContext(browser, options, scenarioDir) {
@@ -577,7 +659,10 @@ async function runScenario(browser, scenario, options) {
         }, true);
         browserWindow.addEventListener('unhandledrejection', (event) => recordStartupException(event.reason));
         browserWindow.addEventListener('message', (event) => {
-            browserWindow.__bvPlaytestObservedMessages.push({ data: event.data, origin: event.origin, at: Date.now() });
+            browserWindow.__bvPlaytestObservedMessages.push({
+                data: event.data, origin: event.origin, at: Date.now(),
+                sourceId: event.source ? browserWindow.__bvPlaytestWebSources?.get(event.source) : undefined,
+            });
         });
     });
     await context.tracing.start({ screenshots: true, snapshots: true, sources: true });
@@ -610,7 +695,7 @@ async function runScenario(browser, scenario, options) {
                     throw new PlaytestError('SCENARIO_TIMEOUT', `Scenario ${scenario.id} exceeded ${options.limits.scenarioTimeoutMs}ms`);
                 await startPlayback(playerFrame, entryNodeId, String(getNode(options.script, entryNodeId).type || ''), entryTimeout);
                 playerReady = true;
-                await assertNodeMedia(playerFrame, getNode(options.script, entryNodeId));
+                await assertNodeMedia(playerFrame, getNode(options.script, entryNodeId), scenarioDeadline);
                 visitedNodes.push(String(options.script.graph?.entryNodeId || ''));
                 for (const edge of scenario.edges) {
                     activeEdge = edge;
@@ -630,7 +715,8 @@ async function runScenario(browser, scenario, options) {
             else
                 failure = new PlaytestError('PLAYER_HANDSHAKE_TIMEOUT', 'Player did not expose the BV playtest protocol within the scenario budget');
         }
-        findings.push({ code: failure.code, message: failure.message, scenarioId: scenario.id, edgeId: scenario.targetEdgeId, details: failure.details });
+        findings.push({ code: failure.code, message: failure.message, scenarioId: scenario.id, edgeId: activeEdge?.id || scenario.targetEdgeId,
+            details: activeEdge ? { ...(failure.details || {}), targetEdgeId: scenario.targetEdgeId } : failure.details });
         const screenshotPath = path.join(scenarioDir, 'failure.png');
         await page.screenshot({ path: screenshotPath, fullPage: true }).catch(() => undefined);
         artifacts.screenshot = screenshotPath;

package/dist/playtest/scenarios.js

@@ -46,6 +46,9 @@ function conditionMatches(condition, variables, inventory) {
 function applyEffects(state, edge, targetNode) {
     const variables = { ...state.variables };
     const inventory = { items: { ...state.inventory.items }, cards: { ...state.inventory.cards } };
+    // Same-node replay/media actions do not rerun entry effects; rule effects still run.
+    if (edge.from === edge.to && ['loop', 'seek', 'segment', 'goto'].includes(edge.actionType))
+        targetNode = undefined;
     const variableActions = [...(edge.variableActions || []), ...(targetNode?.variableActions || [])];
     for (const action of variableActions) {
         const current = variables[action.variable];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindscraft/branch-video-agent-cli",
-  "version": "0.4.6",
+  "version": "0.5.0",
   "description": "Published CLI for branch-video and AIHub agent APIs.",
   "type": "module",
   "bin": {