@midscene/core 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/es/yaml/player.mjs

@@ -1,12 +1,18 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
-import { assert, ifInBrowser, ifInWorker } from "@midscene/shared/utils";
-import { z } from "zod";
-import { deriveCaseStatus } from "../dump/task-status.mjs";
 import { getMidsceneRunSubDir } from "@midscene/shared/common";
 import { getDebug } from "@midscene/shared/logger";
+import { assert, ifInBrowser, ifInWorker, uuid } from "@midscene/shared/utils";
+import { WorkflowExecutionFailure, WorkflowPublicationError } from "../test-runner/engine/execution-failure.mjs";
+import { cleanupResources } from "../test-runner/engine/resource-operations.mjs";
 import { runFreeFnCleanup } from "./cleanup.mjs";
-import { buildDetailedLocateParam, buildDetailedLocateParamAndRestParams } from "./utils.mjs";
+import { YamlExecutionOwnershipError, currentYamlSignal, enterYamlExecution, runInYamlExecutionContext } from "./execution-session.mjs";
+import { createLegacyYamlExecutionRecord } from "./legacy-yaml-execution-record.mjs";
+import { publishLegacyYamlReport } from "./legacy-yaml-report.mjs";
+import { createLegacyYamlRuntime, legacyYamlOutcomeError } from "./legacy-yaml-runtime.mjs";
+import { getLegacyYamlPlayerState, initializeLegacyYamlPlayerState } from "./player-state.mjs";
+import { collectLegacyYamlDocument } from "./test-runner-compat.mjs";
+import { resolveWebTarget, resolveYamlOutputConfig } from "./utils.mjs";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -18,57 +24,12 @@ function _define_property(obj, key, value) {
     return obj;
 }
 const debug = getDebug('yaml-player');
