@midscene/test 1.15.3 → 1.15.4-beta-20261013083552.0

package/dist/lib/test-cli.js

@@ -28,9 +28,7 @@ var __webpack_modules__ = {
         module.exports = require("yargs/yargs");
     },
     "./package.json" (module) {
-        module.exports = {
-            rE: "1.15.3"
-        };
+        module.exports = JSON.parse('{"rE":"1.15.4-beta-20261013083552.0"}');
     }
 };
 var __webpack_module_cache__ = {};
@@ -270,7 +268,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             return pattern;
         });
     };
-    const test_project_validateTestFileSelection = (value, label = 'files')=>{
+    const validateTestFileSelection = (value, label = 'files')=>{
         if (void 0 === value) return;
         if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
         rejectUnknownKeys(value, [
@@ -394,7 +392,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             if ('string' != typeof candidate.name || 0 === candidate.name.trim().length) throw new TypeError(`Midscene config ${label}.name must be non-empty.`);
             if (names.has(candidate.name)) throw new TypeError(`Midscene config project name "${candidate.name}" must be unique.`);
             names.add(candidate.name);
-            const files = test_project_validateTestFileSelection(candidate.files, `${label}.files`);
+            const files = validateTestFileSelection(candidate.files, `${label}.files`);
             if (void 0 !== candidate.nodes && !Array.isArray(candidate.nodes)) throw new TypeError(`Midscene config ${label}.nodes must be an array.`);
             const localNodes = new NodeRegistry(candidate.nodes);
             const nodes = new NodeRegistry([
@@ -424,12 +422,27 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
     const validateTestOptions = (value)=>{
         if (void 0 !== value && !isRecord(value)) throw new TypeError('Midscene config test must be an object.');
         const candidate = value ?? {};
+        const executionUnit = candidate.executionUnit ?? 'project';
+        if ('project' !== executionUnit && 'case' !== executionUnit) throw new TypeError('Midscene config test.executionUnit must be "project" or "case".');
         return Object.freeze({
             maxConcurrency: validatePositiveInteger(candidate.maxConcurrency, 1, 'test.maxConcurrency'),
             bail: validateNonNegativeInteger(candidate.bail, 0, 'test.bail'),
-            testTimeout: validatePositiveInteger(candidate.testTimeout, 120000, 'test.testTimeout')
+            testTimeout: validatePositiveInteger(candidate.testTimeout, 120000, 'test.testTimeout'),
+            executionUnit,
+            executorRetry: validateNonNegativeInteger(candidate.executorRetry, 0, 'test.executorRetry')
         });
     };
+    const validateTestExecutor = (value)=>{
+        if (void 0 === value) return;
+        if (!isRecord(value)) throw new TypeError('Midscene config executor must be an object.');
+        rejectUnknownKeys(value, [
+            'name',
+            'execute'
+        ], 'executor');
+        if ('string' != typeof value.name || 0 === value.name.trim().length) throw new TypeError('Midscene config executor.name must be non-empty.');
+        if ('function' != typeof value.execute) throw new TypeError('Midscene config executor.execute must be a function.');
+        return Object.freeze(value);
+    };
     const validateOutputPath = (value, fallback, label)=>{
         if (void 0 === value) return fallback;
         if ('string' != typeof value || 0 === value.trim().length) throw new TypeError(`Midscene config ${label} must be non-empty.`);
@@ -458,15 +471,22 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             'projects',
             'test',
             'output',
-            'nodes'
+            'nodes',
+            'executor'
         ], 'root');
         const nodes = new NodeRegistry(definition.nodes);
         const resolvedProjects = validateExecutionProjects(definition.projects, definition.setup, nodes);
+        const test = validateTestOptions(definition.test);
+        const executor = validateTestExecutor(definition.executor);
+        if (executor && 'case' !== test.executionUnit) throw new TypeError('Midscene config executor requires test.executionUnit to be "case".');
         return {
             ...resolvedProjects,
-            test: validateTestOptions(definition.test),
+            test,
             output: validateOutput(definition.output),
             nodes,
+            ...executor ? {
+                executor
+            } : {},
             resolveNode: (name)=>nodes.get(name)
         };
     };
@@ -512,6 +532,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         return validateTestProjectDefinition(getDefaultExport(loaded, absolutePath));
     }
     const external_tinyglobby_namespaceObject = require("tinyglobby");
+    const isSafeResultPathSegment = (value)=>'string' == typeof value && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value);
     const external_node_crypto_namespaceObject = require("node:crypto");
     const createCaseInvocationId = (projectId, sourcePath, caseIndex, invocationIndex = 0)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
             projectId,
@@ -733,10 +754,15 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 caseIndex
             });
             collect_rejectUnknownKeys(definition, [
+                'id',
                 'name',
                 'tags',
+                'resources',
                 'steps'
             ], `Case ${caseIndex + 1}`);
+            if (void 0 !== definition.id && !isSafeResultPathSegment(definition.id)) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} id must start with an ASCII letter or number, contain only letters, numbers, dots, underscores, or hyphens, and be at most 128 characters.`, {
+                caseIndex
+            });
             if ('string' != typeof definition.name || 0 === definition.name.trim().length) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} name must be a non-empty string.`, {
                 caseIndex
             });
