@midscene/test 1.15.4-beta-20261013083552.0 → 1.15.4

package/dist/lib/cli/index.js

@@ -25,1281 +25,751 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     DEFAULT_TEST_FILE_SELECTION: ()=>DEFAULT_TEST_FILE_SELECTION,
-    TestExecutorError: ()=>TestExecutorError,
     createTestRunId: ()=>createTestRunId,
-    validateTestFileSelection: ()=>validateTestFileSelection,
-    defineTestExecutor: ()=>defineTestExecutor,
-    discoverTestConfig: ()=>discoverTestConfig,
     runTestProject: ()=>runTestProject,
-    localTestExecutor: ()=>localTestExecutor,
-    assertTestCaseTaskRunResult: ()=>assertTestCaseTaskRunResult,
+    discoverTestConfig: ()=>discoverTestConfig,
+    validateTestFileSelection: ()=>validateTestFileSelection,
     defineProjectSetup: ()=>defineProjectSetup,
-    discoverSelectedTestFiles: ()=>discoverSelectedTestFiles,
     discoverTestFiles: ()=>discoverTestFiles,
-    defineTestProject: ()=>defineTestProject,
-    loadTestProject: ()=>loadTestProject
-});
-const v4_namespaceObject = require("zod/v4");
-const isSafeResultPathSegment = (value)=>'string' == typeof value && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value);
-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 _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
-        }), _define_property(this, "kind", void 0), _define_property(this, "retryable", void 0);
-        this.name = 'TestExecutorError';
-        this.kind = options.kind ?? 'unknown';
-        this.retryable = options.retryable ?? false;
-    }
-}
-const defineTestExecutor = (executor)=>executor;
-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()
+    loadTestProject: ()=>loadTestProject,
+    defineTestProject: ()=>defineTestProject
 });