-const aiTaskHandlerMap = {
-    aiQuery: 'aiQuery',
-    aiNumber: 'aiNumber',
-    aiString: 'aiString',
-    aiBoolean: 'aiBoolean',
-    aiAsk: 'aiAsk',
-    aiLocate: 'aiLocate'
-};
-const isStringParamSchema = (schema)=>{
-    if (!schema) return false;
-    const schemaDef = schema?._def;
-    if (!schemaDef?.typeName) return false;
-    switch(schemaDef.typeName){
-        case z.ZodFirstPartyTypeKind.ZodString:
-        case z.ZodFirstPartyTypeKind.ZodEnum:
-        case z.ZodFirstPartyTypeKind.ZodNativeEnum:
-            return true;
-        case z.ZodFirstPartyTypeKind.ZodLiteral:
-            return 'string' == typeof schemaDef.value;
-        case z.ZodFirstPartyTypeKind.ZodOptional:
-        case z.ZodFirstPartyTypeKind.ZodNullable:
-        case z.ZodFirstPartyTypeKind.ZodDefault:
-            return isStringParamSchema(schemaDef.innerType);
-        case z.ZodFirstPartyTypeKind.ZodEffects:
-            return isStringParamSchema(schemaDef.schema);
-        case z.ZodFirstPartyTypeKind.ZodPipeline:
-            return isStringParamSchema(schemaDef.out);
-        case z.ZodFirstPartyTypeKind.ZodUnion:
-            {
-                const options = schemaDef.options;
-                return Array.isArray(options) ? options.every((option)=>isStringParamSchema(option)) : false;
-            }
-        default:
-            return false;
-    }
-};
-const buildShortcutActionParam = (actionName, interfaceAlias, value)=>{
-    if ('Launch' === actionName || 'launch' === interfaceAlias) return {
-        uri: value
-    };
-    if ('Terminate' === actionName || 'terminate' === interfaceAlias) return {
-        uri: value
-    };
-    if ('RunAdbShell' === actionName || 'runAdbShell' === interfaceAlias || 'RunHdcShell' === actionName || 'runHdcShell' === interfaceAlias) return {
-        command: value
-    };
-};
 class ScriptPlayer {
     setResult(key, value) {
         const keyToUse = key || this.unnamedResultIndex++;
-        if (this.result[keyToUse]) console.warn(`result key ${keyToUse} already exists, will overwrite`);
+        if (this.result[keyToUse]) getDebug('yaml-player', {
+            console: true
+        })(`result key ${keyToUse} already exists, will overwrite`);
         this.result[keyToUse] = value;
         return this.flushResult();
     }
@@ -80,7 +41,7 @@ class ScriptPlayer {
         const taskIndexToNotify = 'number' == typeof taskIndex ? taskIndex : this.currentTaskIndex;
         if ('number' != typeof taskIndexToNotify) return;
         const taskStatus = this.taskStatusList[taskIndexToNotify];
-        if (this.onTaskStatusChange) this.onTaskStatusChange(taskStatus);
+        this.onTaskStatusChange?.(taskStatus);
     }
     async setTaskStatus(index, statusValue, error) {
         this.taskStatusList[index].status = statusValue;
@@ -90,266 +51,78 @@ class ScriptPlayer {
     setTaskIndex(taskIndex) {
         this.currentTaskIndex = taskIndex;
     }
-    flushResult() {
+    async flushResult() {
         if (this.output) {
             const output = resolve(process.cwd(), this.output);
-            const outputDir = dirname(output);
-            if (!existsSync(outputDir)) mkdirSync(outputDir, {
-                recursive: true
+            await this.publish(output, async ()=>{
+                const outputDir = dirname(output);
+                await mkdir(outputDir, {
+                    recursive: true
+                });
+                await writeFile(output, JSON.stringify(this.result || {}, void 0, 2));
             });
-            writeFileSync(output, JSON.stringify(this.result || {}, void 0, 2));
         }
     }
-    flushUnstableLogContent() {
+    async flushUnstableLogContent() {
         if (this.unstableLogContent) {
             const content = this.interfaceAgent?._unstableLogContent();
             const filePath = resolve(process.cwd(), this.unstableLogContent);
-            const outputDir = dirname(filePath);
-            if (!existsSync(outputDir)) mkdirSync(outputDir, {
-                recursive: true
+            await this.publish(filePath, async ()=>{
+                const outputDir = dirname(filePath);
+                await mkdir(outputDir, {
+                    recursive: true
+                });
+                await writeFile(filePath, JSON.stringify(content, null, 2));
             });
-            writeFileSync(filePath, JSON.stringify(content, null, 2));
         }
     }
+    async publish(path, write) {
+        try {
+            await write();
+        } catch (cause) {
+            const error = new WorkflowPublicationError('write-result', path, cause);
+            this.publicationErrors.push(error);
+            throw error;
+        }
+    }
+    createRuntime(agent) {
+        return createLegacyYamlRuntime({
+            agent,
+            actionSpace: this.actionSpace,
+            sourcePath: this.scriptPath,
+            setResult: (key, value)=>this.setResult(key, value)
+        });
+    }
     async playTask(taskStatus, agent) {
         const { flow } = taskStatus;
         assert(flow, 'missing flow in task');
-        for(const flowItemIndex in flow){
-            const currentStep = Number.parseInt(flowItemIndex, 10);
-            taskStatus.currentStep = currentStep;
-            const flowItem = flow[flowItemIndex];
-            const flowItemRecord = flowItem;
-            const executionCountBeforeStep = agent.dump?.executions?.length ?? 0;
-            this.failedReportExecutionInCurrentStep = false;
-            try {
-                await this.playFlowItem(agent, flowItem, flowItemRecord, flowItemIndex);
-            } catch (error) {
-                this.failedReportExecutionInCurrentStep = this.hasFailedReportExecutionSince(agent, executionCountBeforeStep);
-                throw error;
+        const statusIndex = this.taskStatusList.indexOf(taskStatus);
+        const declaredIndex = taskStatus.index;
+        const taskIndex = statusIndex >= 0 ? statusIndex : 'number' == typeof declaredIndex && Number.isInteger(declaredIndex) ? declaredIndex : 0;
+        const state = getLegacyYamlPlayerState(this);
+        state.executionResult = await this.createRuntime(agent).runTask(taskStatus, taskIndex, {
+            onStepStart: (info)=>{
+                if ('case' === info.scope && 'steps' === info.case.phase) taskStatus.currentStep = info.case.stepIndex;
             }
-        }
+        });
+        const outcome = state.executionResult.cases[0];
+        if (!outcome || 'not-run' === outcome.status) throw new Error(`Task "${taskStatus.name}" did not run.`);
+        if ('failed' === outcome.status) throw legacyYamlOutcomeError(outcome);
         this.reportFile = agent.reportFile;
         await this.flushUnstableLogContent();
     }
-    hasFailedReportExecutionSince(agent, executionCountBefore) {
-        const executions = (agent.dump?.executions ?? []).slice(executionCountBefore);
-        return 'failed' === deriveCaseStatus(executions);
-    }
-    async playFlowItem(agent, flowItem, flowItemRecord, flowItemIndex) {
-        if ('Finalize' in flowItemRecord) return;
-        debug(`playing step ${flowItemIndex}, flowItem=${JSON.stringify(flowItem)}`);
-        const simpleAIKey = Object.keys(aiTaskHandlerMap).find((key)=>Object.prototype.hasOwnProperty.call(flowItemRecord, key));
-        if ('aiAct' in flowItem || 'aiAction' in flowItem || 'ai' in flowItem) {
-            const actionTask = flowItem;
-            const { aiAct, aiAction, ai, instruction, ...actionOptions } = actionTask;
-            const actionPrompt = aiAct ?? aiAction ?? ai;
-            let promptForAI;
-            if ('string' == typeof instruction && instruction) promptForAI = instruction;
-            else if (instruction && 'object' == typeof instruction && 'string' == typeof instruction.prompt && instruction.prompt) promptForAI = instruction;
-            else if (actionPrompt && 'object' == typeof actionPrompt && 'string' == typeof actionPrompt.prompt && actionPrompt.prompt) promptForAI = actionPrompt;
-            else if ('string' == typeof actionPrompt && actionPrompt) promptForAI = actionPrompt;
-            assert(promptForAI, 'missing prompt for ai (aiAct)');
-            await agent.aiAct(promptForAI, actionOptions);
-        } else if ('runGherkinScenario' in flowItem) {
-            const gherkinScenarioTask = flowItem;
-            const { runGherkinScenario } = gherkinScenarioTask;
-            assert(runGherkinScenario, 'missing scenario for runGherkinScenario');
-            await agent.runGherkinScenario(runGherkinScenario, {
-                cacheable: false
-            });
-        } else if ('aiAssert' in flowItem) {
-            const assertTask = flowItem;
-            const { aiAssert: prompt, errorMessage: msg, name, ...restOpts } = assertTask;
-            assert(prompt, 'missing prompt for aiAssert');
-            assert(!Object.prototype.hasOwnProperty.call(assertTask, 'observe'), '`observe` is not supported in YAML aiAssert. Use agent.startObserving() from code instead.');
-            const result = await agent.aiAssert(prompt, msg, {
-                ...restOpts,
-                keepRawResponse: true
-            });
-            const pass = result?.pass;
-            const thought = result?.thought;
-            const message = result?.message;
-            this.setResult(name, {
-                pass,
-                thought,
-                message
-            });
-            if (!pass) throw new Error(message);
-        } else if (simpleAIKey) {
-            const { [simpleAIKey]: prompt, name, ...options } = flowItem;
-            assert(prompt, `missing prompt for ${simpleAIKey}`);
-            assert(!Object.prototype.hasOwnProperty.call(flowItem, 'observe'), '`observe` is not supported in YAML flow items. Use agent.startObserving() from code instead.');
-            const agentMethod = agent[aiTaskHandlerMap[simpleAIKey]];
-            assert('function' == typeof agentMethod, `missing agent method for ${simpleAIKey}`);
-            const aiResult = await agentMethod.call(agent, prompt, options);
-            this.setResult(name, aiResult);
-        } else if ('aiWaitFor' in flowItem) {
-            const waitForTask = flowItem;
-            const { aiWaitFor, timeout, ...restWaitForOpts } = waitForTask;
-            const prompt = aiWaitFor;
-            assert(prompt, 'missing prompt for aiWaitFor');
-            const waitForOptions = {
-                ...restWaitForOpts,
-                ...void 0 !== timeout ? {
-                    timeout,
-                    timeoutMs: timeout
-                } : {}
-            };
-            await agent.aiWaitFor(prompt, waitForOptions);
-        } else if ('sleep' in flowItem) {
-            const sleepTask = flowItem;
-            const ms = sleepTask.sleep;
-            let msNumber = ms;
-            if ('string' == typeof ms) msNumber = Number.parseInt(ms, 10);
-            assert(Number.isFinite(msNumber) && msNumber > 0, `ms for sleep must be greater than 0, but got ${ms}`);
-            await agent.sleep(msNumber);
-        } else if ("javascript" in flowItem) {
-            const evaluateJavaScriptTask = flowItem;
-            const result = await agent.evaluateJavaScript(evaluateJavaScriptTask.javascript);
-            this.setResult(evaluateJavaScriptTask.name, result);
-        } else if ('logScreenshot' in flowItem || 'recordToReport' in flowItem) {
-            const recordTask = flowItem;
-            const title = recordTask.recordToReport ?? recordTask.logScreenshot ?? 'untitled';
-            const content = recordTask.content || '';
-            await agent.recordToReport(title, {
-                content
-            });
-        } else if ('aiInput' in flowItem) {
-            const { aiInput, value: rawValue, ...inputTask } = flowItem;
-            let locatePrompt;
-            let value;
-            if (inputTask.locate) {
-                value = aiInput || rawValue;
-                locatePrompt = inputTask.locate;
-            } else {
-                locatePrompt = aiInput || '';
-                value = rawValue;
-            }
-            await agent.callActionInActionSpace('Input', {
-                ...inputTask,
-                ...void 0 !== value ? {
-                    value: String(value)
-                } : {},
-                ...locatePrompt ? {
-                    locate: buildDetailedLocateParam(locatePrompt, inputTask)
-                } : {}
-            });
-        } else if ('aiKeyboardPress' in flowItem) {
-            const { aiKeyboardPress, ...keyboardPressTask } = flowItem;
-            let locatePrompt;
-            let keyName;
-            if (keyboardPressTask.locate) {
-                keyName = aiKeyboardPress;
-                locatePrompt = keyboardPressTask.locate;
-            } else if (keyboardPressTask.keyName) {
-                keyName = keyboardPressTask.keyName;
-                locatePrompt = aiKeyboardPress;
-            } else keyName = aiKeyboardPress;
-            await agent.callActionInActionSpace('KeyboardPress', {
-                ...keyboardPressTask,
-                ...keyName ? {
-                    keyName
-                } : {},
-                ...locatePrompt ? {
-                    locate: buildDetailedLocateParam(locatePrompt, keyboardPressTask)
-                } : {}
-            });
-        } else if ('aiScroll' in flowItem) {
-            const { aiScroll, ...scrollTask } = flowItem;
-            const { locate, ...scrollOptions } = scrollTask;
-            const locatePrompt = locate ?? aiScroll ?? void 0;
-            await agent.aiScroll(locatePrompt, scrollOptions);
-        } else if ('aiTap' in flowItem) {
-            const { aiTap, prompt, locate, ...tapOptions } = flowItem;
-            let locatePrompt;
-            let opts = tapOptions;
-            const locateObj = locate ?? ('object' == typeof aiTap && null !== aiTap ? aiTap.locate : void 0);
-            if ('string' == typeof aiTap && aiTap) locatePrompt = aiTap;
-            else if ('object' == typeof locateObj && locateObj?.prompt) {
-                const { prompt: lp, ...locateOpts } = locateObj;
-                locatePrompt = lp;
-                opts = {
-                    ...locateOpts,
-                    ...tapOptions
-                };
-            } else locatePrompt = aiTap?.prompt || prompt || locateObj;
-            assert(locatePrompt, 'missing prompt for aiTap');
-            await agent.aiTap(locatePrompt, opts);
-        } else {
-            const actionSpace = this.actionSpace;
-            let locatePromptShortcut;
-            let actionParamForMatchedAction;
-            const matchedAction = actionSpace.find((action)=>{
-                const actionInterfaceAlias = action.interfaceAlias;
-                if (actionInterfaceAlias && Object.prototype.hasOwnProperty.call(flowItem, actionInterfaceAlias)) {
-                    actionParamForMatchedAction = flowItem[actionInterfaceAlias];
-                    if ('string' == typeof actionParamForMatchedAction) locatePromptShortcut = actionParamForMatchedAction;
-                    return true;
-                }
-                const keyOfActionInActionSpace = action.name;
-                if (Object.prototype.hasOwnProperty.call(flowItem, keyOfActionInActionSpace)) {
-                    actionParamForMatchedAction = flowItem[keyOfActionInActionSpace];
-                    if ('string' == typeof actionParamForMatchedAction) locatePromptShortcut = actionParamForMatchedAction;
-                    return true;
-                }
-                return false;
-            });
-            assert(matchedAction, `unknown flowItem in yaml: ${JSON.stringify(flowItem)}`);
-            const schemaIsStringParam = isStringParamSchema(matchedAction.paramSchema);
-            let stringParamToCall;
-            const resultName = flowItem.name;
-            const timeout = flowItem.timeout;
-            const hasRunAdbShellAlias = Object.prototype.hasOwnProperty.call(flowItem, 'runAdbShell');
-            if (hasRunAdbShellAlias && 'string' == typeof actionParamForMatchedAction && 'number' == typeof timeout && 'function' == typeof agent.runAdbShell) {
-                const result = await agent.runAdbShell(actionParamForMatchedAction, {
-                    timeout
-                });
-                if (void 0 !== result) this.setResult(resultName, result);
-                return;
-            }
-            const specialActionParamToCall = 'string' == typeof actionParamForMatchedAction ? buildShortcutActionParam(matchedAction.name, matchedAction.interfaceAlias, actionParamForMatchedAction) : void 0;
-            if (specialActionParamToCall) {
-                debug(`matchedAction: ${matchedAction.name}`, `flowParams: ${JSON.stringify(specialActionParamToCall)}`);
-                const result = await agent.callActionInActionSpace(matchedAction.name, specialActionParamToCall);
-                if (void 0 !== result) this.setResult(resultName, result);
-            } else if ('string' == typeof actionParamForMatchedAction && schemaIsStringParam) {
-                if (matchedAction.paramSchema) {
-                    const parseResult = matchedAction.paramSchema.safeParse(actionParamForMatchedAction);
-                    if (parseResult.success && 'string' == typeof parseResult.data) stringParamToCall = parseResult.data;
-                    else if (!parseResult.success) {
-                        debug(`parse failed for action ${matchedAction.name} with string param`, parseResult.error);
-                        stringParamToCall = actionParamForMatchedAction;
-                    }
-                } else stringParamToCall = actionParamForMatchedAction;
-                if (void 0 !== stringParamToCall) {
-                    debug(`matchedAction: ${matchedAction.name}`, `flowParams: ${JSON.stringify(stringParamToCall)}`);
-                    const result = await agent.callActionInActionSpace(matchedAction.name, stringParamToCall);
-                    const resultName = flowItem.name;
-                    if (void 0 !== result) this.setResult(resultName, result);
-                }
-            } else {
-                const sourceForParams = locatePromptShortcut && 'string' == typeof actionParamForMatchedAction ? {
-                    ...flowItem,
-                    prompt: locatePromptShortcut
-                } : 'object' == typeof actionParamForMatchedAction && null !== actionParamForMatchedAction ? actionParamForMatchedAction : flowItem;
-                const { locateParam, restParams } = buildDetailedLocateParamAndRestParams(locatePromptShortcut || '', sourceForParams, [
-                    matchedAction.name,
-                    matchedAction.interfaceAlias || '_never_mind_'
-                ]);
-                const flowParams = {
-                    ...restParams,
-                    locate: locateParam
-                };
-                debug(`matchedAction: ${matchedAction.name}`, `flowParams: ${JSON.stringify(flowParams, null, 2)}`);
-                const result = await agent.callActionInActionSpace(matchedAction.name, flowParams);
-                const resultName = flowItem.name;
-                if (void 0 !== result) this.setResult(resultName, result);
-            }
-        }
-    }
     async run() {
-        const { target, web, android, ios, harmony, computer, tasks } = this.script;
-        const webEnv = web || target;
+        return runInYamlExecutionContext(()=>this.runInContext());
+    }
+    async runInContext() {
+        const startedAt = new Date();
+        const runId = uuid();
+        const state = getLegacyYamlPlayerState(this);
+        state.executionResult = void 0;
+        state.executionRecord = void 0;
+        this.publicationErrors = [];
+        const { android, ios, harmony, computer } = this.script;
+        const webEnv = resolveWebTarget(this.script)?.target;
         const androidEnv = android;
         const iosEnv = ios;
         const harmonyEnv = harmony;
@@ -358,65 +131,155 @@ class ScriptPlayer {
         this.setPlayerStatus('running');
         let agent = null;
         let freeFn = [];
+        let setupError;
+        let executionError;
+        let cleanupError;
+        let signal;
+        let session;
         try {
             const { agent: newAgent, freeFn: newFreeFn } = await this.setupAgent(platform);
-            this.actionSpace = await newAgent.getActionSpace();
             agent = newAgent;
+            agent._prepareForTestRunner?.();
+            freeFn = [
+                ...newFreeFn || []
+            ];
+            session = enterYamlExecution(agent);
+            signal = currentYamlSignal(agent);
+            signal?.throwIfAborted();
+            this.actionSpace = await agent.getActionSpace();
             const originalOnTaskStartTip = agent.onTaskStartTip;
             agent.onTaskStartTip = (tip)=>{
                 if ('running' === this.status) this.agentStatusTip = tip;
                 originalOnTaskStartTip?.(tip);
             };
-            freeFn = [
-                ...newFreeFn || [],
-                {
-                    name: 'restore-agent-onTaskStartTip',
-                    fn: ()=>{
-                        if (agent) agent.onTaskStartTip = originalOnTaskStartTip;
-                    }
+            freeFn.push({
+                name: 'restore-agent-onTaskStartTip',
+                fn: ()=>{
+                    if (agent) agent.onTaskStartTip = originalOnTaskStartTip;
                 }
-            ];
-        } catch (e) {
-            this.setPlayerStatus('error', e);
-            return;
+            });
+        } catch (error) {
+            if (error instanceof YamlExecutionOwnershipError) throw error;
+            setupError = error;
+            this.setPlayerStatus('error', error);
         }
         this.interfaceAgent = agent;
-        let taskIndex = 0;
-        this.setPlayerStatus('running');
-        let errorFlag = false;
-        while(taskIndex < tasks.length){
-            const taskStatus = this.taskStatusList[taskIndex];
-            this.setTaskStatus(taskIndex, 'running');
-            this.setTaskIndex(taskIndex);
-            this.failedReportExecutionInCurrentStep = false;
-            try {
-                await this.playTask(taskStatus, this.interfaceAgent);
-                this.setTaskStatus(taskIndex, 'done');
-            } catch (e) {
-                this.setTaskStatus(taskIndex, 'error', e);
-                const recordErrorToReport = agent.recordErrorToReport;
-                if (!this.failedReportExecutionInCurrentStep && 'function' == typeof recordErrorToReport) try {
-                    await recordErrorToReport.call(agent, `YAML task failed - ${taskStatus.name}`, {
-                        error: e,
-                        content: `Step ${taskStatus.currentStep ?? 0} failed while running YAML task "${taskStatus.name}".`
-                    });
-                } catch (reportError) {
-                    debug('failed to record yaml error to report', reportError);
-                }
-                if (taskStatus.continueOnError) ;
-                else {
-                    this.reportFile = agent.reportFile;
-                    errorFlag = true;
-                    break;
-                }
+        const document = collectLegacyYamlDocument(this.script, this.scriptPath ?? '<inline-yaml>', this.actionSpace);
+        const runtime = agent && !setupError ? this.createRuntime(agent) : void 0;
+        try {
+            if (runtime && agent) {
+                state.executionResult = await runtime.runScript(this.script, {
+                    document,
+                    signal,
+                    createDocumentRunId: ()=>runId,
+                    onCaseStart: (collectedCase)=>{
+                        const taskIndex = collectedCase.caseIndex;
+                        this.setTaskIndex(taskIndex);
+                        return this.setTaskStatus(taskIndex, 'running');
+                    },
+                    onStepStart: (info)=>{
+                        if ('case' !== info.scope || 'steps' !== info.case.phase) return;
+                        const taskStatus = this.taskStatusList[info.case.caseIndex];
+                        if (taskStatus) taskStatus.currentStep = info.case.stepIndex;
+                    },
+                    onCaseOutcome: async (outcome)=>{
+                        if ('not-run' === outcome.status) return;
+                        const taskIndex = outcome.caseIndex;
+                        const taskStatus = this.taskStatusList[taskIndex];
+                        assert(taskStatus, `missing YAML task at index ${taskIndex}`);
+                        this.reportFile = agent?.reportFile;
+                        if ('success' === outcome.status) {
+                            await this.setTaskStatus(taskIndex, 'done');
+                            await this.flushUnstableLogContent();
+                            return;
+                        }
+                        const error = legacyYamlOutcomeError(outcome);
+                        await this.setTaskStatus(taskIndex, 'error', error);
+                    }
+                });
+                const stoppedOnFailure = state.executionResult.cases.some((outcome)=>'failed' === outcome.status && !this.taskStatusList[outcome.caseIndex]?.continueOnError);
+                this.setPlayerStatus(stoppedOnFailure || signal?.aborted ? 'error' : 'done');
             }
-            this.reportFile = agent?.reportFile;
-            taskIndex++;
+        } catch (error) {
+            executionError = error;
+            if (error instanceof WorkflowExecutionFailure) state.executionResult = error.result;
+            this.setPlayerStatus('error', error);
         }
-        if (errorFlag) this.setPlayerStatus('error');
-        else this.setPlayerStatus('done');
+        this.reportFile = agent?.reportFile;
         this.agentStatusTip = '';
-        await runFreeFnCleanup(freeFn);
+        try {
+            if (session?.isRoot && agent) await cleanupResources([
+                agent
+            ], ()=>runFreeFnCleanup(freeFn), {
+                owner: this,
+                signal,
+                onDeferredError: (error)=>getDebug('yaml-player', {
+                        console: true
+                    })(`Deferred YAML cleanup failed: ${String(error)}`)
+            });
+            else await runFreeFnCleanup(freeFn);
+        } catch (error) {
+            cleanupError = error;
+            this.setPlayerStatus('error', setupError ?? executionError ?? error);
+        }
+        const endedAt = new Date();
+        const cleanupErrors = cleanupError instanceof AggregateError ? cleanupError.errors : void 0 === cleanupError ? [] : [
+            cleanupError
+        ];
+        state.executionRecord = createLegacyYamlExecutionRecord({
+            runId,
+            attemptIndex: 0,
+            script: this.script,
+            document,
+            startedAt,
+            endedAt,
+            execution: state.executionResult,
+            setupError,
+            executionError,
+            cleanupErrors,
+            aborted: signal?.aborted ?? false,
+            publicationErrors: this.publicationErrors,
+            outputs: this.result,
+            reportFile: agent?.reportFile,
+            children: session?.children
+        });
+        let reportError;
+        if (!session || session.isRoot) try {
+            const published = await publishLegacyYamlReport({
+                agent,
+                record: state.executionRecord,
+                runId,
+                script: this.script,
+                scriptPath: this.scriptPath,
+                fallbackReportFileName: state.fallbackReportFileName
+            });
+            this.reportFile = published.reportFile;
+            state.executionRecord = published.record;
+        } catch (error) {
+            reportError = error;
+            this.setPlayerStatus('error', setupError ?? executionError ?? cleanupError ?? error);
+            state.executionRecord = Object.freeze({
+                ...state.executionRecord,
+                status: 'failed',
+                reportError: error
+            });
+        }
+        session?.finish(state.executionRecord);
+        if (reportError) {
+            const errors = [
+                setupError,
+                executionError,
+                ...cleanupErrors,
+                reportError
+            ].filter((error)=>void 0 !== error);
+            throw 1 === errors.length ? reportError : new AggregateError(errors, 'YAML execution/report finalization failed');
+        }
+        if (executionError && cleanupError) throw new AggregateError([
+            executionError,
+            ...cleanupErrors
+        ], 'YAML execution and cleanup failed');
+        if (executionError) throw executionError;
+        if (cleanupError) throw cleanupError;
     }
     constructor(script, setupAgent, onTaskStatusChange, scriptPath){
         _define_property(this, "script", void 0);
@@ -428,6 +291,7 @@ class ScriptPlayer {
         _define_property(this, "reportFile", void 0);
         _define_property(this, "result", void 0);
         _define_property(this, "unnamedResultIndex", void 0);
+        _define_property(this, "publicationErrors", void 0);
         _define_property(this, "output", void 0);
         _define_property(this, "unstableLogContent", void 0);
         _define_property(this, "errorInSetup", void 0);
@@ -436,33 +300,35 @@ class ScriptPlayer {
         _define_property(this, "target", void 0);
         _define_property(this, "actionSpace", void 0);
         _define_property(this, "scriptPath", void 0);
-        _define_property(this, "failedReportExecutionInCurrentStep", void 0);
         this.script = script;
         this.setupAgent = setupAgent;
         this.onTaskStatusChange = onTaskStatusChange;
         this.taskStatusList = [];
         this.status = 'init';
         this.unnamedResultIndex = 0;
+        this.publicationErrors = [];
         this.interfaceAgent = null;
         this.actionSpace = [];
-        this.failedReportExecutionInCurrentStep = false;
         this.scriptPath = scriptPath;
+        collectLegacyYamlDocument(script, scriptPath);
+        initializeLegacyYamlPlayerState(this);
         this.result = {};
-        this.target = script.target || script.web || script.android || script.ios || script.computer || script.config;
+        this.target = resolveWebTarget(script)?.target || script.android || script.ios || script.harmony || script.computer || script.config;
+        const outputConfig = resolveYamlOutputConfig(script);
         if (ifInBrowser || ifInWorker) {
             this.output = void 0;
             debug('output is undefined in browser or worker');
-        } else if (this.target?.output) {
-            this.output = resolve(process.cwd(), this.target.output);
+        } else if (outputConfig.output) {
+            this.output = resolve(process.cwd(), outputConfig.output);
             debug('setting output by config.output', this.output);
         } else {
             const scriptName = this.scriptPath ? basename(this.scriptPath, '.yaml').replace(/\.(ya?ml)$/i, '') : "script";
-            this.output = join(getMidsceneRunSubDir('output'), `${scriptName}-${Date.now()}.json`);
+            this.output = join(getMidsceneRunSubDir('output'), `${scriptName}-${uuid()}.json`);
             debug("setting output by script path", this.output);
         }
         if (ifInBrowser || ifInWorker) this.unstableLogContent = void 0;
-        else if ('string' == typeof this.target?.unstableLogContent) this.unstableLogContent = resolve(process.cwd(), this.target.unstableLogContent);
-        else if (this.target?.unstableLogContent === true) this.unstableLogContent = join(getMidsceneRunSubDir('output'), 'unstableLogContent.json');
+        else if ('string' == typeof outputConfig.unstableLogContent) this.unstableLogContent = resolve(process.cwd(), outputConfig.unstableLogContent);
+        else if (true === outputConfig.unstableLogContent) this.unstableLogContent = join(getMidsceneRunSubDir('output'), 'unstableLogContent.json');
         this.taskStatusList = (script.tasks || []).map((task, taskIndex)=>({
                 ...task,
                 index: taskIndex,