@@ -747,6 +773,13 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             if (!Array.isArray(tags) || tags.some((tag)=>'string' != typeof tag || 0 === tag.trim().length)) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} tags must be an array of non-empty strings.`, {
                 caseIndex
             });
+            const resources = definition.resources ?? [];
+            if (!Array.isArray(resources) || resources.some((resource)=>'string' != typeof resource || 0 === resource.trim().length)) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} resources must be an array of non-empty strings.`, {
+                caseIndex
+            });
+            if (new Set(resources).size !== resources.length) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} resources must not contain duplicates.`, {
+                caseIndex
+            });
             const steps = normalizeSteps(definition.steps, options.resolveNode).map((normalized, stepIndex)=>{
                 if (!options.resolveNode(normalized.node)) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
                     caseIndex,
@@ -755,7 +788,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 });
                 return resolveStepVariables(normalized, 'steps', stepIndex, caseIndex);
             });
-            const caseId = createCaseId(source.projectId, sourcePath, caseIndex);
+            const caseId = 'string' == typeof definition.id ? definition.id : createCaseId(source.projectId, sourcePath, caseIndex);
             if (ids.has(caseId)) throw new test_runner_namespaceObject.WorkflowParseError(`Case id collision: ${caseId}.`, {
                 caseId
             });
@@ -766,8 +799,14 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 sourcePath,
                 caseIndex,
                 definition: {
+                    ...'string' == typeof definition.id ? {
+                        id: definition.id
+                    } : {},
                     name: definition.name,
                     tags: tags,
+                    ...resources.length > 0 ? {
+                        resources: resources
+                    } : {},
                     steps
                 }
             };
@@ -908,6 +947,38 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                             ...outcome.notRunReason ? {
                                 notRunReason: outcome.notRunReason
                             } : {},
+                            ...outcome.execution ? {
+                                execution: {
+                                    executor: outcome.execution.executor,
+                                    resources: outcome.execution.resources,
+                                    ...void 0 === outcome.execution.attempts ? {} : {
+                                        attempts: outcome.execution.attempts
+                                    },
+                                    ...outcome.execution.failure ? {
+                                        failure: outcome.execution.failure
+                                    } : {},
+                                    ...outcome.execution.artifacts ? {
+                                        artifacts: outcome.execution.artifacts
+                                    } : {},
+                                    ...outcome.execution.metadata ? {
+                                        metadata: outcome.execution.metadata
+                                    } : {},
+                                    ...outcome.execution.lifecycle ? {
+                                        lifecycle: {
+                                            status: outcome.execution.lifecycle.status,
+                                            startedAt: outcome.execution.lifecycle.startedAt,
+                                            endedAt: outcome.execution.lifecycle.endedAt,
+                                            durationMs: outcome.execution.lifecycle.durationMs,
+                                            ...outcome.execution.lifecycle.setupError ? {
+                                                setupError: errorJson(outcome.execution.lifecycle.setupError)
+                                            } : {},
+                                            ...outcome.execution.lifecycle.teardownErrors ? {
+                                                teardownErrors: outcome.execution.lifecycle.teardownErrors.map(errorJson)
+                                            } : {}
+                                        }
+                                    } : {}
+                                }
+                            } : {},
                             ...outcome.attempts ? {
                                 attempts: outcome.attempts.map((attempt)=>({
                                         attemptId: attempt.runId,
@@ -985,6 +1056,27 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         ]
     };
     const project_preparation_toPosix = (value)=>value.split(external_node_path_.sep).join('/');
+    const discoverSelectedTestFiles = (projectRoot, paths)=>{
+        const root = (0, external_node_path_.resolve)(projectRoot);
+        const files = new Set();
+        for (const requestedPath of paths){
+            if ('string' != typeof requestedPath || 0 === requestedPath.trim().length) throw new TypeError('Test selection paths must be non-empty strings.');
+            const absolutePath = (0, external_node_path_.resolve)(root, requestedPath);
+            const relativePath = (0, external_node_path_.relative)(root, absolutePath);
+            if ('..' === relativePath || relativePath.startsWith(`..${external_node_path_.sep}`) || (0, external_node_path_.isAbsolute)(relativePath)) throw new Error(`Test selection path is outside the project: ${requestedPath}`);
+            if (!(0, external_node_fs_.existsSync)(absolutePath)) throw new Error(`Test selection path does not exist: ${requestedPath}`);
+            if ((0, external_node_fs_.statSync)(absolutePath).isDirectory()) for (const file of discoverTestFiles(absolutePath))files.add(file);
+            else if (/\.ya?ml$/i.test(absolutePath)) files.add(absolutePath);
+            else throw new Error(`Test selection file must be YAML: ${requestedPath}`);
+        }
+        return [
+            ...files
+        ].sort((a, b)=>{
+            const relativeA = project_preparation_toPosix((0, external_node_path_.relative)(root, a));
+            const relativeB = project_preparation_toPosix((0, external_node_path_.relative)(root, b));
+            return relativeA < relativeB ? -1 : relativeA > relativeB ? 1 : 0;
+        });
+    };
     const discoverResolvedTestFiles = (projectRoot, selection)=>{
         const root = (0, external_node_path_.resolve)(projectRoot);
         const match = (patterns)=>(0, external_tinyglobby_namespaceObject.globSync)(patterns, {
@@ -1009,6 +1101,11 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             return relativeA < relativeB ? -1 : relativeA > relativeB ? 1 : 0;
         });
     };
+    const discoverTestFiles = (projectRoot, selection = DEFAULT_TEST_FILE_SELECTION)=>{
+        const normalized = validateTestFileSelection(selection);
+        if (!normalized) throw new TypeError('Test file selection is required.');
+        return discoverResolvedTestFiles(projectRoot, normalized);
+    };
     const discoverTestConfig = (projectRoot)=>{
         const root = (0, external_node_path_.resolve)(projectRoot);
         const candidates = (0, external_node_fs_.readdirSync)(root).filter((name)=>name.startsWith(CONFIG_PREFIX)).sort();
@@ -1039,8 +1136,14 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         if (selection.exclude.some((tag)=>tags.includes(tag))) return false;
         return 0 === selection.include.length || selection.include.some((tag)=>tags.includes(tag));
     };
-    const filterDocumentCases = (document, project)=>{
-        const cases = document.cases.filter((item)=>matchesTags(item.definition.tags ?? [], project.tags));
+    const filterDocumentCases = (document, project, selection)=>{
+        const cases = document.cases.filter((item)=>{
+            const tags = item.definition.tags ?? [];
+            return matchesTags(tags, project.tags) && matchesTags(tags, {
+                include: selection?.tags?.include ?? [],
+                exclude: selection?.tags?.exclude ?? []
+            }) && (!selection?.caseIds?.length || selection.caseIds.includes(item.caseId));
+        });
         const filtered = document.cases.length - cases.length;
         return 0 === cases.length ? {
             filtered
@@ -1065,7 +1168,9 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         const platform = options.platform?.trim();
         const fileSelection = project.files ?? DEFAULT_TEST_FILE_SELECTION;
         const prerequisiteFile = options.prerequisiteFile ? (0, external_node_path_.resolve)(options.prerequisiteFile) : void 0;
-        const mainFiles = options.files ?? discoverResolvedTestFiles(projectRoot, fileSelection);
+        const projectFiles = options.files ?? discoverResolvedTestFiles(projectRoot, fileSelection);
+        const selectedFiles = options.selection?.paths?.length ? new Set(discoverSelectedTestFiles(projectRoot, options.selection.paths)) : void 0;
+        const mainFiles = selectedFiles ? projectFiles.filter((file)=>selectedFiles.has(file)) : projectFiles;
         const files = [
             ...prerequisiteFile ? [
                 prerequisiteFile
@@ -1088,6 +1193,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         const invocations = [];
         const plans = [];
         let filteredCaseCount = 0;
+        const availableCaseIds = new Set();
         if (0 === sources.length) {
             const error = asCollectionError(project.projectId, project.name, '<project>', new test_runner_namespaceObject.WorkflowParseError(`No workflow YAML files found for project "${project.name}" in ${projectRoot}.`, {
                 projectName: project.name,
@@ -1118,10 +1224,16 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 variables: project.variables,
                 env: process.env
             });
+            const duplicate = document.cases.find((item)=>availableCaseIds.has(item.caseId));
+            if (duplicate) throw new test_runner_namespaceObject.WorkflowParseError(`Case id collision in project "${project.name}": ${duplicate.caseId}.`, {
+                caseId: duplicate.caseId,
+                projectName: project.name
+            });
+            for (const item of document.cases)availableCaseIds.add(item.caseId);
             const filtered = source.absolutePath === prerequisiteFile ? {
                 document,
                 filtered: 0
-            } : filterDocumentCases(document, project);
+            } : filterDocumentCases(document, project, options.selection);
             const plan = (0, test_runner_namespaceObject.buildTestRunReportPlan)(document, {
                 selectedCaseIds: filtered.document?.cases.map((item)=>item.caseId) ?? [],
                 defaultTimeoutMs,
@@ -1169,9 +1281,42 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             plans,
             collectionErrors,
             selectedCaseCount: documents.reduce((total, document)=>total + document.cases.length, 0),
-            filteredCaseCount
+            filteredCaseCount,
+            availableCaseIds: [
+                ...availableCaseIds
+            ]
         };
     }
+    const validateUniqueStrings = (values, label)=>{
+        if (void 0 === values) return;
+        if (!Array.isArray(values) || values.some((value)=>'string' != typeof value || 0 === value.trim().length)) throw new TypeError(`${label} must be an array of non-empty strings.`);
+        if (new Set(values).size !== values.length) throw new TypeError(`${label} must not contain duplicates.`);
+        return values;
+    };
+    const validateRunSelection = (options)=>{
+        const paths = validateUniqueStrings(options.paths, 'Test selection paths');
+        const caseIds = validateUniqueStrings(options.caseIds, 'Test selection caseIds');
+        const include = validateUniqueStrings(options.tags?.include, 'Test selection tags.include');
+        const exclude = validateUniqueStrings(options.tags?.exclude, 'Test selection tags.exclude');
+        return {
+            ...paths ? {
+                paths
+            } : {},
+            ...caseIds ? {
+                caseIds
+            } : {},
+            ...include || exclude ? {
+                tags: {
+                    ...include ? {
+                        include
+                    } : {},
+                    ...exclude ? {
+                        exclude
+                    } : {}
+                }
+            } : {}
+        };
+    };
     const padDatePart = (value)=>String(value).padStart(2, '0');
     const createTestRunId = (date = new Date(), uuid = (0, external_node_crypto_namespaceObject.randomUUID)())=>{
         const timestamp = [
@@ -1209,6 +1354,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         const startedAt = new Date();
         const runId = createTestRunId(startedAt);
         const input = resolveRunInput(options);
+        const selection = validateRunSelection(options);
         const configPath = options.configPath ? (0, external_node_path_.resolve)(input.configSearchRoot, options.configPath) : discoverTestConfig(input.configSearchRoot);
         if (options.configPath && /\.ya?ml$/i.test(configPath)) throw new Error(`midscene-test --config only accepts a native TypeScript or JavaScript project config: ${configPath}. Run legacy batch YAML with \`midscene --config ${options.configPath}\`.`);
         if (options.configPath && !(0, external_node_fs_.existsSync)(configPath)) throw new Error(`Midscene config does not exist: ${configPath}`);
@@ -1222,11 +1368,20 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         });
         (0, external_node_fs_.mkdirSync)(runDir);
         const projects = [];
-        for (const project of selectProjects(definition.projects, options.projectNames))projects.push(await prepareProject(project, input.projectRoot, runDir, definition.test.testTimeout, input.singleFile ? {
-            files: [
-                input.singleFile
-            ]
-        } : void 0));
+        for (const project of selectProjects(definition.projects, options.projectNames))projects.push(await prepareProject(project, input.projectRoot, runDir, definition.test.testTimeout, {
+            selection,
+            ...input.singleFile ? {
+                files: [
+                    input.singleFile
+                ]
+            } : {}
+        }));
+        if (selection.caseIds?.length) {
+            const availableCaseIds = new Set(projects.flatMap((project)=>project.availableCaseIds ?? []));
+            const unknown = selection.caseIds.find((id)=>!availableCaseIds.has(id));
+            if (unknown) throw new Error(`Unknown Midscene case id: ${unknown}`);
+        }
+        if ((selection.paths?.length || selection.caseIds?.length || selection.tags?.include?.length || selection.tags?.exclude?.length) && projects.every((project)=>0 === project.selectedCaseCount && 0 === project.collectionErrors.length)) throw new Error('No Midscene cases matched the requested selection.');
         const hasFormatMismatch = projects.some((project)=>project.collectionErrors.some(({ error })=>error instanceof NativeWorkflowFormatError));
         return {
             startedAt,
@@ -1325,20 +1480,1051 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         }));
         return output;
     }