-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}.`);
-}
-const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
+const external_node_url_namespaceObject = require("node:url");
+const api_namespaceObject = require("tsx/cjs/api");
 const test_runner_namespaceObject = require("@midscene/core/internal/test-runner");
-const external_tinyglobby_namespaceObject = require("tinyglobby");
-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,
-        sourcePath,
-        caseIndex,
-        ...invocationIndex ? [
-            invocationIndex
-        ] : []
-    ])).digest('hex');
-const createDocumentInvocationId = (projectId, sourcePath, invocationIndex = 0)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
-        projectId,
-        sourcePath,
-        ...invocationIndex ? [
-            invocationIndex
-        ] : []
-    ])).digest('hex');
-const normalizeSteps = test_runner_namespaceObject.normalizeSteps;
-const external_js_yaml_namespaceObject = require("js-yaml");
-function parseWorkflowSource(source) {
-    const stack = [];
-    const nodes = [];
-    const sensitiveNodes = new Set();
-    const sensitiveValues = new Set();
-    const redactedPaths = new Set();
-    const sourceOffset = 0xfeff === source.charCodeAt(0) ? 1 : 0;
-    const parsed = (0, external_js_yaml_namespaceObject.load)(source, {
-        schema: external_js_yaml_namespaceObject.JSON_SCHEMA,
-        listener (event, state) {
-            if ('open' === event) return void stack.push({
-                start: state.position + sourceOffset,
-                end: 0,
-                value: null,
-                children: []
-            });
-            const node = stack.pop();
-            node.end = state.position + sourceOffset;
-            node.value = state.result;
-            stack.at(-1)?.children.push(node);
-            nodes.push(node);
-            if ('mapping' !== state.kind) return;
-            for(let index = 0; index < node.children.length; index += 2){
-                const key = node.children[index].value;
-                const value = node.children[index + 1];
-                if ('string' == typeof key && (0, test_runner_namespaceObject.isReportSecretKey)(key) && value) {
-                    sensitiveNodes.add(value);
-                    if (null !== value.value) sensitiveValues.add(value.value);
-                    redactedPaths.add(`$..[${JSON.stringify(key)}]`);
-                }
-            }
+const NodeRegistry = test_runner_namespaceObject.NodeRegistry;
+const projectIdFromIndex = (index)=>`project-${index}`;
+const defineTestProject = (definition)=>definition;
+const defineProjectSetup = (definition)=>definition;
+const getDefaultExport = (loaded, absolutePath)=>{
+    if ('object' == typeof loaded && null !== loaded && 'default' in loaded) {
+        const defaultExport = loaded.default;
+        if ('object' == typeof defaultExport && null !== defaultExport && '__esModule' in defaultExport) {
+            if ('default' in defaultExport) return defaultExport.default;
+            throw new TypeError(`Midscene config "${absolutePath}" must have a default export.`);
         }
-    });
-    const ranges = nodes.filter((node)=>sensitiveNodes.has(node) || sensitiveValues.has(node.value)).sort((left, right)=>left.start - right.start || right.end - left.end);
-    let offset = 0;
-    let redacted = '';
-    for (const range of ranges){
-        if (range.start < offset) continue;
-        const text = source.slice(range.start, range.end);
-        const leading = text.match(/^\s*/)?.[0] ?? '';
-        const trailing = text.slice(leading.length).match(/\s*$/)?.[0] ?? '';
-        redacted += `${source.slice(offset, range.start)}${leading}"[REDACTED]"${trailing}`;
-        offset = range.end;
+        return defaultExport;
     }
-    redacted += source.slice(offset);
-    const value = (0, test_runner_namespaceObject.sanitizeReportText)(redacted, 65536);
-    return {
-        parsed,
-        sourceYaml: {
-            value,
-            ...redactedPaths.size ? {
-                redactedPaths: [
-                    ...redactedPaths
-                ]
-            } : {},
-            ...value !== redacted ? {
-                truncatedPaths: [
-                    '$'
-                ]
-            } : {}
-        }
-    };
-}
-const interpolationExpression = /\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}|\$\{([^{}]+)\}/g;
-const exactEnvExpression = /^\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}$/;
-const exactProjectExpression = /^\$\{([^{}]+)\}$/;
-const missingVariable = (kind, name, options)=>{
-    throw new test_runner_namespaceObject.WorkflowParseError(`Undefined ${kind} variable "${name}" in ${options.location.sourcePath}.`, {
-        ...options.location,
-        variable: name,
-        variableKind: kind
-    });
-};
-const projectVariable = (name, options)=>{
-    if (!Object.hasOwn(options.variables ?? {}, name)) return missingVariable('project', name, options);
-    return options.variables[name];
+    throw new TypeError(`Midscene config "${absolutePath}" must have a default export.`);
 };
-const environmentVariable = (name, options)=>{
-    const value = options.env?.[name];
-    if (void 0 === value) return missingVariable('environment', name, options);
-    return value;
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const rejectUnknownKeys = (value, allowedKeys, label)=>{
+    const allowed = new Set(allowedKeys);
+    const unknown = Object.keys(value).find((key)=>!allowed.has(key));
+    if (unknown) throw new TypeError(`Midscene config ${label}.${unknown} is not supported.`);
 };
-const interpolationValue = (name, value, options)=>{
-    if ('object' == typeof value && null !== value) throw new test_runner_namespaceObject.WorkflowParseError(`Project variable "${name}" must be a primitive when embedded in a string.`, {
-        ...options.location,
-        variable: name,
-        variableKind: 'project'
+const isAbsolutePattern = (pattern)=>(0, external_node_path_namespaceObject.isAbsolute)(pattern) || /^[A-Za-z]:[\\/]/.test(pattern) || pattern.startsWith('\\\\');
+const validatePatterns = (value, field, label = 'files', allowEmptyInclude = false)=>{
+    if (!Array.isArray(value)) throw new TypeError(`Midscene config ${label}.${field} must be an array.`);
+    if ('include' === field && 0 === value.length && !allowEmptyInclude) throw new TypeError(`Midscene config ${label}.include must be a non-empty array.`);
+    return value.map((pattern, index)=>{
+        if ('string' != typeof pattern || 0 === pattern.trim().length) throw new TypeError(`Midscene config ${label}.${field}[${index}] must be a non-empty string.`);
+        if (isAbsolutePattern(pattern)) throw new TypeError(`Midscene config ${label}.${field}[${index}] must be relative to the project root.`);
+        if (pattern.split(/[\\/]/).includes('..')) throw new TypeError(`Midscene config ${label}.${field}[${index}] must not contain a ".." path segment.`);
+        if (pattern.includes('\\')) throw new TypeError(`Midscene config ${label}.${field}[${index}] must use POSIX path separators (/).`);
+        if (pattern.startsWith('!')) {
+            if ('include' === field) throw new TypeError(`Midscene config ${label}.include[${index}] must not be a negated pattern. Use files.exclude instead.`);
+            throw new TypeError(`Midscene config ${label}.exclude[${index}] must not be a negated pattern.`);
+        }
+        return pattern;
     });
-    return String(value);
 };
-const resolveString = (value, options)=>{
-    const exactEnv = exactEnvExpression.exec(value);
-    if (exactEnv) return environmentVariable(exactEnv[1], options);
-    const exactProject = exactProjectExpression.exec(value);
-    if (exactProject) return projectVariable(exactProject[1], options);
-    return value.replace(interpolationExpression, (_match, environmentName, projectName)=>environmentName ? environmentVariable(environmentName, options) : interpolationValue(projectName, projectVariable(projectName, options), options));
+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, [
+        'include',
+        'exclude'
+    ], label);
+    const include = validatePatterns(value.include, 'include', label);
+    const exclude = void 0 === value.exclude ? void 0 : validatePatterns(value.exclude, 'exclude', label);
+    return Object.freeze({
+        include: Object.freeze(include),
+        ...exclude ? {
+            exclude: Object.freeze(exclude)
+        } : {}
+    });
 };
-const resolveWorkflowVariables = (value, options)=>{
-    if ('string' == typeof value) return resolveString(value, options);
-    if (Array.isArray(value)) return value.map((child)=>resolveWorkflowVariables(child, options));
-    if ('object' == typeof value && null !== value) return Object.fromEntries(Object.entries(value).map(([key, child])=>[
-            key,
-            resolveWorkflowVariables(child, options)
-        ]));
-    return value;
+const validateTagList = (value, field, label)=>{
+    if (void 0 === value) return [];
+    if (!Array.isArray(value)) throw new TypeError(`Midscene config ${label}.${field} must be an array.`);
+    return value.map((tag, index)=>{
+        if ('string' != typeof tag || 0 === tag.trim().length) throw new TypeError(`Midscene config ${label}.${field}[${index}] must be a non-empty string.`);
+        return tag;
+    });
 };
-function collect_define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
+const validateTagSelection = (value, label)=>{
+    if (void 0 === value) return Object.freeze({
+        include: [],
+        exclude: []
     });
-    else obj[key] = value;
-    return obj;
-}
-const isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
-class NativeWorkflowFormatError extends test_runner_namespaceObject.WorkflowParseError {
-    constructor(actualFormat, sourcePath){
-        super('legacy' === actualFormat ? `Legacy tasks/flow YAML is not supported by midscene-test: ${sourcePath}. Run it with \`midscene ${sourcePath}\`, or migrate the file to cases/steps.` : 'legacy-batch' === actualFormat ? `Legacy YAML batch configuration is not a midscene-test workflow document: ${sourcePath}. Run it with \`midscene --config ${sourcePath}\`, or migrate it to a native project config.` : `A workflow file cannot mix legacy tasks/flow with native cases/steps or lifecycle hooks: ${sourcePath}. Keep the formats in separate files and run each file with its matching command.`, {
-            sourcePath,
-            actualFormat,
-            expectedFormat: 'native'
-        }), collect_define_property(this, "actualFormat", void 0);
-        this.actualFormat = actualFormat;
-    }
-}
-const rejectUnknownKeys = (value, allowed, label)=>{
-    const allowedSet = new Set(allowed);
-    const unknown = Object.keys(value).filter((key)=>!allowedSet.has(key));
-    if (unknown.length) throw new test_runner_namespaceObject.WorkflowParseError(`${label} has unsupported field "${unknown[0]}".`, {
-        field: unknown[0]
+    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
+    return Object.freeze({
+        include: Object.freeze(validateTagList(value.include, 'include', label)),
+        exclude: Object.freeze(validateTagList(value.exclude, 'exclude', label))
     });
 };
-const createCaseId = (projectId, sourcePath, caseIndex)=>createCaseInvocationId(projectId, sourcePath, caseIndex);
-const createWorkflowDocumentId = (projectId, sourcePath)=>createDocumentInvocationId(projectId, sourcePath);
-function collectWorkflowDocument(source, options) {
-    let snapshot;
-    try {
-        snapshot = parseWorkflowSource((0, external_node_fs_namespaceObject.readFileSync)(source.absolutePath, 'utf8'));
-    } catch (error) {
-        throw new test_runner_namespaceObject.WorkflowParseError(`Failed to parse workflow document "${source.sourcePath}".`, {
-            sourcePath: source.sourcePath
-        }, error);
+function assertJsonValue(value, path, seen) {
+    if (null === value || 'string' == typeof value || 'boolean' == typeof value) return;
+    if ('number' == typeof value) {
+        if (Number.isFinite(value)) return;
+        throw new TypeError(`Midscene config ${path} must be JSON-compatible.`);
     }
-    const { parsed, sourceYaml } = snapshot;
-    if (!isMapping(parsed)) throw new test_runner_namespaceObject.WorkflowParseError('Workflow document must be a mapping.');
-    const format = (0, test_runner_namespaceObject.classifyWorkflowDocumentFormat)(parsed);
-    if ('legacy' === format || 'legacy-batch' === format || 'mixed' === format) throw new NativeWorkflowFormatError(format, source.sourcePath);
-    rejectUnknownKeys(parsed, [
-        'beforeAll',
-        'beforeEach',
-        'cases',
-        'afterEach',
-        'afterAll'
-    ], 'Workflow document');
-    if (!Array.isArray(parsed.cases) || 0 === parsed.cases.length) throw new test_runner_namespaceObject.WorkflowParseError('Workflow document must contain a non-empty cases array.');
-    const sourcePath = source.sourcePath.split(external_node_path_namespaceObject.sep).join('/');
-    const resolveStepVariables = (step, phase, stepIndex, caseIndex)=>({
-            ...step,
-            templateInput: step.input,
-            input: resolveWorkflowVariables(step.input, {
-                variables: options.variables,
-                env: options.env ?? process.env,
-                location: {
-                    projectName: source.projectName ?? source.projectId,
-                    sourcePath,
-                    phase,
-                    stepIndex,
-                    ...void 0 === caseIndex ? {} : {
-                        caseIndex
-                    }
-                }
-            })
-        });
-    const normalizeLifecycle = (phase)=>{
-        const value = parsed[phase];
-        if (void 0 === value) return [];
-        if (!Array.isArray(value)) throw new test_runner_namespaceObject.WorkflowParseError(`Workflow document ${phase} must be an array.`, {
-            phase
-        });
-        return normalizeSteps(value, options.resolveNode).map((normalized, stepIndex)=>{
-            const resolved = options.resolveNode(normalized.node);
-            if (!resolved) throw new test_runner_namespaceObject.WorkflowParseError(`Workflow document ${phase} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
-                phase,
-                stepIndex,
-                node: normalized.node
-            });
-            return resolveStepVariables(normalized, phase, stepIndex);
-        });
-    };
-    const lifecycle = {
-        beforeAll: normalizeLifecycle('beforeAll'),
-        beforeEach: normalizeLifecycle('beforeEach'),
-        afterEach: normalizeLifecycle('afterEach'),
-        afterAll: normalizeLifecycle('afterAll')
-    };
-    const ids = new Set();
-    const cases = parsed.cases.map((definition, caseIndex)=>{
-        if (!isMapping(definition)) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} must be a mapping.`, {
-            caseIndex
-        });
-        rejectUnknownKeys(definition, [
-            'id',
+    if ('object' != typeof value || void 0 === value) throw new TypeError(`Midscene config ${path} must be JSON-compatible.`);
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && null !== Object.getPrototypeOf(value)) throw new TypeError(`Midscene config ${path} must be JSON-compatible.`);
+    if (seen.has(value)) throw new TypeError(`Midscene config ${path} must not contain cycles.`);
+    seen.add(value);
+    if (Array.isArray(value)) value.forEach((item, index)=>assertJsonValue(item, `${path}[${index}]`, seen));
+    else for (const [key, child] of Object.entries(value))assertJsonValue(child, `${path}.${key}`, seen);
+    seen.delete(value);
+}
+const deepFreezeJson = (value)=>{
+    if ('object' == typeof value && null !== value) {
+        for (const child of Object.values(value))deepFreezeJson(child);
+        Object.freeze(value);
+    }
+    return value;
+};
+const validateVariables = (value, label)=>{
+    if (void 0 === value) return Object.freeze({});
+    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
+    assertJsonValue(value, label, new Set());
+    return deepFreezeJson(value);
+};
+const validateSetup = (value, label)=>{
+    if (void 0 === value) return;
+    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
+    rejectUnknownKeys(value, [
+        'name',
+        'setup'
+    ], label);
+    if ('string' != typeof value.name || 0 === value.name.trim().length) throw new TypeError(`Midscene config ${label}.name must be non-empty.`);
+    if ('function' != typeof value.setup) throw new TypeError(`Midscene config ${label}.setup must be a function.`);
+    return value;
+};
+const validatePositiveInteger = (value, fallback, label)=>{
+    if (void 0 === value) return fallback;
+    if (!Number.isInteger(value) || value <= 0) throw new TypeError(`Midscene config ${label} must be a positive integer.`);
+    return value;
+};
+const validateNonNegativeInteger = (value, fallback, label)=>{
+    if (void 0 === value) return fallback;
+    if (!Number.isInteger(value) || value < 0) throw new TypeError(`Midscene config ${label} must be a non-negative integer.`);
+    return value;
+};
+const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
+    if (void 0 === value) {
+        const setup = validateSetup(defaultSetup, 'setup');
+        return {
+            hasExplicitProjects: false,
+            projects: Object.freeze([
+                Object.freeze({
+                    projectId: projectIdFromIndex(0),
+                    name: 'default',
+                    ...setup ? {
+                        setup
+                    } : {},
+                    tags: Object.freeze({
+                        include: [],
+                        exclude: []
+                    }),
+                    retry: 0,
+                    variables: Object.freeze({}),
+                    nodes: new NodeRegistry(globalNodes.definitions())
+                })
+            ])
+        };
+    }
+    if (void 0 !== defaultSetup) throw new TypeError('Midscene config setup cannot be used together with projects. Move setup to projects[].setup.');
+    if (!Array.isArray(value) || 0 === value.length) throw new TypeError('Midscene config projects must be a non-empty array when declared.');
+    const names = new Set();
+    const projects = value.map((candidate, index)=>{
+        const label = `projects[${index}]`;
+        if (!isRecord(candidate)) throw new TypeError(`Midscene config ${label} must be an object.`);
+        rejectUnknownKeys(candidate, [
             'name',
+            'setup',
+            'nodes',
+            'files',
             '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
-        });
-        if (!Array.isArray(definition.steps) || 0 === definition.steps.length) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} steps must be a non-empty array.`, {
-            caseIndex
-        });
-        const tags = definition.tags ?? [];
-        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,
-                stepIndex,
-                node: normalized.node
-            });
-            return resolveStepVariables(normalized, 'steps', stepIndex, 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
-        });
-        ids.add(caseId);
-        return {
-            caseId,
-            projectId: source.projectId,
-            sourcePath,
-            caseIndex,
-            definition: {
-                ...'string' == typeof definition.id ? {
-                    id: definition.id
-                } : {},
-                name: definition.name,
-                tags: tags,
-                ...resources.length > 0 ? {
-                    resources: resources
-                } : {},
-                steps
+            'retry',
+            'variables'
+        ], label);
+        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 = 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([
+            ...globalNodes.definitions().filter((node)=>!localNodes.has(node.name)),
+            ...localNodes.definitions()
+        ]);
+        return Object.freeze({
+            projectId: projectIdFromIndex(index),
+            name: candidate.name,
+            nodes,
+            ...files ? {
+                files
+            } : {},
+            tags: validateTagSelection(candidate.tags, `${label}.tags`),
+            retry: validateNonNegativeInteger(candidate.retry, 0, `${label}.retry`),
+            variables: validateVariables(candidate.variables, `${label}.variables`),
+            ...void 0 === candidate.setup ? {} : {
+                setup: validateSetup(candidate.setup, `${label}.setup`)
             }
-        };
+        });
     });
     return {
-        documentId: createWorkflowDocumentId(source.projectId, sourcePath),
-        projectId: source.projectId,
-        sourcePath,
-        sourceYaml,
-        lifecycle,
-        cases
+        projects: Object.freeze(projects),
+        hasExplicitProjects: true
     };
-}
-const promises_namespaceObject = require("node:fs/promises");
-const writeJson = async (path, value)=>{
-    try {
-        await (0, promises_namespaceObject.mkdir)((0, external_node_path_namespaceObject.dirname)(path), {
-            recursive: true
-        });
-        await (0, promises_namespaceObject.writeFile)(path, JSON.stringify(value, null, 2));
-    } catch (error) {
-        throw new test_runner_namespaceObject.WorkflowPublicationError('write-result', path, error);
-    }
 };
-const writeTestRunPlan = (runDir, projects)=>writeJson((0, external_node_path_namespaceObject.join)(runDir, 'plan.json'), {
-        schemaVersion: 1,
-        createdAt: new Date().toISOString(),
-        projects: projects.map((item)=>({
-                projectId: item.project.projectId,
-                name: item.project.name,
-                documents: item.plans ?? []
-            }))
+const validateTestOptions = (value)=>{
+    if (void 0 !== value && !isRecord(value)) throw new TypeError('Midscene config test must be an object.');
+    const candidate = value ?? {};
+    return Object.freeze({
+        maxConcurrency: validatePositiveInteger(candidate.maxConcurrency, 1, 'test.maxConcurrency'),
+        bail: validateNonNegativeInteger(candidate.bail, 0, 'test.bail'),
+        testTimeout: validatePositiveInteger(candidate.testTimeout, 120000, 'test.testTimeout')
     });
-const toPosix = (value)=>value.split(external_node_path_namespaceObject.sep).join('/');
-const caseAttemptResultPath = (projectId, documentId, result)=>toPosix((0, external_node_path_namespaceObject.join)(projectId, 'documents', documentId, 'cases', result.caseId, `${result.runId}.json`));
-const workflowDocumentResultPath = (result)=>toPosix((0, external_node_path_namespaceObject.join)(result.projectId, 'documents', result.documentId, void 0 === result.attemptIndex ? 'document.json' : `${result.documentRunId}.json`));
-const collectionErrorPath = (projectId, sourcePath)=>{
-    const id = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
-        projectId,
-        sourcePath
-    ])).digest('hex');
-    return toPosix((0, external_node_path_namespaceObject.join)(projectId, 'collection-errors', `${id}.json`));
 };
-const writeWorkflowDocumentResult = (runDir, result)=>{
-    const { documentRunId: _documentRunId, ...persistedResult } = result;
-    return writeJson((0, external_node_path_namespaceObject.join)(runDir, workflowDocumentResultPath(result)), persistedResult);
-};
-const writeCaseAttemptResult = (runDir, projectId, documentId, result)=>{
-    const { runId: attemptId, ...persistedResult } = result;
-    return writeJson((0, external_node_path_namespaceObject.join)(runDir, caseAttemptResultPath(projectId, documentId, result)), {
-        ...persistedResult,
-        attemptId
-    });
+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.`);
+    return value;
 };
-const writeCollectionError = (runDir, collectionError)=>writeJson((0, external_node_path_namespaceObject.join)(runDir, collectionErrorPath(collectionError.projectId, collectionError.sourcePath)), {
-        kind: 'collection-error',
-        ...collectionError
+const validateOutput = (value)=>{
+    if (void 0 !== value && !isRecord(value)) throw new TypeError('Midscene config output must be an object.');
+    const candidate = value ?? {};
+    rejectUnknownKeys(candidate, [
+        'reportDir'
+    ], 'output');
+    return Object.freeze({
+        reportDir: validateOutputPath(candidate.reportDir, './midscene_run/report', 'output.reportDir')
     });
-const relativeToSummary = (summaryPath, target)=>{
-    const value = (0, external_node_path_namespaceObject.relative)((0, external_node_path_namespaceObject.dirname)(summaryPath), target);
-    return toPosix(value || '.');
 };
-const errorJson = test_runner_namespaceObject.sanitizeReportError;
-const writeTestProjectRunResult = (options)=>{
-    const { result } = options;
-    const fact = (path)=>toPosix(path);
-    return writeJson(result.summaryPath, {
-        schemaVersion: result.schemaVersion,
-        runId: result.runId,
-        startedAt: result.startedAt,
-        endedAt: result.endedAt,
-        durationMs: result.durationMs,
-        status: result.status,
-        exitCode: result.exitCode,
-        ...result.errors?.length ? {
-            errors: result.errors.map(errorJson)
-        } : {},
-        projectRoot: options.projectRoot,
-        ...options.configPath ? {
-            configPath: options.configPath
-        } : {},
-        factsRoot: '.',
-        plan: 'plan.json',
-        ...result.operationLog ? {
-            operationLog: {
-                ...result.operationLog,
-                path: relativeToSummary(result.summaryPath, result.operationLog.path)
-            }
-        } : {},
-        reportDir: relativeToSummary(result.summaryPath, result.reportDir),
-        ...result.reportPath ? {
-            report: relativeToSummary(result.summaryPath, result.reportPath)
-        } : {},
-        ...result.markdownPath ? {
-            markdown: relativeToSummary(result.summaryPath, result.markdownPath)
-        } : {},
-        summary: result.summary,
-        projects: result.projects.map((project)=>({
-                projectId: project.projectId,
-                name: project.name,
-                status: project.status,
-                retry: project.retry,
-                fileSelection: project.fileSelection,
-                tagSelection: project.tagSelection,
-                sourceCount: project.sourceCount,
-                selectedCaseCount: project.selectedCaseCount,
-                filteredCaseCount: project.filteredCaseCount,
-                ...project.lifecycle ? {
-                    lifecycle: {
-                        status: project.lifecycle.status,
-                        startedAt: project.lifecycle.startedAt,
-                        endedAt: project.lifecycle.endedAt,
-                        durationMs: project.lifecycle.durationMs,
-                        ...project.lifecycle.cleanup ? {
-                            cleanup: project.lifecycle.cleanup
-                        } : {},
-                        ...project.lifecycle.pendingOperations ? {
-                            pendingOperations: project.lifecycle.pendingOperations
-                        } : {},
-                        ...project.lifecycle.setupError ? {
-                            setupError: errorJson(project.lifecycle.setupError)
-                        } : {},
-                        ...project.lifecycle.teardownErrors ? {
-                            teardownErrors: project.lifecycle.teardownErrors.map(errorJson)
-                        } : {}
-                    }
-                } : {},
-                cases: project.cases.map((outcome)=>({
-                        ...outcome.documentRunId ? {
-                            documentRunId: outcome.documentRunId
-                        } : {},
-                        documentId: outcome.documentId,
-                        caseId: outcome.caseId,
-                        sourcePath: outcome.sourcePath,
-                        caseIndex: outcome.caseIndex,
-                        name: outcome.name,
-                        status: outcome.status,
-                        ...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,
-                                    attemptIndex: attempt.attemptIndex,
-                                    status: attempt.status,
-                                    ...attempt.cleanup ? {
-                                        cleanup: attempt.cleanup
-                                    } : {},
-                                    ...attempt.pendingOperations ? {
-                                        pendingOperations: attempt.pendingOperations
-                                    } : {},
-                                    ...attempt.executionStatus ? {
-                                        executionStatus: attempt.executionStatus
-                                    } : {},
-                                    ...attempt.retryDecision ? {
-                                        retryDecision: attempt.retryDecision
-                                    } : {},
-                                    resultFile: fact(caseAttemptResultPath(project.projectId, outcome.documentId, attempt)),
-                                    ...attempt.reportPaths?.length ? {
-                                        reports: attempt.reportPaths.map((path)=>relativeToSummary(result.summaryPath, path))
-                                    } : {}
-                                }))
-                        } : {}
-                    })),
-                documents: project.documents.map((document)=>({
-                        documentId: document.documentId,
-                        ...void 0 === document.attemptIndex ? {} : {
-                            attemptIndex: document.attemptIndex,
-                            documentRunId: document.documentRunId
-                        },
-                        sourcePath: document.sourcePath,
-                        status: document.status,
-                        ...document.cleanup ? {
-                            cleanup: document.cleanup
-                        } : {},
-                        ...document.pendingOperations ? {
-                            pendingOperations: document.pendingOperations
-                        } : {},
-                        ...document.executionStatus ? {
-                            executionStatus: document.executionStatus
-                        } : {},
-                        ...document.retryDecision ? {
-                            retryDecision: document.retryDecision
-                        } : {},
-                        resultFile: fact(workflowDocumentResultPath(document)),
-                        ...document.reportPaths?.length ? {
-                            reports: document.reportPaths.map((path)=>relativeToSummary(result.summaryPath, path))
-                        } : {}
-                    })),
-                collectionErrors: project.collectionErrors.map((error)=>({
-                        sourcePath: error.sourcePath,
-                        errorFile: fact(collectionErrorPath(error.projectId, error.sourcePath))
-                    }))
-            }))
-    });
+const validateTestProjectDefinition = (definition)=>{
+    if (!isRecord(definition)) throw new TypeError('Midscene config must default export an object.');
+    if (void 0 !== definition.nodes && !Array.isArray(definition.nodes)) throw new TypeError('Midscene config nodes must be an array.');
+    if ('setupWorkflow' in definition) throw new TypeError('Midscene config setupWorkflow is no longer supported. Use setup or projects[].setup instead.');
+    if ('setupDocument' in definition) throw new TypeError('Midscene config setupDocument is not supported. Use setup or projects[].setup for resources, and beforeAll/afterAll for document lifecycle steps.');
+    if ('root' in definition) throw new TypeError('Midscene config root is not supported. Pass the Test Project directory to midscene-test instead.');
+    if ('files' in definition) throw new TypeError('Midscene config files is not supported at the root. Move it to projects[].files.');
+    if ('testRunner' in definition) throw new TypeError('Midscene config testRunner is not supported. Rename it to test.');
+    rejectUnknownKeys(definition, [
+        'setup',
+        'projects',
+        'test',
+        'output',
+        'nodes'
+    ], 'root');
+    const nodes = new NodeRegistry(definition.nodes);
+    const resolvedProjects = validateExecutionProjects(definition.projects, definition.setup, nodes);
+    return {
+        ...resolvedProjects,
+        test: validateTestOptions(definition.test),
+        output: validateOutput(definition.output),
+        nodes,
+        resolveNode: (name)=>nodes.get(name)
+    };
 };
-const external_node_url_namespaceObject = require("node:url");
-const api_namespaceObject = require("tsx/cjs/api");
-const NodeRegistry = test_runner_namespaceObject.NodeRegistry;
-const projectIdFromIndex = (index)=>`project-${index}`;
-const defineTestProject = (definition)=>definition;
-const defineProjectSetup = (definition)=>definition;
-const getDefaultExport = (loaded, absolutePath)=>{
-    if ('object' == typeof loaded && null !== loaded && 'default' in loaded) {
-        const defaultExport = loaded.default;
-        if ('object' == typeof defaultExport && null !== defaultExport && '__esModule' in defaultExport) {
-            if ('default' in defaultExport) return defaultExport.default;
-            throw new TypeError(`Midscene config "${absolutePath}" must have a default export.`);
-        }
-        return defaultExport;
+const assertSupportedConfig = (absolutePath)=>{
+    if (!absolutePath.endsWith('.ts') && !absolutePath.endsWith('.mjs')) {
+        const extension = absolutePath.match(/(\.[^./\\]+)$/)?.[1] ?? '(none)';
+        throw new TypeError(`Unsupported Midscene config extension: ${extension}. Supported extensions: .ts, .mjs.`);
     }
-    throw new TypeError(`Midscene config "${absolutePath}" must have a default export.`);
+    return absolutePath.endsWith('.mjs') ? '.mjs' : '.ts';
 };
-const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
-const test_project_rejectUnknownKeys = (value, allowedKeys, label)=>{
-    const allowed = new Set(allowedKeys);
-    const unknown = Object.keys(value).find((key)=>!allowed.has(key));
-    if (unknown) throw new TypeError(`Midscene config ${label}.${unknown} is not supported.`);
+const canRetryWithCjsLoader = (error)=>{
+    if (!(error instanceof Error)) return false;
+    const errorCode = error.code;
+    return error instanceof SyntaxError && /^Unexpected (?:identifier|reserved word|token)/.test(error.message) || 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX' === errorCode || 'ERR_UNKNOWN_FILE_EXTENSION' === errorCode && /^Unknown file extension\b/.test(error.message);
 };
-const isAbsolutePattern = (pattern)=>(0, external_node_path_namespaceObject.isAbsolute)(pattern) || /^[A-Za-z]:[\\/]/.test(pattern) || pattern.startsWith('\\\\');
-const validatePatterns = (value, field, label = 'files', allowEmptyInclude = false)=>{
-    if (!Array.isArray(value)) throw new TypeError(`Midscene config ${label}.${field} must be an array.`);
-    if ('include' === field && 0 === value.length && !allowEmptyInclude) throw new TypeError(`Midscene config ${label}.include must be a non-empty array.`);
-    return value.map((pattern, index)=>{
-        if ('string' != typeof pattern || 0 === pattern.trim().length) throw new TypeError(`Midscene config ${label}.${field}[${index}] must be a non-empty string.`);
-        if (isAbsolutePattern(pattern)) throw new TypeError(`Midscene config ${label}.${field}[${index}] must be relative to the project root.`);
-        if (pattern.split(/[\\/]/).includes('..')) throw new TypeError(`Midscene config ${label}.${field}[${index}] must not contain a ".." path segment.`);
-        if (pattern.includes('\\')) throw new TypeError(`Midscene config ${label}.${field}[${index}] must use POSIX path separators (/).`);
-        if (pattern.startsWith('!')) {
-            if ('include' === field) throw new TypeError(`Midscene config ${label}.include[${index}] must not be a negated pattern. Use files.exclude instead.`);
-            throw new TypeError(`Midscene config ${label}.exclude[${index}] must not be a negated pattern.`);
-        }
-        return pattern;
+async function loadTestProject(configPath) {
+    if (!configPath) return validateTestProjectDefinition({
+        nodes: []
     });
-};
-const validateTestFileSelection = (value, label = 'files')=>{
-    if (void 0 === value) return;
-    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
-    test_project_rejectUnknownKeys(value, [
-        'include',
-        'exclude'
-    ], label);
-    const include = validatePatterns(value.include, 'include', label);
-    const exclude = void 0 === value.exclude ? void 0 : validatePatterns(value.exclude, 'exclude', label);
-    return Object.freeze({
-        include: Object.freeze(include),
-        ...exclude ? {
-            exclude: Object.freeze(exclude)
-        } : {}
+    const absolutePath = (0, external_node_path_namespaceObject.resolve)(configPath);
+    const extension = assertSupportedConfig(absolutePath);
+    let loaded;
+    try {
+        if ('.mjs' === extension) loaded = await import((0, external_node_url_namespaceObject.pathToFileURL)(absolutePath).href);
+        else {
+            const { tsImport } = await import("tsx/esm/api");
+            loaded = await tsImport((0, external_node_url_namespaceObject.pathToFileURL)(absolutePath).href, {
+                parentURL: (0, external_node_url_namespaceObject.pathToFileURL)(`${(0, external_node_path_namespaceObject.dirname)(absolutePath)}${external_node_path_namespaceObject.sep}`).href,
+                tsconfig: false
+            });
+        }
+    } catch (error) {
+        try {
+            if ('.mjs' === extension || !canRetryWithCjsLoader(error)) throw error;
+            loaded = (0, api_namespaceObject.require)(absolutePath, (0, external_node_url_namespaceObject.pathToFileURL)(absolutePath));
+        } catch (fallbackError) {
+            const message = fallbackError instanceof Error ? `: ${fallbackError.message}` : '';
+            throw new Error(`Failed to load Midscene config "${absolutePath}"${message}`, {
+                cause: fallbackError
+            });
+        }
+    }
+    return validateTestProjectDefinition(getDefaultExport(loaded, absolutePath));
+}
+const external_node_fs_namespaceObject = require("node:fs");
+const external_tinyglobby_namespaceObject = require("tinyglobby");
+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,
+        sourcePath,
+        caseIndex,
+        ...invocationIndex ? [
+            invocationIndex
+        ] : []
+    ])).digest('hex');
+const createDocumentInvocationId = (projectId, sourcePath, invocationIndex = 0)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
+        projectId,
+        sourcePath,
+        ...invocationIndex ? [
+            invocationIndex
+        ] : []
+    ])).digest('hex');
+const normalizeSteps = test_runner_namespaceObject.normalizeSteps;
+const external_js_yaml_namespaceObject = require("js-yaml");
+function parseWorkflowSource(source) {
+    const stack = [];
+    const nodes = [];
+    const sensitiveNodes = new Set();
+    const sensitiveValues = new Set();
+    const redactedPaths = new Set();
+    const sourceOffset = 0xfeff === source.charCodeAt(0) ? 1 : 0;
+    const parsed = (0, external_js_yaml_namespaceObject.load)(source, {
+        schema: external_js_yaml_namespaceObject.JSON_SCHEMA,
+        listener (event, state) {
+            if ('open' === event) return void stack.push({
+                start: state.position + sourceOffset,
+                end: 0,
+                value: null,
+                children: []
+            });
+            const node = stack.pop();
+            node.end = state.position + sourceOffset;
+            node.value = state.result;
+            stack.at(-1)?.children.push(node);
+            nodes.push(node);
+            if ('mapping' !== state.kind) return;
+            for(let index = 0; index < node.children.length; index += 2){
+                const key = node.children[index].value;
+                const value = node.children[index + 1];
+                if ('string' == typeof key && (0, test_runner_namespaceObject.isReportSecretKey)(key) && value) {
+                    sensitiveNodes.add(value);
+                    if (null !== value.value) sensitiveValues.add(value.value);
+                    redactedPaths.add(`$..[${JSON.stringify(key)}]`);
+                }
+            }
+        }
     });
-};
-const validateTagList = (value, field, label)=>{
-    if (void 0 === value) return [];
-    if (!Array.isArray(value)) throw new TypeError(`Midscene config ${label}.${field} must be an array.`);
-    return value.map((tag, index)=>{
-        if ('string' != typeof tag || 0 === tag.trim().length) throw new TypeError(`Midscene config ${label}.${field}[${index}] must be a non-empty string.`);
-        return tag;
+    const ranges = nodes.filter((node)=>sensitiveNodes.has(node) || sensitiveValues.has(node.value)).sort((left, right)=>left.start - right.start || right.end - left.end);
+    let offset = 0;
+    let redacted = '';
+    for (const range of ranges){
+        if (range.start < offset) continue;
+        const text = source.slice(range.start, range.end);
+        const leading = text.match(/^\s*/)?.[0] ?? '';
+        const trailing = text.slice(leading.length).match(/\s*$/)?.[0] ?? '';
+        redacted += `${source.slice(offset, range.start)}${leading}"[REDACTED]"${trailing}`;
+        offset = range.end;
+    }
+    redacted += source.slice(offset);
+    const value = (0, test_runner_namespaceObject.sanitizeReportText)(redacted, 65536);
+    return {
+        parsed,
+        sourceYaml: {
+            value,
+            ...redactedPaths.size ? {
+                redactedPaths: [
+                    ...redactedPaths
+                ]
+            } : {},
+            ...value !== redacted ? {
+                truncatedPaths: [
+                    '$'
+                ]
+            } : {}
+        }
+    };
+}
+const interpolationExpression = /\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}|\$\{([^{}]+)\}/g;
+const exactEnvExpression = /^\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}$/;
+const exactProjectExpression = /^\$\{([^{}]+)\}$/;
+const missingVariable = (kind, name, options)=>{
+    throw new test_runner_namespaceObject.WorkflowParseError(`Undefined ${kind} variable "${name}" in ${options.location.sourcePath}.`, {
+        ...options.location,
+        variable: name,
+        variableKind: kind
     });
 };
-const validateTagSelection = (value, label)=>{
-    if (void 0 === value) return Object.freeze({
-        include: [],
-        exclude: []
-    });
-    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
-    return Object.freeze({
-        include: Object.freeze(validateTagList(value.include, 'include', label)),
-        exclude: Object.freeze(validateTagList(value.exclude, 'exclude', label))
-    });
+const projectVariable = (name, options)=>{
+    if (!Object.hasOwn(options.variables ?? {}, name)) return missingVariable('project', name, options);
+    return options.variables[name];
 };
-function assertJsonValue(value, path, seen) {
-    if (null === value || 'string' == typeof value || 'boolean' == typeof value) return;
-    if ('number' == typeof value) {
-        if (Number.isFinite(value)) return;
-        throw new TypeError(`Midscene config ${path} must be JSON-compatible.`);
-    }
-    if ('object' != typeof value || void 0 === value) throw new TypeError(`Midscene config ${path} must be JSON-compatible.`);
-    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && null !== Object.getPrototypeOf(value)) throw new TypeError(`Midscene config ${path} must be JSON-compatible.`);
-    if (seen.has(value)) throw new TypeError(`Midscene config ${path} must not contain cycles.`);
-    seen.add(value);
-    if (Array.isArray(value)) value.forEach((item, index)=>assertJsonValue(item, `${path}[${index}]`, seen));
-    else for (const [key, child] of Object.entries(value))assertJsonValue(child, `${path}.${key}`, seen);
-    seen.delete(value);
-}
-const deepFreezeJson = (value)=>{
-    if ('object' == typeof value && null !== value) {
-        for (const child of Object.values(value))deepFreezeJson(child);
-        Object.freeze(value);
-    }
+const environmentVariable = (name, options)=>{
+    const value = options.env?.[name];
+    if (void 0 === value) return missingVariable('environment', name, options);
     return value;
 };
-const validateVariables = (value, label)=>{
-    if (void 0 === value) return Object.freeze({});
-    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
-    assertJsonValue(value, label, new Set());
-    return deepFreezeJson(value);
+const interpolationValue = (name, value, options)=>{
+    if ('object' == typeof value && null !== value) throw new test_runner_namespaceObject.WorkflowParseError(`Project variable "${name}" must be a primitive when embedded in a string.`, {
+        ...options.location,
+        variable: name,
+        variableKind: 'project'
+    });
+    return String(value);
 };
-const validateSetup = (value, label)=>{
-    if (void 0 === value) return;
-    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
-    test_project_rejectUnknownKeys(value, [
-        'name',
-        'setup'
-    ], label);
-    if ('string' != typeof value.name || 0 === value.name.trim().length) throw new TypeError(`Midscene config ${label}.name must be non-empty.`);
-    if ('function' != typeof value.setup) throw new TypeError(`Midscene config ${label}.setup must be a function.`);
-    return value;
+const resolveString = (value, options)=>{
+    const exactEnv = exactEnvExpression.exec(value);
+    if (exactEnv) return environmentVariable(exactEnv[1], options);
+    const exactProject = exactProjectExpression.exec(value);
+    if (exactProject) return projectVariable(exactProject[1], options);
+    return value.replace(interpolationExpression, (_match, environmentName, projectName)=>environmentName ? environmentVariable(environmentName, options) : interpolationValue(projectName, projectVariable(projectName, options), options));
 };
-const validatePositiveInteger = (value, fallback, label)=>{
-    if (void 0 === value) return fallback;
-    if (!Number.isInteger(value) || value <= 0) throw new TypeError(`Midscene config ${label} must be a positive integer.`);
+const resolveWorkflowVariables = (value, options)=>{
+    if ('string' == typeof value) return resolveString(value, options);
+    if (Array.isArray(value)) return value.map((child)=>resolveWorkflowVariables(child, options));
+    if ('object' == typeof value && null !== value) return Object.fromEntries(Object.entries(value).map(([key, child])=>[
+            key,
+            resolveWorkflowVariables(child, options)
+        ]));
     return value;
 };
-const validateNonNegativeInteger = (value, fallback, label)=>{
-    if (void 0 === value) return fallback;
-    if (!Number.isInteger(value) || value < 0) throw new TypeError(`Midscene config ${label} must be a non-negative integer.`);
-    return value;
+function _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;
+}
+const isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+class NativeWorkflowFormatError extends test_runner_namespaceObject.WorkflowParseError {
+    constructor(actualFormat, sourcePath){
+        super('legacy' === actualFormat ? `Legacy tasks/flow YAML is not supported by midscene-test: ${sourcePath}. Run it with \`midscene ${sourcePath}\`, or migrate the file to cases/steps.` : 'legacy-batch' === actualFormat ? `Legacy YAML batch configuration is not a midscene-test workflow document: ${sourcePath}. Run it with \`midscene --config ${sourcePath}\`, or migrate it to a native project config.` : `A workflow file cannot mix legacy tasks/flow with native cases/steps or lifecycle hooks: ${sourcePath}. Keep the formats in separate files and run each file with its matching command.`, {
+            sourcePath,
+            actualFormat,
+            expectedFormat: 'native'
+        }), _define_property(this, "actualFormat", void 0);
+        this.actualFormat = actualFormat;
+    }
+}
+const collect_rejectUnknownKeys = (value, allowed, label)=>{
+    const allowedSet = new Set(allowed);
+    const unknown = Object.keys(value).filter((key)=>!allowedSet.has(key));
+    if (unknown.length) throw new test_runner_namespaceObject.WorkflowParseError(`${label} has unsupported field "${unknown[0]}".`, {
+        field: unknown[0]
+    });
 };
-const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
-    if (void 0 === value) {
-        const setup = validateSetup(defaultSetup, 'setup');
-        return {
-            hasExplicitProjects: false,
-            projects: Object.freeze([
-                Object.freeze({
-                    projectId: projectIdFromIndex(0),
-                    name: 'default',
-                    ...setup ? {
-                        setup
-                    } : {},
-                    tags: Object.freeze({
-                        include: [],
-                        exclude: []
-                    }),
-                    retry: 0,
-                    variables: Object.freeze({}),
-                    nodes: new NodeRegistry(globalNodes.definitions())
-                })
-            ])
-        };
+const createCaseId = (projectId, sourcePath, caseIndex)=>createCaseInvocationId(projectId, sourcePath, caseIndex);
+const createWorkflowDocumentId = (projectId, sourcePath)=>createDocumentInvocationId(projectId, sourcePath);
+function collectWorkflowDocument(source, options) {
+    let snapshot;
+    try {
+        snapshot = parseWorkflowSource((0, external_node_fs_namespaceObject.readFileSync)(source.absolutePath, 'utf8'));
+    } catch (error) {
+        throw new test_runner_namespaceObject.WorkflowParseError(`Failed to parse workflow document "${source.sourcePath}".`, {
+            sourcePath: source.sourcePath
+        }, error);
     }
-    if (void 0 !== defaultSetup) throw new TypeError('Midscene config setup cannot be used together with projects. Move setup to projects[].setup.');
-    if (!Array.isArray(value) || 0 === value.length) throw new TypeError('Midscene config projects must be a non-empty array when declared.');
-    const names = new Set();
-    const projects = value.map((candidate, index)=>{
-        const label = `projects[${index}]`;
-        if (!isRecord(candidate)) throw new TypeError(`Midscene config ${label} must be an object.`);
-        test_project_rejectUnknownKeys(candidate, [
+    const { parsed, sourceYaml } = snapshot;
+    if (!isMapping(parsed)) throw new test_runner_namespaceObject.WorkflowParseError('Workflow document must be a mapping.');
+    const format = (0, test_runner_namespaceObject.classifyWorkflowDocumentFormat)(parsed);
+    if ('legacy' === format || 'legacy-batch' === format || 'mixed' === format) throw new NativeWorkflowFormatError(format, source.sourcePath);
+    collect_rejectUnknownKeys(parsed, [
+        'beforeAll',
+        'beforeEach',
+        'cases',
+        'afterEach',
+        'afterAll'
+    ], 'Workflow document');
+    if (!Array.isArray(parsed.cases) || 0 === parsed.cases.length) throw new test_runner_namespaceObject.WorkflowParseError('Workflow document must contain a non-empty cases array.');
+    const sourcePath = source.sourcePath.split(external_node_path_namespaceObject.sep).join('/');
+    const resolveStepVariables = (step, phase, stepIndex, caseIndex)=>({
+            ...step,
+            templateInput: step.input,
+            input: resolveWorkflowVariables(step.input, {
+                variables: options.variables,
+                env: options.env ?? process.env,
+                location: {
+                    projectName: source.projectName ?? source.projectId,
+                    sourcePath,
+                    phase,
+                    stepIndex,
+                    ...void 0 === caseIndex ? {} : {
+                        caseIndex
+                    }
+                }
+            })
+        });
+    const normalizeLifecycle = (phase)=>{
+        const value = parsed[phase];
+        if (void 0 === value) return [];
+        if (!Array.isArray(value)) throw new test_runner_namespaceObject.WorkflowParseError(`Workflow document ${phase} must be an array.`, {
+            phase
+        });
+        return normalizeSteps(value, options.resolveNode).map((normalized, stepIndex)=>{
+            const resolved = options.resolveNode(normalized.node);
+            if (!resolved) throw new test_runner_namespaceObject.WorkflowParseError(`Workflow document ${phase} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
+                phase,
+                stepIndex,
+                node: normalized.node
+            });
+            return resolveStepVariables(normalized, phase, stepIndex);
+        });
+    };
+    const lifecycle = {
+        beforeAll: normalizeLifecycle('beforeAll'),
+        beforeEach: normalizeLifecycle('beforeEach'),
+        afterEach: normalizeLifecycle('afterEach'),
+        afterAll: normalizeLifecycle('afterAll')
+    };
+    const ids = new Set();
+    const cases = parsed.cases.map((definition, caseIndex)=>{
+        if (!isMapping(definition)) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} must be a mapping.`, {
+            caseIndex
+        });
+        collect_rejectUnknownKeys(definition, [
             'name',
-            'setup',
-            'nodes',
-            'files',
             'tags',
-            'retry',
-            'variables'
-        ], label);
-        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 = 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([
-            ...globalNodes.definitions().filter((node)=>!localNodes.has(node.name)),
-            ...localNodes.definitions()
-        ]);
-        return Object.freeze({
-            projectId: projectIdFromIndex(index),
-            name: candidate.name,
-            nodes,
-            ...files ? {
-                files
-            } : {},
-            tags: validateTagSelection(candidate.tags, `${label}.tags`),
-            retry: validateNonNegativeInteger(candidate.retry, 0, `${label}.retry`),
-            variables: validateVariables(candidate.variables, `${label}.variables`),
-            ...void 0 === candidate.setup ? {} : {
-                setup: validateSetup(candidate.setup, `${label}.setup`)
-            }
+            'steps'
+        ], `Case ${caseIndex + 1}`);
+        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
+        });
+        if (!Array.isArray(definition.steps) || 0 === definition.steps.length) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} steps must be a non-empty array.`, {
+            caseIndex
+        });
+        const tags = definition.tags ?? [];
+        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 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,
+                stepIndex,
+                node: normalized.node
+            });
+            return resolveStepVariables(normalized, 'steps', stepIndex, caseIndex);
+        });
+        const caseId = createCaseId(source.projectId, sourcePath, caseIndex);
+        if (ids.has(caseId)) throw new test_runner_namespaceObject.WorkflowParseError(`Case id collision: ${caseId}.`, {
+            caseId
         });
+        ids.add(caseId);
+        return {
+            caseId,
+            projectId: source.projectId,
+            sourcePath,
+            caseIndex,
+            definition: {
+                name: definition.name,
+                tags: tags,
+                steps
+            }
+        };
     });
     return {
-        projects: Object.freeze(projects),
-        hasExplicitProjects: true
+        documentId: createWorkflowDocumentId(source.projectId, sourcePath),
+        projectId: source.projectId,
+        sourcePath,
+        sourceYaml,
+        lifecycle,
+        cases
     };
+}
+const promises_namespaceObject = require("node:fs/promises");
+const writeJson = async (path, value)=>{
+    try {
+        await (0, promises_namespaceObject.mkdir)((0, external_node_path_namespaceObject.dirname)(path), {
+            recursive: true
+        });
+        await (0, promises_namespaceObject.writeFile)(path, JSON.stringify(value, null, 2));
+    } catch (error) {
+        throw new test_runner_namespaceObject.WorkflowPublicationError('write-result', path, error);
+    }
 };
-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'),
-        executionUnit,
-        executorRetry: validateNonNegativeInteger(candidate.executorRetry, 0, 'test.executorRetry')
+const writeTestRunPlan = (runDir, projects)=>writeJson((0, external_node_path_namespaceObject.join)(runDir, 'plan.json'), {
+        schemaVersion: 1,
+        createdAt: new Date().toISOString(),
+        projects: projects.map((item)=>({
+                projectId: item.project.projectId,
+                name: item.project.name,
+                documents: item.plans ?? []
+            }))
     });
+const toPosix = (value)=>value.split(external_node_path_namespaceObject.sep).join('/');
+const caseAttemptResultPath = (projectId, documentId, result)=>toPosix((0, external_node_path_namespaceObject.join)(projectId, 'documents', documentId, 'cases', result.caseId, `${result.runId}.json`));
+const workflowDocumentResultPath = (result)=>toPosix((0, external_node_path_namespaceObject.join)(result.projectId, 'documents', result.documentId, void 0 === result.attemptIndex ? 'document.json' : `${result.documentRunId}.json`));
+const collectionErrorPath = (projectId, sourcePath)=>{
+    const id = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
+        projectId,
+        sourcePath
+    ])).digest('hex');
+    return toPosix((0, external_node_path_namespaceObject.join)(projectId, 'collection-errors', `${id}.json`));
 };
-const validateTestExecutor = (value)=>{
-    if (void 0 === value) return;
-    if (!isRecord(value)) throw new TypeError('Midscene config executor must be an object.');
-    test_project_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 writeWorkflowDocumentResult = (runDir, result)=>{
+    const { documentRunId: _documentRunId, ...persistedResult } = result;
+    return writeJson((0, external_node_path_namespaceObject.join)(runDir, workflowDocumentResultPath(result)), persistedResult);
 };
-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.`);
-    return value;
+const writeCaseAttemptResult = (runDir, projectId, documentId, result)=>{
+    const { runId: attemptId, ...persistedResult } = result;
+    return writeJson((0, external_node_path_namespaceObject.join)(runDir, caseAttemptResultPath(projectId, documentId, result)), {
+        ...persistedResult,
+        attemptId
+    });
 };
-const validateOutput = (value)=>{
-    if (void 0 !== value && !isRecord(value)) throw new TypeError('Midscene config output must be an object.');
-    const candidate = value ?? {};
-    test_project_rejectUnknownKeys(candidate, [
-        'reportDir'
-    ], 'output');
-    return Object.freeze({
-        reportDir: validateOutputPath(candidate.reportDir, './midscene_run/report', 'output.reportDir')
+const writeCollectionError = (runDir, collectionError)=>writeJson((0, external_node_path_namespaceObject.join)(runDir, collectionErrorPath(collectionError.projectId, collectionError.sourcePath)), {
+        kind: 'collection-error',
+        ...collectionError
     });
+const relativeToSummary = (summaryPath, target)=>{
+    const value = (0, external_node_path_namespaceObject.relative)((0, external_node_path_namespaceObject.dirname)(summaryPath), target);
+    return toPosix(value || '.');
 };
-const validateTestProjectDefinition = (definition)=>{
-    if (!isRecord(definition)) throw new TypeError('Midscene config must default export an object.');
-    if (void 0 !== definition.nodes && !Array.isArray(definition.nodes)) throw new TypeError('Midscene config nodes must be an array.');
-    if ('setupWorkflow' in definition) throw new TypeError('Midscene config setupWorkflow is no longer supported. Use setup or projects[].setup instead.');
-    if ('setupDocument' in definition) throw new TypeError('Midscene config setupDocument is not supported. Use setup or projects[].setup for resources, and beforeAll/afterAll for document lifecycle steps.');
-    if ('root' in definition) throw new TypeError('Midscene config root is not supported. Pass the Test Project directory to midscene-test instead.');
-    if ('files' in definition) throw new TypeError('Midscene config files is not supported at the root. Move it to projects[].files.');
-    if ('testRunner' in definition) throw new TypeError('Midscene config testRunner is not supported. Rename it to test.');
-    test_project_rejectUnknownKeys(definition, [
-        'setup',
-        'projects',
-        'test',
-        'output',
-        '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,
-        output: validateOutput(definition.output),
-        nodes,
-        ...executor ? {
-            executor
+const errorJson = test_runner_namespaceObject.sanitizeReportError;
+const writeTestProjectRunResult = (options)=>{
+    const { result } = options;
+    const fact = (path)=>toPosix(path);
+    return writeJson(result.summaryPath, {
+        schemaVersion: result.schemaVersion,
+        runId: result.runId,
+        startedAt: result.startedAt,
+        endedAt: result.endedAt,
+        durationMs: result.durationMs,
+        status: result.status,
+        exitCode: result.exitCode,
+        ...result.errors?.length ? {
+            errors: result.errors.map(errorJson)
         } : {},
-        resolveNode: (name)=>nodes.get(name)
-    };
-};
-const assertSupportedConfig = (absolutePath)=>{
-    if (!absolutePath.endsWith('.ts') && !absolutePath.endsWith('.mjs')) {
-        const extension = absolutePath.match(/(\.[^./\\]+)$/)?.[1] ?? '(none)';
-        throw new TypeError(`Unsupported Midscene config extension: ${extension}. Supported extensions: .ts, .mjs.`);
-    }
-    return absolutePath.endsWith('.mjs') ? '.mjs' : '.ts';
-};
-const canRetryWithCjsLoader = (error)=>{
-    if (!(error instanceof Error)) return false;
-    const errorCode = error.code;
-    return error instanceof SyntaxError && /^Unexpected (?:identifier|reserved word|token)/.test(error.message) || 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX' === errorCode || 'ERR_UNKNOWN_FILE_EXTENSION' === errorCode && /^Unknown file extension\b/.test(error.message);
-};
-async function loadTestProject(configPath) {
-    if (!configPath) return validateTestProjectDefinition({
-        nodes: []
+        projectRoot: options.projectRoot,
+        ...options.configPath ? {
+            configPath: options.configPath
+        } : {},
+        factsRoot: '.',
+        plan: 'plan.json',
+        ...result.operationLog ? {
+            operationLog: {
+                ...result.operationLog,
+                path: relativeToSummary(result.summaryPath, result.operationLog.path)
+            }
+        } : {},
+        reportDir: relativeToSummary(result.summaryPath, result.reportDir),
+        ...result.reportPath ? {
+            report: relativeToSummary(result.summaryPath, result.reportPath)
+        } : {},
+        ...result.markdownPath ? {
+            markdown: relativeToSummary(result.summaryPath, result.markdownPath)
+        } : {},
+        summary: result.summary,
+        projects: result.projects.map((project)=>({
+                projectId: project.projectId,
+                name: project.name,
+                status: project.status,
+                retry: project.retry,
+                fileSelection: project.fileSelection,
+                tagSelection: project.tagSelection,
+                sourceCount: project.sourceCount,
+                selectedCaseCount: project.selectedCaseCount,
+                filteredCaseCount: project.filteredCaseCount,
+                ...project.lifecycle ? {
+                    lifecycle: {
+                        status: project.lifecycle.status,
+                        startedAt: project.lifecycle.startedAt,
+                        endedAt: project.lifecycle.endedAt,
+                        durationMs: project.lifecycle.durationMs,
+                        ...project.lifecycle.cleanup ? {
+                            cleanup: project.lifecycle.cleanup
+                        } : {},
+                        ...project.lifecycle.pendingOperations ? {
+                            pendingOperations: project.lifecycle.pendingOperations
+                        } : {},
+                        ...project.lifecycle.setupError ? {
+                            setupError: errorJson(project.lifecycle.setupError)
+                        } : {},
+                        ...project.lifecycle.teardownErrors ? {
+                            teardownErrors: project.lifecycle.teardownErrors.map(errorJson)
+                        } : {}
+                    }
+                } : {},
+                cases: project.cases.map((outcome)=>({
+                        ...outcome.documentRunId ? {
+                            documentRunId: outcome.documentRunId
+                        } : {},
+                        documentId: outcome.documentId,
+                        caseId: outcome.caseId,
+                        sourcePath: outcome.sourcePath,
+                        caseIndex: outcome.caseIndex,
+                        name: outcome.name,
+                        status: outcome.status,
+                        ...outcome.notRunReason ? {
+                            notRunReason: outcome.notRunReason
+                        } : {},
+                        ...outcome.attempts ? {
+                            attempts: outcome.attempts.map((attempt)=>({
+                                    attemptId: attempt.runId,
+                                    attemptIndex: attempt.attemptIndex,
+                                    status: attempt.status,
+                                    ...attempt.cleanup ? {
+                                        cleanup: attempt.cleanup
+                                    } : {},
+                                    ...attempt.pendingOperations ? {
+                                        pendingOperations: attempt.pendingOperations
+                                    } : {},
+                                    ...attempt.executionStatus ? {
+                                        executionStatus: attempt.executionStatus
+                                    } : {},
+                                    ...attempt.retryDecision ? {
+                                        retryDecision: attempt.retryDecision
+                                    } : {},
+                                    resultFile: fact(caseAttemptResultPath(project.projectId, outcome.documentId, attempt)),
+                                    ...attempt.reportPaths?.length ? {
+                                        reports: attempt.reportPaths.map((path)=>relativeToSummary(result.summaryPath, path))
+                                    } : {}
+                                }))
+                        } : {}
+                    })),
+                documents: project.documents.map((document)=>({
+                        documentId: document.documentId,
+                        ...void 0 === document.attemptIndex ? {} : {
+                            attemptIndex: document.attemptIndex,
+                            documentRunId: document.documentRunId
+                        },
+                        sourcePath: document.sourcePath,
+                        status: document.status,
+                        ...document.cleanup ? {
+                            cleanup: document.cleanup
+                        } : {},
+                        ...document.pendingOperations ? {
+                            pendingOperations: document.pendingOperations
+                        } : {},
+                        ...document.executionStatus ? {
+                            executionStatus: document.executionStatus
+                        } : {},
+                        ...document.retryDecision ? {
+                            retryDecision: document.retryDecision
+                        } : {},
+                        resultFile: fact(workflowDocumentResultPath(document)),
+                        ...document.reportPaths?.length ? {
+                            reports: document.reportPaths.map((path)=>relativeToSummary(result.summaryPath, path))
+                        } : {}
+                    })),
+                collectionErrors: project.collectionErrors.map((error)=>({
+                        sourcePath: error.sourcePath,
+                        errorFile: fact(collectionErrorPath(error.projectId, error.sourcePath))
+                    }))
+            }))
     });
-    const absolutePath = (0, external_node_path_namespaceObject.resolve)(configPath);
-    const extension = assertSupportedConfig(absolutePath);
-    let loaded;
-    try {
-        if ('.mjs' === extension) loaded = await import((0, external_node_url_namespaceObject.pathToFileURL)(absolutePath).href);
-        else {
-            const { tsImport } = await import("tsx/esm/api");
-            loaded = await tsImport((0, external_node_url_namespaceObject.pathToFileURL)(absolutePath).href, {
-                parentURL: (0, external_node_url_namespaceObject.pathToFileURL)(`${(0, external_node_path_namespaceObject.dirname)(absolutePath)}${external_node_path_namespaceObject.sep}`).href,
-                tsconfig: false
-            });
-        }
-    } catch (error) {
-        try {
-            if ('.mjs' === extension || !canRetryWithCjsLoader(error)) throw error;
-            loaded = (0, api_namespaceObject.require)(absolutePath, (0, external_node_url_namespaceObject.pathToFileURL)(absolutePath));
-        } catch (fallbackError) {
-            const message = fallbackError instanceof Error ? `: ${fallbackError.message}` : '';
-            throw new Error(`Failed to load Midscene config "${absolutePath}"${message}`, {
-                cause: fallbackError
-            });
-        }
-    }
-    return validateTestProjectDefinition(getDefaultExport(loaded, absolutePath));
-}
+};
 const CONFIG_NAMES = [
     'midscene.config.ts',
     'midscene.config.mjs'
@@ -1321,27 +791,6 @@ const DEFAULT_TEST_FILE_SELECTION = {
     ]
 };
 const project_preparation_toPosix = (value)=>value.split(external_node_path_namespaceObject.sep).join('/');
-const discoverSelectedTestFiles = (projectRoot, paths)=>{
-    const root = (0, external_node_path_namespaceObject.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_namespaceObject.resolve)(root, requestedPath);
-        const relativePath = (0, external_node_path_namespaceObject.relative)(root, absolutePath);
-        if ('..' === relativePath || relativePath.startsWith(`..${external_node_path_namespaceObject.sep}`) || (0, external_node_path_namespaceObject.isAbsolute)(relativePath)) throw new Error(`Test selection path is outside the project: ${requestedPath}`);
-        if (!(0, external_node_fs_namespaceObject.existsSync)(absolutePath)) throw new Error(`Test selection path does not exist: ${requestedPath}`);
-        if ((0, external_node_fs_namespaceObject.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_namespaceObject.relative)(root, a));
-        const relativeB = project_preparation_toPosix((0, external_node_path_namespaceObject.relative)(root, b));
-        return relativeA < relativeB ? -1 : relativeA > relativeB ? 1 : 0;
-    });
-};
 const discoverResolvedTestFiles = (projectRoot, selection)=>{
     const root = (0, external_node_path_namespaceObject.resolve)(projectRoot);
     const match = (patterns)=>(0, external_tinyglobby_namespaceObject.globSync)(patterns, {
@@ -1401,14 +850,8 @@ const matchesTags = (tags, selection)=>{
     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, 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 filterDocumentCases = (document, project)=>{
+    const cases = document.cases.filter((item)=>matchesTags(item.definition.tags ?? [], project.tags));
     const filtered = document.cases.length - cases.length;
     return 0 === cases.length ? {
         filtered
@@ -1433,9 +876,7 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
     const platform = options.platform?.trim();
     const fileSelection = project.files ?? DEFAULT_TEST_FILE_SELECTION;
     const prerequisiteFile = options.prerequisiteFile ? (0, external_node_path_namespaceObject.resolve)(options.prerequisiteFile) : void 0;
-    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 mainFiles = options.files ?? discoverResolvedTestFiles(projectRoot, fileSelection);
     const files = [
         ...prerequisiteFile ? [
             prerequisiteFile
@@ -1458,7 +899,6 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
     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,
@@ -1489,16 +929,10 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
             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, options.selection);
+        } : filterDocumentCases(document, project);
         const plan = (0, test_runner_namespaceObject.buildTestRunReportPlan)(document, {
             selectedCaseIds: filtered.document?.cases.map((item)=>item.caseId) ?? [],
             defaultTimeoutMs,
@@ -1546,42 +980,9 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
         plans,
         collectionErrors,
         selectedCaseCount: documents.reduce((total, document)=>total + document.cases.length, 0),
-        filteredCaseCount,
-        availableCaseIds: [
-            ...availableCaseIds
-        ]
+        filteredCaseCount
     };
 }
-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 = [
@@ -1619,7 +1020,6 @@ async function prepareTestRun(options) {
     const startedAt = new Date();
     const runId = createTestRunId(startedAt);
     const input = resolveRunInput(options);
-    const selection = validateRunSelection(options);
     const configPath = options.configPath ? (0, external_node_path_namespaceObject.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_namespaceObject.existsSync)(configPath)) throw new Error(`Midscene config does not exist: ${configPath}`);
@@ -1633,20 +1033,11 @@ async function prepareTestRun(options) {
     });
     (0, external_node_fs_namespaceObject.mkdirSync)(runDir);
     const projects = [];
-    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.');
+    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));
     const hasFormatMismatch = projects.some((project)=>project.collectionErrors.some(({ error })=>error instanceof NativeWorkflowFormatError));
     return {
         startedAt,
@@ -1745,601 +1136,20 @@ async function writeTestResultMarkdown(result, index = emptyIndex()) {
     }));
     return output;
 }
-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 stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
 const formatStep = (info)=>{
-    const position = 'case' === info.scope ? info.case : info.document;
+    const position = stepPosition(info);
     const phase = 'steps' === position.phase ? 'step' : position.phase;
     return `${phase} ${position.stepIndex + 1}/${info.stepCount}: ${info.node}`;
 };
-const formatStepResult = (info, result, indent = '')=>{
+const formatStepResult = (info, result)=>{
+    const indent = 'case' === info.scope ? '      ' : '    ';
     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
-    };
-};
-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_namespaceObject.realpathSync)(source.dumpPath);
-            const reference = (0, external_node_crypto_namespaceObject.randomUUID)();
-            const destination = (0, external_node_path_namespaceObject.join)(outputDir, 'reports', reference);
-            (0, external_node_fs_namespaceObject.mkdirSync)(destination, {
-                recursive: true
-            });
-            const dumpPath = (0, external_node_path_namespaceObject.join)(destination, 'snapshot.json');
-            (0, external_node_fs_namespaceObject.cpSync)(dump, dumpPath);
-            const screenshots = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(dump), 'screenshots');
-            if ((0, external_node_fs_namespaceObject.existsSync)(screenshots)) (0, external_node_fs_namespaceObject.cpSync)(screenshots, (0, external_node_path_namespaceObject.join)(destination, 'screenshots'), {
-                recursive: true,
-                dereference: true
-            });
-            const sourcePath = (0, external_node_path_namespaceObject.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_namespaceObject.realpathSync)(sourcePath);
-            const entry = (0, external_node_fs_namespaceObject.statSync)(source).isDirectory() ? (0, external_node_path_namespaceObject.join)(source, 'index.html') : source;
-            if (!(0, external_node_fs_namespaceObject.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_namespaceObject.join)(outputDir, 'reports', reference);
-            (0, external_node_fs_namespaceObject.mkdirSync)(destination, {
-                recursive: true
-            });
-            const isDirectoryReport = 'index.html' === (0, external_node_path_namespaceObject.basename)(entry);
-            const reportPath = (0, external_node_path_namespaceObject.join)(destination, isDirectoryReport ? 'index.html' : 'report.html');
-            (0, external_node_fs_namespaceObject.cpSync)(isDirectoryReport ? (0, external_node_path_namespaceObject.dirname)(entry) : entry, isDirectoryReport ? destination : reportPath, {
-                recursive: isDirectoryReport,
-                dereference: true
-            });
-            if (!isDirectoryReport) {
-                const screenshots = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(entry), 'screenshots');
-                if ((0, external_node_fs_namespaceObject.existsSync)(screenshots)) (0, external_node_fs_namespaceObject.cpSync)(screenshots, (0, external_node_path_namespaceObject.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_namespaceObject.join)(options.runDir, task.projectId, 'executor-output', task.documentId, task.caseId);
-    (0, external_node_fs_namespaceObject.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,
@@ -2385,7 +1195,7 @@ async function executeDocumentInvocation(options) {
             },
             onStepResult: async (info, result)=>{
                 await invocation.bindings.onStepResult?.(info, result);
-                options.onProgress(formatStepResult(info, result, 'case' === info.scope ? '      ' : '    '));
+                options.onProgress(formatStepResult(info, result));
             },
             onCaseResult: async (attempt)=>{
                 await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
@@ -2503,6 +1313,16 @@ function createOperationJournal(runDir) {
         }
     };
 }
+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)=>[
@@ -2536,6 +1356,12 @@ const summarize = (projects)=>{
         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;
@@ -2548,7 +1374,7 @@ async function runPreparedTestProject(plan) {
     await writeTestRunPlan(runDir, preparedProjects);
     const journal = createOperationJournal(runDir);
     const rootController = new AbortController();
-    (0, external_node_events_namespaceObject.setMaxListeners)(Math.max(10, ('case' === definition.test.executionUnit ? Math.min(definition.test.maxConcurrency, totalCases) : effectiveConcurrency) + 1), rootController.signal);
+    (0, external_node_events_namespaceObject.setMaxListeners)(Math.max(10, effectiveConcurrency + 1), rootController.signal);
     const handleSignal = (signal)=>{
         rootController.abort(new Error(`Workflow interrupted by ${signal}.`));
     };
@@ -2590,6 +1416,31 @@ async function runPreparedTestProject(plan) {
         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), []);
@@ -2690,7 +1541,7 @@ async function runPreparedTestProject(plan) {
     };
     const projectResults = new Array(preparedProjects.length);
     try {
-        if ('case' !== definition.test.executionUnit || 'run' === plan.preflightScope && totalErrors > 0) await (0, test_runner_namespaceObject.runConcurrentJobs)(preparedProjects, {
+        await (0, test_runner_namespaceObject.runConcurrentJobs)(preparedProjects, {
             concurrency: effectiveConcurrency,
             shouldStop: ()=>hasInfrastructureError || rootController.signal.aborted || bailReached()
         }, async (prepared, index)=>{
@@ -2701,20 +1552,6 @@ async function runPreparedTestProject(plan) {
                 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{
@@ -2821,32 +1658,22 @@ async function runTestProject(options = {}) {
     return runPreparedTestProject(await prepareTestRun(options));
 }
 exports.DEFAULT_TEST_FILE_SELECTION = __webpack_exports__.DEFAULT_TEST_FILE_SELECTION;
-exports.TestExecutorError = __webpack_exports__.TestExecutorError;
-exports.assertTestCaseTaskRunResult = __webpack_exports__.assertTestCaseTaskRunResult;
 exports.createTestRunId = __webpack_exports__.createTestRunId;
 exports.defineProjectSetup = __webpack_exports__.defineProjectSetup;
-exports.defineTestExecutor = __webpack_exports__.defineTestExecutor;
 exports.defineTestProject = __webpack_exports__.defineTestProject;
-exports.discoverSelectedTestFiles = __webpack_exports__.discoverSelectedTestFiles;
 exports.discoverTestConfig = __webpack_exports__.discoverTestConfig;
 exports.discoverTestFiles = __webpack_exports__.discoverTestFiles;
 exports.loadTestProject = __webpack_exports__.loadTestProject;
-exports.localTestExecutor = __webpack_exports__.localTestExecutor;
 exports.runTestProject = __webpack_exports__.runTestProject;
 exports.validateTestFileSelection = __webpack_exports__.validateTestFileSelection;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "DEFAULT_TEST_FILE_SELECTION",
-    "TestExecutorError",
-    "assertTestCaseTaskRunResult",
     "createTestRunId",
     "defineProjectSetup",
-    "defineTestExecutor",
     "defineTestProject",
-    "discoverSelectedTestFiles",
     "discoverTestConfig",
     "discoverTestFiles",
     "loadTestProject",
-    "localTestExecutor",
     "runTestProject",
     "validateTestFileSelection"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];