-    const stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
+    const asNotRun = (documentId, collectedCase, projectName, reason)=>({
+            documentId,
+            caseId: collectedCase.caseId,
+            projectName,
+            name: collectedCase.definition.name,
+            sourcePath: collectedCase.sourcePath,
+            caseIndex: collectedCase.caseIndex,
+            status: 'not-run',
+            notRunReason: reason
+        });
     const formatStep = (info)=>{
-        const position = stepPosition(info);
+        const position = 'case' === info.scope ? info.case : info.document;
         const phase = 'steps' === position.phase ? 'step' : position.phase;
         return `${phase} ${position.stepIndex + 1}/${info.stepCount}: ${info.node}`;
     };
-    const formatStepResult = (info, result)=>{
-        const indent = 'case' === info.scope ? '      ' : '    ';
+    const formatStepResult = (info, result, indent = '')=>{
         if ('not-run' === result.status) return `${indent}– ${formatStep(info)} (not run: ${result.notRunReason})`;
         const symbol = 'success' === result.status ? '✓' : '✗';
         const error = result.error ? ` — ${result.error.message}` : '';
         const continuation = result.continuedAfterError ? '; continuing' : '';
         return `${indent}${symbol} ${formatStep(info)} (${result.durationMs} ms)${error}${continuation}`;
     };
+    const latestById = (items, id)=>[
+            ...new Map(items.map((item)=>[
+                    id(item),
+                    item
+                ])).values()
+        ];
+    const buildProjectResult = (prepared, cases, documents, lifecycle)=>{
+        const { project } = prepared;
+        const projectFailed = prepared.collectionErrors.length > 0 || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status || item.execution?.lifecycle?.status === 'failed') || latestById(documents, (item)=>item.documentId).some((item)=>'failed' === item.status) || lifecycle?.status === 'failed';
+        return {
+            projectId: project.projectId,
+            name: project.name,
+            ...prepared.platform ? {
+                platform: prepared.platform
+            } : {},
+            status: projectFailed ? 'failed' : 'success',
+            retry: project.retry,
+            fileSelection: prepared.fileSelection,
+            tagSelection: project.tags,
+            sourceCount: prepared.sources.length,
+            selectedCaseCount: prepared.selectedCaseCount,
+            filteredCaseCount: prepared.filteredCaseCount,
+            ...lifecycle ? {
+                lifecycle
+            } : {},
+            cases,
+            plans: prepared.plans,
+            documents,
+            collectionErrors: prepared.collectionErrors
+        };
+    };
+    const json = v4_namespaceObject.z.lazy(()=>v4_namespaceObject.z.union([
+            v4_namespaceObject.z["null"](),
+            v4_namespaceObject.z.string(),
+            v4_namespaceObject.z.number().finite(),
+            v4_namespaceObject.z.boolean(),
+            v4_namespaceObject.z.array(json),
+            v4_namespaceObject.z.record(v4_namespaceObject.z.string(), json)
+        ]));
+    const time = v4_namespaceObject.z.string().refine((value)=>Number.isFinite(Date.parse(value)));
+    const executor_runtime_schema_count = v4_namespaceObject.z.number().int().nonnegative();
+    const executor_runtime_schema_value = v4_namespaceObject.z.strictObject({
+        value: json,
+        truncatedPaths: v4_namespaceObject.z.array(v4_namespaceObject.z.string()).optional(),
+        redactedPaths: v4_namespaceObject.z.array(v4_namespaceObject.z.string()).optional()
+    });
+    const reportErrorSchema = v4_namespaceObject.z.lazy(()=>v4_namespaceObject.z.strictObject({
+            format: v4_namespaceObject.z.literal('midscene-error').optional(),
+            name: v4_namespaceObject.z.string(),
+            message: v4_namespaceObject.z.string(),
+            code: v4_namespaceObject.z.string().optional(),
+            details: executor_runtime_schema_value.optional(),
+            cause: reportErrorSchema.optional(),
+            errors: v4_namespaceObject.z.array(reportErrorSchema).optional(),
+            truncated: v4_namespaceObject.z.boolean().optional()
+        }));
+    const executor_runtime_schema_operation = v4_namespaceObject.z.strictObject({
+        operationId: v4_namespaceObject.z.string().min(1),
+        scopeId: v4_namespaceObject.z.string().optional(),
+        stepId: v4_namespaceObject.z.string().optional(),
+        node: v4_namespaceObject.z.string().optional()
+    });
+    const cleanupSchema = v4_namespaceObject.z.strictObject({
+        status: v4_namespaceObject.z["enum"]([
+            'not-required',
+            'completed',
+            'pending',
+            'failed'
+        ]),
+        capturedAt: time,
+        operationId: v4_namespaceObject.z.string().optional(),
+        blockingOperations: v4_namespaceObject.z.array(executor_runtime_schema_operation).optional(),
+        error: reportErrorSchema.optional()
+    });
+    const pendingOperationsSchema = v4_namespaceObject.z.array(executor_runtime_schema_operation);
+    const collectionStatus = v4_namespaceObject.z["enum"]([
+        'complete',
+        'partial',
+        'unknown'
+    ]);
+    const metricsSchema = v4_namespaceObject.z.strictObject({
+        modelCallCount: executor_runtime_schema_count,
+        modelTimeMs: v4_namespaceObject.z.number().finite().nonnegative(),
+        promptTokens: executor_runtime_schema_count,
+        cachedInputTokens: executor_runtime_schema_count,
+        completionTokens: executor_runtime_schema_count,
+        totalTokens: executor_runtime_schema_count,
+        collection: v4_namespaceObject.z.strictObject({
+            status: collectionStatus,
+            expectedExecutionCount: executor_runtime_schema_count,
+            capturedExecutionCount: executor_runtime_schema_count,
+            reasons: v4_namespaceObject.z.array(v4_namespaceObject.z.string()),
+            fields: v4_namespaceObject.z.strictObject({
+                modelCallCount: collectionStatus,
+                modelTimeMs: collectionStatus,
+                totalTokens: collectionStatus
+            }).optional()
+        }).optional()
+    });
+    const operationsSchema = v4_namespaceObject.z.strictObject({
+        capturedAt: time,
+        events: v4_namespaceObject.z.array(v4_namespaceObject.z.strictObject({
+            operationId: v4_namespaceObject.z.string().min(1),
+            operationKind: v4_namespaceObject.z["enum"]([
+                'node',
+                'resource',
+                'acquisition',
+                'cleanup',
+                'readiness'
+            ]),
+            kind: v4_namespaceObject.z["enum"]([
+                'started',
+                'cancel-requested',
+                'settled',
+                'runner-returned',
+                'cleanup-deferred'
+            ]),
+            at: time,
+            stepId: v4_namespaceObject.z.string().optional(),
+            scopeId: v4_namespaceObject.z.string().optional(),
+            node: v4_namespaceObject.z.string().optional(),
+            status: v4_namespaceObject.z["enum"]([
+                'success',
+                'failed',
+                'not-run'
+            ]).optional(),
+            pending: v4_namespaceObject.z.boolean().optional(),
+            error: reportErrorSchema.optional(),
+            blockingOperations: v4_namespaceObject.z.array(executor_runtime_schema_operation).optional()
+        }))
+    });
+    const runtimeResultFields = {
+        executionStatus: v4_namespaceObject.z["enum"]([
+            'success',
+            'failed',
+            'not-run'
+        ]).optional(),
+        phases: v4_namespaceObject.z.partialRecord(v4_namespaceObject.z["enum"]([
+            'beforeAll',
+            'beforeEach',
+            'steps',
+            'afterEach',
+            'afterAll'
+        ]), v4_namespaceObject.z.strictObject({
+            status: v4_namespaceObject.z["enum"]([
+                'success',
+                'failed',
+                'not-run',
+                'not-required'
+            ]),
+            plannedStepCount: executor_runtime_schema_count,
+            executedStepCount: executor_runtime_schema_count
+        })).optional(),
+        cleanup: cleanupSchema.optional(),
+        pendingOperations: pendingOperationsSchema.optional(),
+        retryDecision: v4_namespaceObject.z.strictObject({
+            scope: v4_namespaceObject.z["enum"]([
+                'case',
+                'document'
+            ]),
+            retryCount: executor_runtime_schema_count,
+            attemptIndex: executor_runtime_schema_count,
+            decision: v4_namespaceObject.z["enum"]([
+                'retry',
+                'stop'
+            ]),
+            reason: v4_namespaceObject.z["enum"]([
+                'passed',
+                'attempt-failed',
+                'budget-exhausted',
+                'cleanup-pending',
+                'cleanup-failed',
+                'operation-pending',
+                'fatal-error',
+                'interrupted',
+                'bail',
+                'infrastructure-error'
+            ])
+        }).optional()
+    };
+    const plannedStep = v4_namespaceObject.z.strictObject({
+        id: v4_namespaceObject.z.string(),
+        phase: v4_namespaceObject.z["enum"]([
+            'beforeAll',
+            'beforeEach',
+            'steps',
+            'afterEach',
+            'afterAll'
+        ]),
+        stepIndex: executor_runtime_schema_count,
+        node: v4_namespaceObject.z.string(),
+        title: v4_namespaceObject.z.string().optional(),
+        input: executor_runtime_schema_value,
+        inputMode: v4_namespaceObject.z["enum"]([
+            'template',
+            'resolved'
+        ]),
+        timeoutMs: v4_namespaceObject.z.number().positive().optional(),
+        continueOnError: v4_namespaceObject.z.boolean()
+    });
+    const documentPlanSchema = v4_namespaceObject.z.strictObject({
+        documentId: v4_namespaceObject.z.string(),
+        sourcePath: v4_namespaceObject.z.string(),
+        sourceYaml: executor_runtime_schema_value.optional(),
+        retry: v4_namespaceObject.z.strictObject({
+            scope: v4_namespaceObject.z["enum"]([
+                'case',
+                'document'
+            ]),
+            count: executor_runtime_schema_count
+        }),
+        beforeAll: v4_namespaceObject.z.array(plannedStep),
+        afterAll: v4_namespaceObject.z.array(plannedStep),
+        cases: v4_namespaceObject.z.array(v4_namespaceObject.z.strictObject({
+            caseId: v4_namespaceObject.z.string(),
+            name: v4_namespaceObject.z.string(),
+            caseIndex: executor_runtime_schema_count,
+            selected: v4_namespaceObject.z.boolean(),
+            tags: v4_namespaceObject.z.array(v4_namespaceObject.z.string()),
+            onFailure: v4_namespaceObject.z["enum"]([
+                'continue',
+                'stop-document'
+            ]).optional(),
+            beforeEach: v4_namespaceObject.z.array(plannedStep),
+            steps: v4_namespaceObject.z.array(plannedStep),
+            afterEach: v4_namespaceObject.z.array(plannedStep)
+        }))
+    });
+    function test_executor_define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    class TestExecutorError extends Error {
+        constructor(message, options = {}){
+            super(message, {
+                cause: options.cause
+            }), test_executor_define_property(this, "kind", void 0), test_executor_define_property(this, "retryable", void 0);
+            this.name = 'TestExecutorError';
+            this.kind = options.kind ?? 'unknown';
+            this.retryable = options.retryable ?? false;
+        }
+    }
+    const localTestExecutor = Object.freeze({
+        name: 'local',
+        execute: (_task, context)=>context.runLocal()
+    });
+    const jsonValueSchema = v4_namespaceObject.z.lazy(()=>v4_namespaceObject.z.union([
+            v4_namespaceObject.z["null"](),
+            v4_namespaceObject.z.string(),
+            v4_namespaceObject.z.number().finite(),
+            v4_namespaceObject.z.boolean(),
+            v4_namespaceObject.z.array(jsonValueSchema),
+            v4_namespaceObject.z.record(v4_namespaceObject.z.string(), jsonValueSchema)
+        ]));
+    const timestampSchema = v4_namespaceObject.z.string().refine((value)=>Number.isFinite(Date.parse(value)), {
+        message: 'Expected an ISO-compatible timestamp.'
+    });
+    const errorSchema = v4_namespaceObject.z.strictObject({
+        format: v4_namespaceObject.z.literal('midscene-error').optional(),
+        cause: reportErrorSchema.optional(),
+        name: v4_namespaceObject.z.string().min(1),
+        message: v4_namespaceObject.z.string(),
+        code: v4_namespaceObject.z.string().min(1),
+        details: jsonValueSchema.optional()
+    });
+    const stepBaseSchema = v4_namespaceObject.z.strictObject({
+        phase: v4_namespaceObject.z["enum"]([
+            'beforeAll',
+            'beforeEach',
+            'steps',
+            'afterEach',
+            'afterAll'
+        ]),
+        stepIndex: v4_namespaceObject.z.number().int().nonnegative(),
+        node: v4_namespaceObject.z.string().min(1),
+        input: jsonValueSchema,
+        meta: v4_namespaceObject.z.strictObject({
+            timeoutMs: v4_namespaceObject.z.number().positive().finite().optional(),
+            continueOnError: v4_namespaceObject.z.boolean()
+        }),
+        continuedAfterError: v4_namespaceObject.z.boolean(),
+        waitForPreviousOperationMs: v4_namespaceObject.z.number().nonnegative().finite().optional(),
+        operations: operationsSchema.optional(),
+        output: v4_namespaceObject.z.strictObject({
+            summary: v4_namespaceObject.z.string().optional(),
+            data: jsonValueSchema.optional()
+        }).optional(),
+        error: errorSchema.optional(),
+        report: v4_namespaceObject.z.strictObject({
+            traces: v4_namespaceObject.z.array(v4_namespaceObject.z.strictObject({
+                type: v4_namespaceObject.z.literal('midscene-execution'),
+                executionId: v4_namespaceObject.z.string().min(1),
+                metrics: metricsSchema.optional()
+            })),
+            collectionErrors: v4_namespaceObject.z.array(errorSchema).optional()
+        }).optional()
+    });
+    const stepSchema = v4_namespaceObject.z.discriminatedUnion('status', [
+        stepBaseSchema.extend({
+            status: v4_namespaceObject.z["enum"]([
+                'success',
+                'failed'
+            ]),
+            startedAt: timestampSchema,
+            endedAt: timestampSchema,
+            durationMs: v4_namespaceObject.z.number().nonnegative().finite()
+        }),
+        stepBaseSchema.extend({
+            status: v4_namespaceObject.z.literal('not-run'),
+            notRunReason: v4_namespaceObject.z.string().min(1),
+            blockedBy: v4_namespaceObject.z.string().optional()
+        })
+    ]);
+    const validatedStepSchema = stepSchema.superRefine((step, context)=>{
+        if ('success' === step.status && (step.error || step.continuedAfterError)) context.addIssue({
+            code: 'custom',
+            message: 'Successful steps cannot contain failure evidence.'
+        });
+        if (step.continuedAfterError && !step.meta.continueOnError) context.addIssue({
+            code: 'custom',
+            message: 'Continuation requires continueOnError.'
+        });
+    });
+    const attemptSchema = v4_namespaceObject.z.strictObject({
+        ...runtimeResultFields,
+        caseId: v4_namespaceObject.z.string().min(1),
+        runId: v4_namespaceObject.z.string().min(1),
+        projectName: v4_namespaceObject.z.string().min(1),
+        attemptIndex: v4_namespaceObject.z.number().int().nonnegative(),
+        name: v4_namespaceObject.z.string(),
+        sourcePath: v4_namespaceObject.z.string().min(1),
+        caseIndex: v4_namespaceObject.z.number().int().nonnegative(),
+        status: v4_namespaceObject.z["enum"]([
+            'success',
+            'failed'
+        ]),
+        beforeEach: v4_namespaceObject.z.array(validatedStepSchema),
+        steps: v4_namespaceObject.z.array(validatedStepSchema),
+        afterEach: v4_namespaceObject.z.array(validatedStepSchema),
+        executionErrors: v4_namespaceObject.z.array(errorSchema).optional(),
+        teardownErrors: v4_namespaceObject.z.array(errorSchema).optional(),
+        reportRefs: v4_namespaceObject.z.array(v4_namespaceObject.z.string().min(1)).optional(),
+        startedAt: timestampSchema,
+        endedAt: timestampSchema,
+        durationMs: v4_namespaceObject.z.number().nonnegative().finite()
+    });
+    const notRunReasonSchema = v4_namespaceObject.z["enum"]([
+        'document-start-failed',
+        'project-preflight-failed',
+        'project-setup-failed',
+        'interrupted',
+        'bail',
+        'fatal-error',
+        'executor-failed',
+        'cleanup-pending',
+        'cleanup-failed',
+        'operation-pending'
+    ]);
+    const resultSchema = v4_namespaceObject.z.strictObject({
+        case: v4_namespaceObject.z.strictObject({
+            documentId: v4_namespaceObject.z.string().min(1),
+            caseId: v4_namespaceObject.z.string().min(1),
+            projectName: v4_namespaceObject.z.string().min(1),
+            name: v4_namespaceObject.z.string(),
+            sourcePath: v4_namespaceObject.z.string().min(1),
+            caseIndex: v4_namespaceObject.z.number().int().nonnegative(),
+            status: v4_namespaceObject.z["enum"]([
+                'success',
+                'failed',
+                'not-run'
+            ]),
+            run: attemptSchema.optional(),
+            attempts: v4_namespaceObject.z.array(attemptSchema).optional(),
+            notRunReason: notRunReasonSchema.optional()
+        }),
+        document: v4_namespaceObject.z.strictObject({
+            ...runtimeResultFields,
+            plan: documentPlanSchema.optional(),
+            attemptIndex: v4_namespaceObject.z.number().int().nonnegative().optional(),
+            hostErrors: v4_namespaceObject.z.array(v4_namespaceObject.z.strictObject({
+                phase: v4_namespaceObject.z["enum"]([
+                    'setup',
+                    'execution',
+                    'cleanup',
+                    'report',
+                    'publication',
+                    'observer'
+                ]),
+                error: reportErrorSchema
+            })).optional(),
+            documentId: v4_namespaceObject.z.string().min(1),
+            documentRunId: v4_namespaceObject.z.string().min(1),
+            projectId: v4_namespaceObject.z.string().min(1),
+            projectName: v4_namespaceObject.z.string().min(1),
+            sourcePath: v4_namespaceObject.z.string().min(1),
+            status: v4_namespaceObject.z["enum"]([
+                'success',
+                'failed'
+            ]),
+            startedAt: timestampSchema,
+            endedAt: timestampSchema,
+            durationMs: v4_namespaceObject.z.number().nonnegative().finite(),
+            beforeAll: v4_namespaceObject.z.array(validatedStepSchema),
+            afterAll: v4_namespaceObject.z.array(validatedStepSchema),
+            executionErrors: v4_namespaceObject.z.array(errorSchema).optional(),
+            teardownErrors: v4_namespaceObject.z.array(errorSchema).optional(),
+            reportRefs: v4_namespaceObject.z.array(v4_namespaceObject.z.string().min(1)).optional()
+        }).optional(),
+        lifecycle: v4_namespaceObject.z.strictObject({
+            cleanup: cleanupSchema.optional(),
+            pendingOperations: pendingOperationsSchema.optional(),
+            projectName: v4_namespaceObject.z.string().min(1),
+            status: v4_namespaceObject.z["enum"]([
+                'success',
+                'failed'
+            ]),
+            setupError: errorSchema.optional(),
+            teardownErrors: v4_namespaceObject.z.array(errorSchema).optional(),
+            startedAt: timestampSchema,
+            endedAt: timestampSchema,
+            durationMs: v4_namespaceObject.z.number().nonnegative().finite()
+        }).optional(),
+        artifacts: v4_namespaceObject.z.array(v4_namespaceObject.z.strictObject({
+            name: v4_namespaceObject.z.string().min(1),
+            uri: v4_namespaceObject.z.string().min(1),
+            mediaType: v4_namespaceObject.z.string().min(1).optional()
+        })).optional(),
+        metadata: v4_namespaceObject.z.record(v4_namespaceObject.z.string(), v4_namespaceObject.z.union([
+            v4_namespaceObject.z.string(),
+            v4_namespaceObject.z.number().finite(),
+            v4_namespaceObject.z.boolean(),
+            v4_namespaceObject.z["null"]()
+        ])).optional()
+    });
+    const attemptMatchesTask = (task, attempt)=>attempt.caseId === task.caseId && attempt.projectName === task.projectName && attempt.name === task.caseName && attempt.sourcePath === task.sourcePath && attempt.caseIndex === task.caseIndex && isSafeResultPathSegment(attempt.runId);
+    const hasUnfinishedWork = (result)=>void 0 !== result.executionStatus && 'success' !== result.executionStatus || void 0 !== result.cleanup && ![
+            'completed',
+            'not-required'
+        ].includes(result.cleanup.status) || (result.pendingOperations?.length ?? 0) > 0;
+    function assertTestCaseTaskRunResult(task, value) {
+        const parsed = resultSchema.safeParse(value);
+        if (!parsed.success) throw new TypeError(`Executor returned invalid transport data for ${task.caseId}: ${v4_namespaceObject.z.prettifyError(parsed.error)}`);
+        const outcome = parsed.data.case;
+        if (outcome.caseId !== task.caseId || outcome.documentId !== task.documentId || outcome.projectName !== task.projectName || outcome.name !== task.caseName || outcome.sourcePath !== task.sourcePath || outcome.caseIndex !== task.caseIndex) throw new Error(`Executor returned a result that does not match task ${task.caseId}.`);
+        const attempts = outcome.attempts ?? [];
+        for (const attempt of attempts){
+            const steps = [
+                ...attempt.beforeEach,
+                ...attempt.steps,
+                ...attempt.afterEach
+            ];
+            if ('success' === attempt.status && (0 === attempt.steps.length || (attempt.executionErrors?.length ?? 0) > 0 || steps.some((step)=>'success' !== step.status) || hasUnfinishedWork(attempt) || (attempt.teardownErrors?.length ?? 0) > 0)) throw new TypeError(`Executor returned an inconsistent successful attempt for ${task.caseId}.`);
+        }
+        if (new Set(attempts.map((attempt)=>attempt.runId)).size !== attempts.length) throw new TypeError(`Executor returned duplicate attempt IDs for ${task.caseId}.`);
+        if (attempts.some((attempt)=>!attemptMatchesTask(task, attempt))) throw new TypeError(`Executor returned invalid attempts for ${task.caseId}.`);
+        if (attempts.some((attempt, index)=>attempt.attemptIndex !== index) || attempts.length > task.retry + 1) throw new TypeError(`Executor returned a non-sequential attempt history for ${task.caseId}.`);
+        const finalAttempt = attempts.at(-1);
+        if ('not-run' === outcome.status) {
+            if (outcome.run || attempts.length || !outcome.notRunReason) throw new TypeError(`Executor returned an inconsistent not-run result for ${task.caseId}.`);
+        } else if (void 0 !== outcome.notRunReason || !outcome.run || !finalAttempt || finalAttempt.status !== outcome.status || outcome.run.runId !== finalAttempt.runId || JSON.stringify(outcome.run) !== JSON.stringify(finalAttempt) || attempts.slice(0, -1).some((attempt)=>'failed' !== attempt.status)) throw new TypeError(`Executor returned an inconsistent ${outcome.status} result for ${task.caseId}.`);
+        const reportRefs = [
+            ...attempts.flatMap((attempt)=>attempt.reportRefs ?? []),
+            ...parsed.data.document?.reportRefs ?? []
+        ];
+        if (reportRefs.some((reference)=>!isSafeResultPathSegment(reference))) throw new TypeError(`Executor returned an invalid report reference for ${task.caseId}.`);
+        const document = parsed.data.document;
+        if (document?.status === 'success' && (hasUnfinishedWork(document) || (document.hostErrors?.length ?? 0) > 0 || (document.executionErrors?.length ?? 0) > 0 || [
+            ...document.beforeAll,
+            ...document.afterAll
+        ].some((step)=>'success' !== step.status) || (document.teardownErrors?.length ?? 0) > 0)) throw new TypeError(`Executor returned an inconsistent successful document for ${task.caseId}.`);
+        const lifecycle = parsed.data.lifecycle;
+        if (lifecycle?.status === 'success' && (hasUnfinishedWork(lifecycle) || lifecycle.setupError || (lifecycle.teardownErrors?.length ?? 0) > 0)) throw new TypeError(`Executor returned an inconsistent successful lifecycle for ${task.caseId}.`);
+        if (document && (document.documentId !== task.documentId || document.projectId !== task.projectId || document.projectName !== task.projectName || document.sourcePath !== task.sourcePath || !isSafeResultPathSegment(document.documentRunId))) throw new Error(`Executor returned a document that does not match task ${task.caseId}.`);
+        if (parsed.data.lifecycle && parsed.data.lifecycle.projectName !== task.projectName) throw new Error(`Executor returned a lifecycle that does not match task ${task.caseId}.`);
+    }
+    function createExecutorReports(outputDir) {
+        const paths = new Map();
+        const sources = new Map();
+        return {
+            materializeSource (source) {
+                if (!source.dumpPath) {
+                    const reference = this.materialize(source.sourcePath);
+                    sources.set(reference, {
+                        sourcePath: this.resolve(reference),
+                        collection: source.collection
+                    });
+                    return reference;
+                }
+                const dump = (0, external_node_fs_.realpathSync)(source.dumpPath);
+                const reference = (0, external_node_crypto_namespaceObject.randomUUID)();
+                const destination = (0, external_node_path_.join)(outputDir, 'reports', reference);
+                (0, external_node_fs_.mkdirSync)(destination, {
+                    recursive: true
+                });
+                const dumpPath = (0, external_node_path_.join)(destination, 'snapshot.json');
+                (0, external_node_fs_.cpSync)(dump, dumpPath);
+                const screenshots = (0, external_node_path_.join)((0, external_node_path_.dirname)(dump), 'screenshots');
+                if ((0, external_node_fs_.existsSync)(screenshots)) (0, external_node_fs_.cpSync)(screenshots, (0, external_node_path_.join)(destination, 'screenshots'), {
+                    recursive: true,
+                    dereference: true
+                });
+                const sourcePath = (0, external_node_path_.join)(destination, 'index.html');
+                sources.set(reference, {
+                    sourcePath,
+                    dumpPath,
+                    collection: source.collection
+                });
+                paths.set(reference, sourcePath);
+                return reference;
+            },
+            resolveSource (reference) {
+                return sources.get(reference);
+            },
+            materialize (sourcePath) {
+                const source = (0, external_node_fs_.realpathSync)(sourcePath);
+                const entry = (0, external_node_fs_.statSync)(source).isDirectory() ? (0, external_node_path_.join)(source, 'index.html') : source;
+                if (!(0, external_node_fs_.statSync)(entry).isFile()) throw new TestExecutorError(`Executor report must have a regular HTML entry: ${sourcePath}`, {
+                    kind: 'report'
+                });
+                const reference = (0, external_node_crypto_namespaceObject.randomUUID)();
+                const destination = (0, external_node_path_.join)(outputDir, 'reports', reference);
+                (0, external_node_fs_.mkdirSync)(destination, {
+                    recursive: true
+                });
+                const isDirectoryReport = 'index.html' === (0, external_node_path_.basename)(entry);
+                const reportPath = (0, external_node_path_.join)(destination, isDirectoryReport ? 'index.html' : 'report.html');
+                (0, external_node_fs_.cpSync)(isDirectoryReport ? (0, external_node_path_.dirname)(entry) : entry, isDirectoryReport ? destination : reportPath, {
+                    recursive: isDirectoryReport,
+                    dereference: true
+                });
+                if (!isDirectoryReport) {
+                    const screenshots = (0, external_node_path_.join)((0, external_node_path_.dirname)(entry), 'screenshots');
+                    if ((0, external_node_fs_.existsSync)(screenshots)) (0, external_node_fs_.cpSync)(screenshots, (0, external_node_path_.join)(destination, 'screenshots'), {
+                        recursive: true,
+                        dereference: true
+                    });
+                }
+                paths.set(reference, reportPath);
+                return reference;
+            },
+            resolve (reference) {
+                const reportPath = paths.get(reference);
+                if (!reportPath) throw new TestExecutorError(`Executor returned unknown report reference ${reference}.`, {
+                    kind: 'report'
+                });
+                return reportPath;
+            }
+        };
+    }
+    async function runTaskPool(options) {
+        if (!Number.isInteger(options.maxConcurrency) || options.maxConcurrency <= 0) throw new TypeError('Task scheduler maxConcurrency must be a positive integer.');
+        const pending = options.tasks.map((_, index)=>index);
+        const results = new Array(options.tasks.length);
+        const activeResources = new Set();
+        let active = 0;
+        let firstError;
+        let hasError = false;
+        return await new Promise((resolve, reject)=>{
+            let settled = false;
+            const stopRequested = ()=>hasError || options.signal?.aborted === true || options.shouldStop?.() === true;
+            const finish = ()=>{
+                if (settled) return;
+                settled = true;
+                options.signal?.removeEventListener('abort', pump);
+                if (hasError) reject(firstError);
+                else resolve(results);
+            };
+            const release = (resources)=>{
+                for (const resource of resources)activeResources.delete(resource);
+            };
+            const claimRunnable = ()=>{
+                const pendingIndex = pending.findIndex((taskIndex)=>options.tasks[taskIndex].resources.every((resource)=>!activeResources.has(resource)));
+                if (pendingIndex < 0) return;
+                const [taskIndex] = pending.splice(pendingIndex, 1);
+                return taskIndex;
+            };
+            function pump() {
+                if (settled) return;
+                while(active < options.maxConcurrency && !stopRequested()){
+                    const taskIndex = claimRunnable();
+                    if (void 0 === taskIndex) break;
+                    const task = options.tasks[taskIndex];
+                    for (const resource of task.resources)activeResources.add(resource);
+                    active += 1;
+                    Promise.resolve().then(()=>options.run(task, taskIndex)).then((result)=>{
+                        results[taskIndex] = result;
+                    }).catch((error)=>{
+                        if (!hasError) {
+                            hasError = true;
+                            firstError = error;
+                        }
+                    }).finally(()=>{
+                        release(task.resources);
+                        active -= 1;
+                        pump();
+                    });
+                }
+                if (0 === active && (0 === pending.length || stopRequested())) finish();
+            }
+            options.signal?.addEventListener('abort', pump, {
+                once: true
+            });
+            pump();
+        });
+    }
+    const isolatedDocumentId = (document, collectedCase)=>`${document.documentId}-case-${collectedCase.caseIndex}`;
+    const prepareCaseTasks = (projects)=>projects.flatMap((prepared, projectIndex)=>prepared.documents.flatMap((document)=>document.cases.map((collectedCase)=>{
+                    const documentId = isolatedDocumentId(document, collectedCase);
+                    return {
+                        projectIndex,
+                        prepared,
+                        document,
+                        collectedCase,
+                        task: Object.freeze({
+                            taskId: `${prepared.project.projectId}:${collectedCase.caseId}`,
+                            projectId: prepared.project.projectId,
+                            projectName: prepared.project.name,
+                            documentId,
+                            sourcePath: collectedCase.sourcePath,
+                            caseId: collectedCase.caseId,
+                            caseName: collectedCase.definition.name,
+                            caseIndex: collectedCase.caseIndex,
+                            tags: Object.freeze([
+                                ...collectedCase.definition.tags ?? []
+                            ]),
+                            resources: Object.freeze([
+                                ...collectedCase.definition.resources ?? []
+                            ]),
+                            retry: prepared.project.retry
+                        })
+                    };
+                })));
+    const reviveError = (error)=>{
+        const revived = new test_runner_namespaceObject.WorkflowError(error.message, {
+            code: error.code,
+            details: error.details,
+            cause: error.cause
+        });
+        revived.name = error.name;
+        return revived;
+    };
+    const reviveStep = (step)=>{
+        const { error, output, report, ...base } = step;
+        return {
+            ...base,
+            input: step.input,
+            meta: {
+                ...step.meta
+            },
+            ...output ? {
+                output: {
+                    ...output
+                }
+            } : {},
+            ...error ? {
+                error: reviveError(error)
+            } : {},
+            ...report ? {
+                report: {
+                    traces: report.traces.map((trace)=>({
+                            ...trace
+                        })),
+                    ...report.collectionErrors ? {
+                        collectionErrors: report.collectionErrors.map(reviveError)
+                    } : {}
+                }
+            } : {}
+        };
+    };
+    const reviveAttempt = (attempt)=>{
+        const { executionErrors, teardownErrors, reportRefs, beforeEach, steps, afterEach, ...base } = attempt;
+        return {
+            ...base,
+            beforeEach: beforeEach.map(reviveStep),
+            steps: steps.map(reviveStep),
+            afterEach: afterEach.map(reviveStep),
+            ...executionErrors ? {
+                executionErrors: executionErrors.map(reviveError)
+            } : {},
+            ...teardownErrors ? {
+                teardownErrors: teardownErrors.map(reviveError)
+            } : {}
+        };
+    };
+    const reviveDocument = (document)=>{
+        const { executionErrors, teardownErrors, reportRefs, beforeAll, afterAll, hostErrors, ...base } = document;
+        return {
+            ...base,
+            ...hostErrors ? {
+                hostErrors: hostErrors.map((error)=>({
+                        ...error
+                    }))
+            } : {},
+            beforeAll: beforeAll.map(reviveStep),
+            afterAll: afterAll.map(reviveStep),
+            ...executionErrors ? {
+                executionErrors: executionErrors.map(reviveError)
+            } : {},
+            ...teardownErrors ? {
+                teardownErrors: teardownErrors.map(reviveError)
+            } : {}
+        };
+    };
+    const reviveLifecycle = (lifecycle)=>{
+        const { setupError, teardownErrors, ...base } = lifecycle;
+        return {
+            ...base,
+            ...setupError ? {
+                setupError: reviveError(setupError)
+            } : {},
+            ...teardownErrors ? {
+                teardownErrors: teardownErrors.map(reviveError)
+            } : {}
+        };
+    };
+    const toTransportResult = (result, materializeReport, materializeSource)=>{
+        const transportReports = (scope)=>[
+                ...(scope.reportSources ?? []).map(materializeSource),
+                ...(scope.reportPaths ?? []).filter((path)=>!scope.reportSources?.some((source)=>source.sourcePath === path)).map(materializeReport)
+            ];
+        const mapStep = (step)=>{
+            if (!step.report) return step;
+            const { sources: _sources, ...report } = step.report;
+            return {
+                ...step,
+                report
+            };
+        };
+        const mapAttempt = (attempt)=>{
+            const { reportPaths, reportSources, reportScopeId, ...transportAttempt } = attempt;
+            const reportRefs = transportReports(attempt);
+            return {
+                ...transportAttempt,
+                beforeEach: attempt.beforeEach.map(mapStep),
+                steps: attempt.steps.map(mapStep),
+                afterEach: attempt.afterEach.map(mapStep),
+                ...reportRefs.length ? {
+                    reportRefs
+                } : {}
+            };
+        };
+        const attempts = result.case.attempts?.map(mapAttempt);
+        const run = attempts?.at(-1);
+        const { run: _run, attempts: _attempts, ...transportCase } = result.case;
+        const document = result.document ? (()=>{
+            const { reportPaths, reportSources, reportScopeId, ...transportDocument } = result.document;
+            const reportRefs = transportReports(result.document);
+            return {
+                ...transportDocument,
+                ...result.document.hostErrors ? {
+                    hostErrors: result.document.hostErrors.map(({ phase, error })=>({
+                            phase,
+                            error: (0, test_runner_namespaceObject.sanitizeReportError)(error)
+                        }))
+                } : {},
+                beforeAll: result.document.beforeAll.map(mapStep),
+                afterAll: result.document.afterAll.map(mapStep),
+                ...reportRefs.length ? {
+                    reportRefs
+                } : {}
+            };
+        })() : void 0;
+        return JSON.parse(JSON.stringify({
+            case: {
+                ...transportCase,
+                ...run ? {
+                    run
+                } : {},
+                ...attempts ? {
+                    attempts
+                } : {}
+            },
+            ...document ? {
+                document
+            } : {},
+            ...result.lifecycle ? {
+                lifecycle: result.lifecycle
+            } : {}
+        }));
+    };
+    const fromTransportResult = (result, resolveReportReference, resolveSource)=>{
+        const resolveReports = (refs)=>{
+            const reportPaths = [];
+            const reportSources = [];
+            for (const ref of refs ?? []){
+                const path = resolveReportReference(ref);
+                const source = resolveSource(ref);
+                if (source) reportSources.push(source);
+                else reportPaths.push(path);
+            }
+            return {
+                ...reportPaths.length ? {
+                    reportPaths
+                } : {},
+                ...reportSources.length ? {
+                    reportSources
+                } : {}
+            };
+        };
+        const attempts = result.case.attempts?.map((attempt)=>({
+                ...reviveAttempt(attempt),
+                ...resolveReports(attempt.reportRefs)
+            }));
+        const run = attempts?.at(-1);
+        const { run: _run, attempts: _attempts, ...caseBase } = result.case;
+        return {
+            case: {
+                ...caseBase,
+                ...run ? {
+                    run
+                } : {},
+                ...attempts ? {
+                    attempts
+                } : {}
+            },
+            ...result.document ? {
+                document: {
+                    ...reviveDocument(result.document),
+                    ...resolveReports(result.document.reportRefs)
+                }
+            } : {},
+            ...result.lifecycle ? {
+                lifecycle: reviveLifecycle(result.lifecycle)
+            } : {}
+        };
+    };
+    const runLocalCase = async (preparedTask, options, taskProgress, materializeReport, materializeSource)=>{
+        const { prepared, document, collectedCase, task } = preparedTask;
+        const { project } = prepared;
+        const isolatedDocument = {
+            ...document,
+            documentId: task.documentId,
+            cases: [
+                collectedCase
+            ]
+        };
+        const runtime = (0, test_runner_namespaceObject.createProjectRuntime)({
+            project,
+            setup: project.setup,
+            signal: options.signal
+        });
+        let lifecycle;
+        let execution;
+        let executionError;
+        try {
+            await runtime.start();
+            if (runtime.canRun) execution = await (0, test_runner_namespaceObject.runWorkflowDocument)(isolatedDocument, {
+                resolveNode: project.nodes.require.bind(project.nodes),
+                project,
+                projectContext: runtime.context,
+                retry: project.retry,
+                signal: runtime.signal,
+                defaultTimeoutMs: options.test.testTimeout,
+                shouldStop: ()=>options.signal.aborted,
+                stopReason: ()=>'interrupted',
+                isFatalError: (run)=>[
+                        ...run.beforeEach,
+                        ...run.steps,
+                        ...run.afterEach
+                    ].some((step)=>step.error && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (run.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError),
+                onStepStart: (info)=>taskProgress(`→ ${formatStep(info)}`),
+                onStepResult: (info, result)=>taskProgress(formatStepResult(info, result)),
+                onCaseResult: (attempt)=>taskProgress(`${'success' === attempt.status ? '✓' : '✗'} attempt ${attempt.attemptIndex + 1}/${project.retry + 1}: ${attempt.name} (${attempt.durationMs} ms)`)
+            });
+        } catch (error) {
+            executionError = error;
+            if (error instanceof test_runner_namespaceObject.WorkflowExecutionFailure) execution = error.result;
+        } finally{
+            const failed = void 0 !== executionError || !runtime.canRun || execution?.cases[0]?.status !== 'success' || execution?.document.status === 'failed';
+            lifecycle = await runtime.finish(failed ? 'failed' : 'success');
+        }
+        if (executionError) {
+            if (!execution) throw executionError;
+            options.onInfrastructureError(executionError);
+        }
+        if (!execution) return toTransportResult({
+            case: asNotRun(task.documentId, collectedCase, project.name, options.signal.aborted ? 'interrupted' : 'project-setup-failed'),
+            lifecycle
+        }, materializeReport, materializeSource);
+        const outcome = execution.cases[0];
+        if (!outcome) throw new Error(`Executor did not produce case result for ${task.caseId}.`);
+        return toTransportResult({
+            case: {
+                ...outcome,
+                documentId: task.documentId
+            },
+            document: execution.document,
+            lifecycle
+        }, materializeReport, materializeSource);
+    };
+    const runCaseTask = async (preparedTask, taskIndex, taskCount, options, onCompleted)=>{
+        const { prepared, task } = preparedTask;
+        const taskProgress = (message)=>options.progress(`[case ${taskIndex + 1}/${taskCount}] ${task.projectName} / ${task.sourcePath} / ${task.caseName}: ${message}`);
+        taskProgress('started');
+        const outputDir = (0, external_node_path_.join)(options.runDir, task.projectId, 'executor-output', task.documentId, task.caseId);
+        (0, external_node_fs_.mkdirSync)(outputDir, {
+            recursive: true
+        });
+        const { materialize: materializeReport, materializeSource, resolve: resolveReportReference, resolveSource } = createExecutorReports(outputDir);
+        if (prepared.collectionErrors.length > 0) return {
+            case: asNotRun(task.documentId, preparedTask.collectedCase, task.projectName, 'project-preflight-failed')
+        };
+        const executor = options.executor ?? localTestExecutor;
+        let result;
+        let executorFailure;
+        let executorAttempts = 0;
+        for(let attemptIndex = 0; attemptIndex <= options.test.executorRetry; attemptIndex += 1){
+            executorAttempts = attemptIndex + 1;
+            try {
+                result = await executor.execute(task, {
+                    signal: options.signal,
+                    onProgress: taskProgress,
+                    outputDir,
+                    materializeReport,
+                    runLocal: ()=>runLocalCase(preparedTask, options, taskProgress, materializeReport, materializeSource)
+                });
+                executorFailure = void 0;
+                break;
+            } catch (error) {
+                if (!(error instanceof TestExecutorError)) throw error;
+                executorFailure = error;
+                if (!error.retryable || attemptIndex >= options.test.executorRetry || options.signal.aborted) break;
+                taskProgress(`executor retry ${attemptIndex + 1}/${options.test.executorRetry}: ${error.message}`);
+            }
+        }
+        if (!result) {
+            if (!executorFailure) throw new Error(`Executor did not return a result for ${task.caseId}.`);
+            taskProgress(`executor-failed: ${executorFailure.message}`);
+            return {
+                case: {
+                    ...asNotRun(task.documentId, preparedTask.collectedCase, task.projectName, 'executor-failed'),
+                    execution: {
+                        executor: executor.name,
+                        resources: task.resources,
+                        attempts: executorAttempts,
+                        failure: {
+                            kind: executorFailure.kind,
+                            message: executorFailure.message,
+                            retryable: executorFailure.retryable
+                        }
+                    }
+                }
+            };
+        }
+        assertTestCaseTaskRunResult(task, result);
+        const internalResult = fromTransportResult(result, resolveReportReference, resolveSource);
+        const completed = {
+            ...internalResult,
+            case: {
+                ...internalResult.case,
+                execution: {
+                    executor: executor.name,
+                    resources: task.resources,
+                    attempts: executorAttempts,
+                    ...internalResult.lifecycle ? {
+                        lifecycle: internalResult.lifecycle
+                    } : {},
+                    ...result.artifacts ? {
+                        artifacts: result.artifacts
+                    } : {},
+                    ...result.metadata ? {
+                        metadata: result.metadata
+                    } : {}
+                }
+            }
+        };
+        onCompleted(completed);
+        for (const attempt of internalResult.case.attempts ?? [])await writeCaseAttemptResult(options.runDir, task.projectId, task.documentId, attempt);
+        if (internalResult.document) await writeWorkflowDocumentResult(options.runDir, internalResult.document);
+        taskProgress(internalResult.case.status);
+        return completed;
+    };
+    const runCaseExecution = async (options)=>{
+        const tasks = prepareCaseTasks(options.projects);
+        let failedCaseCount = 0;
+        const bailReached = ()=>options.test.bail > 0 && failedCaseCount >= options.test.bail;
+        const results = new Array(tasks.length);
+        if (tasks.length > 0) try {
+            await runTaskPool({
+                tasks: tasks.map((preparedTask)=>preparedTask.task),
+                maxConcurrency: Math.min(options.test.maxConcurrency, tasks.length),
+                signal: options.signal,
+                shouldStop: bailReached,
+                run: async (_task, taskIndex)=>{
+                    try {
+                        const result = await runCaseTask(tasks[taskIndex], taskIndex, tasks.length, options, (completed)=>{
+                            results[taskIndex] = completed;
+                        });
+                        results[taskIndex] = result;
+                        if ('failed' === result.case.status) failedCaseCount += 1;
+                        return result;
+                    } catch (error) {
+                        options.onInfrastructureError(error);
+                        throw error;
+                    }
+                }
+            });
+        } catch (error) {
+            options.onInfrastructureError(error);
+        }
+        return options.projects.map((prepared, projectIndex)=>{
+            const projectTasks = tasks.map((task, taskIndex)=>({
+                    task,
+                    result: results[taskIndex]
+                })).filter(({ task })=>task.projectIndex === projectIndex);
+            const reason = prepared.collectionErrors.length ? 'project-preflight-failed' : options.signal.aborted ? 'interrupted' : bailReached() ? 'bail' : void 0;
+            const cases = projectTasks.map(({ task, result })=>{
+                if (result) return result.case;
+                if (!reason) throw new Error(`Case scheduler did not produce a result for "${task.task.caseId}".`);
+                return asNotRun(task.task.documentId, task.collectedCase, prepared.project.name, reason);
+            });
+            const documents = projectTasks.flatMap(({ result })=>result?.document ? [
+                    result.document
+                ] : []);
+            return buildProjectResult(prepared, cases, documents);
+        });
+    };
     const caseHasFatalError = (outcome)=>(outcome.attempts ?? []).some((attempt)=>[
                 ...attempt.beforeEach,
                 ...attempt.steps,
@@ -1384,7 +2570,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 },
                 onStepResult: async (info, result)=>{
                     await invocation.bindings.onStepResult?.(info, result);
-                    options.onProgress(formatStepResult(info, result));
+                    options.onProgress(formatStepResult(info, result, 'case' === info.scope ? '      ' : '    '));
                 },
                 onCaseResult: async (attempt)=>{
                     await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
@@ -1502,16 +2688,6 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             }
         };
     }
-    const asNotRun = (documentId, collectedCase, projectName, reason)=>({
-            documentId,
-            caseId: collectedCase.caseId,
-            projectName,
-            name: collectedCase.definition.name,
-            sourcePath: collectedCase.sourcePath,
-            caseIndex: collectedCase.caseIndex,
-            status: 'not-run',
-            notRunReason: reason
-        });
     const summarize = (projects)=>{
         const healthCases = projects.flatMap((project)=>{
             const documentAttemptByRunId = new Map(project.documents.map((document)=>[
@@ -1545,12 +2721,6 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             projectFailures: projects.filter((project)=>'failed' === project.status).length
         };
     };
-    const latestById = (items, id)=>[
-            ...new Map(items.map((item)=>[
-                    id(item),
-                    item
-                ])).values()
-        ];
     const notRunSuite = (prepared, reason)=>prepared.documents.flatMap((document)=>document.cases.map((item)=>asNotRun(document.documentId, item, prepared.project.name, reason)));
     async function runPreparedTestProject(plan) {
         const { startedAt, runId, projectRoot, configPath, resultDir, runDir, summaryPath, reportDir, definition, projects: preparedProjects } = plan;
@@ -1563,7 +2733,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         await writeTestRunPlan(runDir, preparedProjects);
         const journal = createOperationJournal(runDir);
         const rootController = new AbortController();
-        (0, external_node_events_namespaceObject.setMaxListeners)(Math.max(10, effectiveConcurrency + 1), rootController.signal);
+        (0, external_node_events_namespaceObject.setMaxListeners)(Math.max(10, ('case' === definition.test.executionUnit ? Math.min(definition.test.maxConcurrency, totalCases) : effectiveConcurrency) + 1), rootController.signal);
         const handleSignal = (signal)=>{
             rootController.abort(new Error(`Workflow interrupted by ${signal}.`));
         };
@@ -1605,31 +2775,6 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             const { project } = prepared;
             runInfrastructureCallback(()=>progress(`[project ${projectIndex + 1}/${preparedProjects.length}] ${project.name}`));
         };
-        const buildProjectResult = (prepared, cases, documents, lifecycle)=>{
-            const { project } = prepared;
-            const projectFailed = prepared.collectionErrors.length > 0 || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status) || latestById(documents, (item)=>item.documentId).some((item)=>'failed' === item.status) || lifecycle?.status === 'failed';
-            return {
-                projectId: project.projectId,
-                name: project.name,
-                ...prepared.platform ? {
-                    platform: prepared.platform
-                } : {},
-                status: projectFailed ? 'failed' : 'success',
-                retry: project.retry,
-                fileSelection: prepared.fileSelection,
-                tagSelection: project.tags,
-                sourceCount: prepared.sources.length,
-                selectedCaseCount: prepared.selectedCaseCount,
-                filteredCaseCount: prepared.filteredCaseCount,
-                ...lifecycle ? {
-                    lifecycle
-                } : {},
-                cases,
-                plans: prepared.plans,
-                documents,
-                collectionErrors: prepared.collectionErrors
-            };
-        };
         const buildSkippedProjectResult = (prepared, projectIndex, reason)=>{
             announceProject(prepared, projectIndex);
             return buildProjectResult(prepared, notRunSuite(prepared, reason), []);
@@ -1730,7 +2875,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         };
         const projectResults = new Array(preparedProjects.length);
         try {
-            await (0, test_runner_namespaceObject.runConcurrentJobs)(preparedProjects, {
+            if ('case' !== definition.test.executionUnit || 'run' === plan.preflightScope && totalErrors > 0) await (0, test_runner_namespaceObject.runConcurrentJobs)(preparedProjects, {
                 concurrency: effectiveConcurrency,
                 shouldStop: ()=>hasInfrastructureError || rootController.signal.aborted || bailReached()
             }, async (prepared, index)=>{
@@ -1741,6 +2886,20 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                     throw error;
                 }
             });
+            else {
+                const results = await runCaseExecution({
+                    projects: preparedProjects,
+                    test: definition.test,
+                    executor: definition.executor,
+                    runDir,
+                    signal: rootController.signal,
+                    progress,
+                    onInfrastructureError: recordInfrastructureError
+                });
+                results.forEach((result, index)=>{
+                    projectResults[index] = result;
+                });
+            }
         } catch (error) {
             recordInfrastructureError(error);
         } finally{
@@ -1853,6 +3012,10 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         let configPath;
         let resultDir;
         const projectNames = [];
+        const paths = [];
+        const caseIds = [];
+        const includeTags = [];
+        const excludeTags = [];
         for(let index = commandOffset; index < args.length; index += 1){
             const token = args[index];
             const equal = token.startsWith('-') ? token.indexOf('=') : -1;
@@ -1863,17 +3026,22 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 projectRoot = (0, external_node_path_.resolve)(cwd, arg);
                 continue;
             }
-            if ('--config' === arg || '--result-dir' === arg || '--project' === arg) {
+            if ('--config' === arg || '--result-dir' === arg || '--project' === arg || '--file' === arg || '--case-id' === arg || '--tag' === arg || '--exclude-tag' === arg) {
                 const value = inlineValue ?? args[index + 1];
                 if (!value || value.startsWith('--')) throw new Error(`${arg} requires a value.`);
                 if ('--config' === arg) configPath = value;
                 else if ('--result-dir' === arg) resultDir = (0, external_node_path_.resolve)(cwd, value);
-                else projectNames.push(value);
+                else if ('--project' === arg) projectNames.push(value);
+                else if ('--file' === arg) paths.push(value);
+                else if ('--case-id' === arg) caseIds.push(value);
+                else if ('--tag' === arg) includeTags.push(value);
+                else excludeTags.push(value);
                 if (void 0 === inlineValue) index += 1;
             } else throw new Error(`Unknown option: ${token}`);
         }
         if ('nodes' === command && resultDir) throw new Error('--result-dir is not supported by nodes.');
         if ('nodes' === command && projectNames.length > 1) throw new Error('nodes accepts only one --project name.');
+        if ('nodes' === command && (paths.length > 0 || caseIds.length > 0 || includeTags.length > 0 || excludeTags.length > 0)) throw new Error('nodes does not support --file, --case-id, --tag, or --exclude-tag.');
         return {
             ...command ? {
                 command
@@ -1884,6 +3052,22 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             resultDir,
             ...projectNames.length > 0 ? {
                 projectNames
+            } : {},
+            ...paths.length > 0 ? {
+                paths
+            } : {},
+            ...caseIds.length > 0 ? {
+                caseIds
+            } : {},
+            ...includeTags.length > 0 || excludeTags.length > 0 ? {
+                tags: {
+                    ...includeTags.length > 0 ? {
+                        include: includeTags
+                    } : {},
+                    ...excludeTags.length > 0 ? {
+                        exclude: excludeTags
+                    } : {}
+                }
             } : {}
         };
     };