@midscene/test 1.17.8-beta-20261106101231.0 → 1.17.8

package/dist/es/164.mjs

@@ -0,0 +1,1469 @@
+import string_width from "string-width";
+import { DEFAULT_TEST_FILE_SELECTION, fileURLToPath, prepareTestRun, discoverTestConfig, inspect, formatModelUsage, stripVTControlCharacters, CliModelUsage, runPreparedTestProject, loadTestProject } from "./299.mjs";
+import { sep, realpathSync, resolve, statSync, existsSync, isAbsolute, appendFileSync, relative, win32, writeFileSync } from "./154.mjs";
+import { WorkflowExecutionFailure, sanitizeReportValue } from "./793.mjs";
+import { chalk } from "./946.mjs";
+import { renderTestBadgeLines } from "./431.mjs";
+import { z } from "./487.mjs";
+import { runWithConsoleLogHandler } from "./470.mjs";
+var package_namespaceObject = {
+    rE: "1.17.8"
+};
+const formatCliError = (error)=>'string' == typeof error ? error : inspect(error, {
+        colors: false,
+        depth: null,
+        customInspect: false
+    });
+function formatConciseError(error) {
+    const seen = new Set();
+    const messages = [];
+    let current = error;
+    while(current instanceof Error && !seen.has(current)){
+        seen.add(current);
+        if ('NODE_EXECUTION_ERROR' === current.code && void 0 !== current.cause) {
+            current = current.cause;
+            continue;
+        }
+        if (current.message && !messages.includes(current.message)) messages.push(current.message);
+        if (current instanceof AggregateError) {
+            for (const nested of current.errors)if (!(nested === current || seen.has(nested))) {
+                seen.add(nested);
+                messages.push(nested instanceof Error ? nested.message : String(nested));
+            }
+        }
+        current = current.cause;
+    }
+    if (!messages.length) return current instanceof Error ? current.message : formatCliError(current);
+    return messages.join('\nCaused by: ');
+}
+const oneLine = (value)=>stripVTControlCharacters(value).replace(/\s+/g, ' ').trim();
+const shorten = (value, length)=>{
+    const text = oneLine(value);
+    return text.length <= length ? text : `${text.slice(0, length - 1)}…`;
+};
+function unwrapFrameLocation(location) {
+    if (!location.endsWith(')')) return location;
+    const absoluteStart = location.search(/ \((?:file:\/\/|[A-Za-z]:[\\/]|\/|\\\\)/);
+    if (-1 !== absoluteStart) return location.slice(absoluteStart + 2, -1);
+    let depth = 0;
+    for(let index = location.length - 1; index >= 0; index--)if (')' === location[index]) depth++;
+    else if ('(' === location[index] && 0 === --depth) return ' ' === location[index - 1] ? location.slice(index + 1, -1) : location;
+    return location;
+}
+function firstBusinessFrame(error, projectRoot) {
+    const seen = new Set();
+    const frames = [];
+    const visit = (value, depth = 0)=>{
+        if (!value || 'object' != typeof value || seen.has(value) || depth > 12) return;
+        seen.add(value);
+        const detail = value;
+        visit(detail.cause, depth + 1);
+        if (Array.isArray(detail.errors)) for (const child of detail.errors.slice(0, 10))visit(child, depth + 1);
+        if ('string' != typeof detail.stack) return;
+        for (const line of detail.stack.split('\n')){
+            if (!line.trim().startsWith('at ')) continue;
+            const location = unwrapFrameLocation(line.trim().slice(3).replace(/^async /, ''));
+            const match = location.match(/^(.*):(\d+):(\d+)$/);
+            if (!match) continue;
+            let file = match[1];
+            if (file.startsWith('file://')) try {
+                file = fileURLToPath(file);
+            } catch  {
+                continue;
+            }
+            const normalized = file.replace(/\\/g, '/');
+            if (!(normalized.startsWith('node:') || normalized.includes('/node_modules/') || /(?:^|\/)packages\/(?:core|test|shared|web-integration)\/(?:dist|src)\//.test(normalized)) && /\.[cm]?[jt]sx?$/.test(normalized)) frames.push(`${file}:${match[2]}:${match[3]}`);
+        }
+    };
+    visit(error);
+    const chosen = frames[0];
+    if (!chosen || !projectRoot) return chosen;
+    const match = chosen.match(/^(.*):(\d+):(\d+)$/);
+    const file = match[1];
+    const paths = /^[A-Za-z]:[\\/]/.test(file) ? win32 : {
+        isAbsolute: isAbsolute,
+        relative: relative
+    };
+    const display = paths.isAbsolute(file) ? paths.relative(projectRoot, file) : file;
+    return `${display.replace(/\\/g, '/')}:${match[2]}:${match[3]}`;
+}
+function formatFailureInput(input) {
+    if (void 0 === input) return [];
+    const value = sanitizeReportValue(input).value;
+    const render = (value)=>shorten('string' == typeof value ? value : inspect(value, {
+            colors: false,
+            depth: 2,
+            maxArrayLength: 4,
+            maxStringLength: 180,
+            breakLength: 1 / 0,
+            customInspect: false,
+            getters: false
+        }), 160);
+    if (value && 'object' == typeof value && !Array.isArray(value)) {
+        const entries = Object.entries(value);
+        const rows = entries.slice(0, 4).map(([key, value])=>`${shorten(key, 48)}: ${render(value)}`);
+        if (entries.length > 4) rows.push(`… ${entries.length - 4} more fields (see Summary)`);
+        return rows;
+    }
+    return [
+        render(value)
+    ];
+}
+function formatFailureDetails(source, error, context = {}) {
+    const title = context.projectName ? `[${oneLine(context.projectName)}] ${oneLine(context.caseName ?? context.sourcePath ?? context.phase ?? source)}` : oneLine(source);
+    const body = [];
+    const field = (label, value)=>body.push(`  ${label.padEnd(9)}${value}`);
+    const step = context.step;
+    if (step) {
+        const phase = 'steps' === step.phase ? '' : `${step.phase} `;
+        const index = step.stepIndex + 1;
+        const position = void 0 === context.stepCount ? String(index) : `${index}/${Math.max(index, context.stepCount)}`;
+        field('Step', `${phase}${position} · ${oneLine(step.node)}`);
+    } else if (context.phase) field('Phase', oneLine(context.phase));
+    if (context.sourcePath) {
+        const location = step?.meta.sourceLocation;
+        field('Location', `${oneLine(context.sourcePath)}${location ? `:${location.line}` : ''}`);
+    }
+    for (const [label, attempt] of [
+        [
+            'Attempt',
+            context.attempt
+        ],
+        [
+            'File try',
+            context.fileAttempt
+        ]
+    ])if (attempt && (attempt.total > 1 || attempt.index > 0)) field(label, `${attempt.index + 1}/${attempt.total}`);
+    if (body.length) body.push('');
+    const lines = stripVTControlCharacters(formatConciseError(error)).split(/\r?\n/);
+    body.push(`  Error: ${shorten(lines[0], 320)}`, ...lines.slice(1, 6).map((line)=>`         ${shorten(line, 320)}`));
+    if (lines.length > 6) body.push('         … (use --reporter verbose for details)');
+    const input = step ? formatFailureInput(step.input) : [];
+    if (input.length) {
+        body.push('');
+        input.forEach((line, index)=>field(0 === index ? 'Input' : '', line));
+    }
+    const frame = firstBusinessFrame(error, context.projectRoot);
+    if (frame) body.push('', `  at ${oneLine(frame)}`);
+    return {
+        title,
+        body
+    };
+}
+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 graphemes = new Intl.Segmenter(void 0, {
+    granularity: 'grapheme'
+});
+const SYNC_START = '\u001b[?2026h';
+const SYNC_END = '\u001b[?2026l';
+const truncateTerminalLine = (text, columns)=>{
+    if (columns <= 0) return '';
+    if (string_width(text) <= columns) return text;
+    let output = '';
+    let width = 0;
+    for (const { segment } of graphemes.segment(stripVTControlCharacters(text))){
+        width += string_width(segment);
+        if (width > columns - 1) break;
+        output += segment;
+    }
+    return `${output}…`;
+};
+class TerminalProgress {
+    erase() {
+        if (!this.lines.length) return '';
+        const columns = Math.max(1, this.io.columns ?? 100);
+        const occupiedRows = this.lines.reduce((sum, line)=>sum + Math.max(1, Math.ceil(string_width(line) / columns)), 0);
+        const rows = Math.min(occupiedRows, Math.max(0, (this.io.rows ?? 24) - 1));
+        this.lines = [];
+        return `\r${rows ? `\u001b[${rows}A` : ''}\u001b[0J`;
+    }
+    frame(previousHeight = 0) {
+        const availableRows = Math.max(0, (this.io.rows ?? 24) - 2);
+        const columns = Math.max(0, (this.io.columns ?? 100) - 1);
+        if (!availableRows || !columns) return '';
+        const footer = this.footer.slice(0, availableRows);
+        const budget = availableRows - footer.length;
+        const overflow = this.content.length > budget;
+        const visible = Math.max(0, budget - (overflow ? 1 : 0));
+        const body = this.content.slice(0, visible);
+        if (overflow && budget > 0) body.push(`  … ${this.content.length - visible} more rows`);
+        const lines = [
+            ...body,
+            ...footer
+        ].map((line)=>truncateTerminalLine(line, columns));
+        const blanks = Math.max(0, Math.min(previousHeight, availableRows) - lines.length);
+        this.lines = [
+            ...Array.from({
+                length: blanks
+            }, ()=>''),
+            ...lines
+        ];
+        return this.lines.length ? `${this.lines.join('\n')}\n` : '';
+    }
+    render(content, footer) {
+        this.update(content, footer);
+        const previousHeight = this.lines.length;
+        const erase = this.erase();
+        this.io.write?.(`${SYNC_START}${erase}${this.frame(previousHeight)}${SYNC_END}`);
+    }
+    update(content, footer) {
+        this.content = content;
+        this.footer = footer;
+    }
+    output(message, write) {
+        this.io.write?.(SYNC_START);
+        try {
+            const erase = this.erase();
+            if (erase) this.io.write?.(erase);
+            write(message.endsWith('\n') ? message : `${message}\n`);
+            const frame = this.frame();
+            if (frame) this.io.write?.(frame);
+        } finally{
+            this.io.write?.(SYNC_END);
+        }
+    }
+    clear() {
+        const erase = this.erase();
+        this.content = [];
+        this.footer = [];
+        if (erase) this.io.write?.(`${SYNC_START}${erase}${SYNC_END}`);
+    }
+    constructor(io){
+        _define_property(this, "io", void 0);
+        _define_property(this, "lines", void 0);
+        _define_property(this, "content", void 0);
+        _define_property(this, "footer", void 0);
+        this.io = io;
+        this.lines = [];
+        this.content = [];
+        this.footer = [];
+    }
+}
+const warning_format_oneLine = (text)=>stripVTControlCharacters(text).replace(/\s+/g, ' ').trim();
+function formatWarningScope(scope) {
+    if (!scope) return '';
+    const parts = [
+        `[${warning_format_oneLine(scope.projectName)}]`
+    ];
+    if (scope.sourcePath) parts.push(warning_format_oneLine(scope.sourcePath));
+    if (scope.caseName) parts.push(warning_format_oneLine(scope.caseName));
+    if (scope.phase) {
+        const phase = 'steps' === scope.phase ? 'step' : scope.phase;
+        parts.push(`${phase}${void 0 === scope.stepIndex ? '' : `[${scope.stepIndex + 1}]`}${scope.node ? ` ${warning_format_oneLine(scope.node)}` : ''}`);
+    }
+    return `${parts.join(' › ')} · `;
+}
+function errorMessage(error) {
+    const seen = new Set();
+    let current = error;
+    let message = '';
+    let status;
+    while(current && 'object' == typeof current && !seen.has(current)){
+        seen.add(current);
+        const detail = current;
+        if ('string' == typeof detail.message) message = detail.message;
+        if ('number' == typeof detail.status) status = detail.status;
+        current = detail.cause;
+    }
+    const firstLine = warning_format_oneLine((message || String(error)).split(/\r?\n/)[0]);
+    return status && !firstLine.startsWith(String(status)) ? `${status}: ${firstLine}` : firstLine;
+}
+function formatWarning(entry) {
+    const details = entry.warning;
+    let message;
+    if (details?.kind === 'model-request-retry') message = `model request retry ${details.attempt + 1}/${details.maxAttempts} in ${details.delayMs / 1000}s (${warning_format_oneLine(details.modelName)}): ${errorMessage(details.error)}`;
+    else {
+        const error = entry.args?.find((arg)=>arg instanceof Error);
+        const prefix = 'string' == typeof entry.args?.[0] ? warning_format_oneLine(entry.args[0].split(/\r?\n/)[0]).replace(/:\s*$/, '') : '';
+        message = error ? `${prefix ? `${prefix}: ` : ''}${errorMessage(error)}` : warning_format_oneLine(entry.message.split(/\r?\n/)[0]);
+        message = message.replace(/^\[midscene:warning\]\s*/, '');
+    }
+    if (message.startsWith('waitForNetworkIdle is skipped for Playwright.')) message = 'Playwright: post-action network-idle wait skipped.';
+    return message.length > 240 ? `${message.slice(0, 239)}…` : message;
+}
+function warningKey(entry, message) {
+    const details = entry.warning;
+    if (details?.kind === 'model-request-retry') return `${entry.topic}\n${JSON.stringify(entry.scope)}\n${details.callId}\n${details.attempt}`;
+    const scope = entry.args?.some((arg)=>arg instanceof Error) ? JSON.stringify(entry.scope) : '';
+    return `${entry.topic}\n${scope}\n${message}`;
+}
+function terminal_reporter_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 terminal_reporter_oneLine = (value)=>stripVTControlCharacters(value).replace(/\s+/g, ' ').trim();
+const formatDuration = (ms)=>{
+    if (ms < 1000) return `${Math.round(ms)}ms`;
+    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m ${Math.floor(ms % 60000 / 1000)}s`;
+};
+const identity = (project, path, name)=>`[${terminal_reporter_oneLine(project)}] ${terminal_reporter_oneLine(path)}${name ? ` › ${terminal_reporter_oneLine(name)}` : ''}`;
+const projectPhaseLabel = (phase)=>'setup' === phase ? 'setting up' : 'cleaning up';
+const fileStatus = (status, cases)=>{
+    if ('failed' === status || cases.some((item)=>'failed' === item.status)) return 'failed';
+    if (cases.length && cases.every((item)=>'not-run' === item.status)) return 'not-run';
+    if (cases.some((item)=>'not-run' === item.status)) return 'failed';
+    return status ?? (cases.length ? 'success' : 'not-run');
+};
+class TerminalReporter {
+    get interactive() {
+        return !!this.io.isTTY && !!this.io.write && 'default' === this.mode;
+    }
+    log(message) {
+        if (this.interactive) this.output(`${message}\n`, (text)=>this.io.write(text));
+        else this.io.log(message);
+        this.lastOutput = Date.now();
+    }
+    output(message, write) {
+        this.renderProgress(false);
+        this.progressView.output(message, write);
+        this.lastOutput = Date.now();
+    }
+    progress(message) {
+        if ('verbose' === this.mode) this.log(message);
+    }
+    console(entry) {
+        if ('report' === entry.type) {
+            if ('verbose' === this.mode) this.log(entry.message);
+            return;
+        }
+        const scope = formatWarningScope(entry.scope);
+        if ('verbose' === this.mode) {
+            const kind = entry.warning?.kind === 'model-request-retry' ? 'model request retry · ' : entry.warning?.kind === 'model-request-detail' ? 'model request error · ' : '';
+            this.log(`WARN ${scope}${kind}${entry.message}`);
+            return;
+        }
+        if (entry.warning?.kind === 'model-request-detail') return;
+        const message = formatWarning(entry);
+        const key = warningKey(entry, message);
+        if (this.warnings.has(key)) return;
+        this.warnings.set(key, {
+            scope,
+            message
+        });
+        if (this.interactive) {
+            let attached = false;
+            if (entry.warning?.kind === 'model-request-retry' && entry.scope) {
+                const owner = entry.scope;
+                for (const [id, task] of this.active)if (task.file.projectName === owner.projectName && (!owner.sourcePath || task.file.sourcePath === owner.sourcePath) && (!owner.caseId || id === owner.caseId) && (!owner.runId || task.runId === owner.runId) && (!owner.phase || task.phase === owner.phase) && (void 0 === owner.stepIndex || task.stepIndex === owner.stepIndex)) {
+                    task.warning = message;
+                    attached = true;
+                }
+            }
+            if (!attached) this.latestNotice = message.startsWith('Playwright:') ? 'Playwright: network-idle wait skipped.' : `${scope}${message}`;
+            this.schedule();
+            return;
+        }
+        this.log(`${this.color.yellow('WARN')} ${this.color.dim(scope)}${message}`);
+    }
+    file(projectName, sourcePath, total = 0) {
+        const key = `${projectName}\0${sourcePath}`;
+        let file = this.files.get(key);
+        if (!file) {
+            file = {
+                projectName,
+                sourcePath,
+                total,
+                outcomes: new Map(),
+                attemptOutcomes: new Map(),
+                started: false,
+                printed: false,
+                durationMs: 0,
+                retries: 0,
+                completionOrder: 0
+            };
+            this.files.set(key, file);
+        }
+        file.total = Math.max(file.total, total);
+        return file;
+    }
+    event(event) {
+        if ('run-start' === event.type) {
+            this.total = event.cases;
+            this.totalFiles = event.documents;
+            this.startedAt = event.startedAt ? Date.parse(event.startedAt) : Date.now();
+            for (const file of event.files ?? [])this.file(file.projectName, file.sourcePath, file.cases);
+            const c = this.color;
+            this.log(`\n ${c.bgGreen.black.bold(' RUN ')} ${c.green(`midscene-test v${package_namespaceObject.rE}`)} ${c.dim(terminal_reporter_oneLine(event.projectRoot ?? process.cwd()))}`);
+            this.log(` ${c.dim(`${event.projects} projects · ${event.documents} files · ${event.cases} cases`)}`);
+            if (void 0 !== event.maxConcurrentProjects && void 0 !== event.maxConcurrentFiles) this.log(` ${c.dim(`Concurrency ${event.maxConcurrentProjects ?? 'unlimited'} projects · ${event.maxConcurrentFiles ?? 'unlimited'} files (global limits)`)}`);
+            if (event.configPath) this.log(` ${c.dim(`Config ${terminal_reporter_oneLine(event.configPath)}`)}`);
+            for (const model of event.configuredModels ?? [])this.log(` ${c.dim('Models (env)')} ${terminal_reporter_oneLine(model.name)} ${c.dim(`· ${model.intents.map(terminal_reporter_oneLine).join(', ')}`)}`);
+            this.log('');
+            if ('default' === this.mode) {
+                this.timer = setInterval(()=>this.tick(), this.interactive ? 1000 : 30000);
+                this.timer.unref();
+                if (this.interactive) this.removeResizeListener = this.io.onResize?.(()=>this.renderProgress());
+                this.renderProgress();
+            }
+        } else if ('project-end' === event.type) {
+            this.completeProject(event.project);
+            this.schedule();
+        } else if ('project-phase' === event.type) {
+            if ('running' === event.phase) this.projectPhases.delete(event.projectName);
+            else this.projectPhases.set(event.projectName, {
+                phase: event.phase,
+                since: Date.now()
+            });
+            this.schedule();
+        } else if ('document-start' === event.type) {
+            this.file(event.projectName, event.sourcePath, event.cases).started = true;
+            this.schedule();
+        } else if ('document-end' === event.type) {
+            const file = this.file(event.document.projectName, event.document.sourcePath, event.cases.length);
+            file.status = fileStatus(event.document.status, event.cases);
+            file.started = true;
+            file.completionOrder = ++this.completionOrder;
+            file.durationMs = event.durationMs;
+            file.retries = event.document.attemptIndex ?? 0;
+            file.outcomes = new Map(event.cases.map((outcome)=>[
+                    outcome.caseId,
+                    outcome
+                ]));
+            file.attemptOutcomes.clear();
+            for (const [key, task] of this.active)if (task.file === file) this.active.delete(key);
+            if (!this.interactive) this.printFile(file);
+            this.schedule();
+        } else if ('step-start' === event.type) this.startStep(event.projectName, event.info);
+        else if ('step-end' === event.type) {
+            if (event.result) this.usage.add(event.result);
+            const key = 'case' === event.info.scope ? event.info.case.caseId : event.info.document.documentId;
+            const task = this.active.get(key);
+            if (task) if ('document' === event.info.scope) this.active.delete(key);
+            else {
+                task.step = void 0;
+                task.warning = void 0;
+            }
+            this.schedule();
+        } else if ('case-attempt-end' === event.type) this.attempts.set(event.attempt.caseId, {
+            run: event.attempt,
+            max: event.maxAttempts
+        });
+        else if ('case-end' === event.type || 'case-progress' === event.type) {
+            const file = this.file(event.outcome.projectName, event.outcome.sourcePath);
+            if ('case-progress' === event.type) {
+                file.attemptOutcomes.set(event.outcome.caseId, event.outcome);
+                file.retries = Math.max(file.retries, event.documentAttemptIndex);
+            } else {
+                file.attemptOutcomes.delete(event.outcome.caseId);
+                file.outcomes.set(event.outcome.caseId, event.outcome);
+                file.retries = Math.max(file.retries, event.documentRetries ?? 0);
+            }
+            this.active.delete(event.outcome.caseId);
+            this.schedule();
+        } else if ('document-retry' === event.type) {
+            const file = this.file(event.document.projectName, event.document.sourcePath);
+            file.outcomes.clear();
+            file.attemptOutcomes.clear();
+            file.status = void 0;
+            file.completionOrder = 0;
+            for (const [key, task] of this.active)if (task.file === file) this.active.delete(key);
+            this.log(this.color.yellow(` ↻ ${identity(file.projectName, file.sourcePath)} · file retry ${(event.document.attemptIndex ?? 0) + 2}/${event.maxAttempts}`));
+            this.schedule();
+        }
+    }
+    startStep(projectName, info) {
+        const position = 'case' === info.scope ? info.case : info.document;
+        const file = this.file(projectName, position.sourcePath);
+        file.started = true;
+        const key = 'case' === info.scope ? info.case.caseId : info.document.documentId;
+        const attempt = 'case' === info.scope ? info.case.attemptIndex : 0;
+        const previous = this.attempts.get(key);
+        if (previous && previous.run.attemptIndex < attempt) {
+            this.attempts.delete(key);
+            if ('default' === this.mode && !this.interactive) this.log(this.color.yellow(` ↻ ${identity(projectName, position.sourcePath, 'case' === info.scope ? info.case.name : void 0)} · case retry · attempt ${attempt + 1}/${previous.max}`));
+        }
+        const existing = this.active.get(key);
+        const now = Date.now();
+        this.active.set(key, {
+            file,
+            name: 'case' === info.scope ? info.case.name : void 0,
+            step: `${'steps' === position.phase ? 'step' : position.phase} ${position.stepIndex + 1}/${info.stepCount} · ${terminal_reporter_oneLine(info.node)}`,
+            since: existing?.attempt === attempt ? existing.since : now,
+            attempt,
+            maxAttempts: previous?.max ?? existing?.maxAttempts,
+            runId: 'case' === info.scope ? info.case.runId : info.document.documentRunId,
+            phase: position.phase,
+            stepIndex: position.stepIndex,
+            caseIndex: 'case' === info.scope ? info.case.caseIndex : void 0
+        });
+        this.schedule();
+    }
+    schedule() {
+        if (!this.interactive || !this.timer || this.scheduled) return;
+        this.scheduled = setTimeout(()=>{
+            this.scheduled = void 0;
+            this.renderProgress();
+        }, 100);
+        this.scheduled.unref();
+    }
+    counts(items, total) {
+        const failed = items.filter((item)=>'failed' === item.status).length;
+        const passed = items.filter((item)=>'success' === item.status).length;
+        const notRun = items.filter((item)=>'not-run' === item.status).length;
+        return this.stateCounts(passed, failed, notRun, total);
+    }
+    stateCounts(passed, failed, notRun, total) {
+        const c = this.color;
+        return [
+            failed ? c.red.bold(`${failed} failed`) : '',
+            c.green.bold(`${passed} passed`),
+            notRun ? c.yellow(`${notRun} not run`) : ''
+        ].filter(Boolean).join(c.dim(' | ')) + c.dim(` (${total})`);
+    }
+    footer(durationMs = Date.now() - this.startedAt, result) {
+        const files = [
+            ...this.files.values()
+        ];
+        const cases = files.flatMap((file)=>[
+                ...file.outcomes.values()
+            ]);
+        const c = this.color;
+        const metrics = result ? this.finalMetrics : this.usage.snapshot();
+        return [
+            ` ${c.dim('Test Files')} ${this.counts(files, this.totalFiles)}`,
+            ` ${c.dim('     Cases')} ${result ? this.stateCounts(result.summary.passed, result.summary.failed, result.summary.notRun, result.summary.total) : this.counts(cases, this.total)}`,
+            ` ${c.dim('  Start at')} ${new Date(this.startedAt).toLocaleTimeString('en-GB', {
+                hour12: false
+            })}`,
+            ` ${c.dim('  Duration')} ${formatDuration(durationMs)}`,
+            ...formatModelUsage(metrics).map((model, index)=>` ${c.dim(index ? '          ' : '   Models:')} ${model}`),
+            ...!result || this.warnings.size ? [
+                ` ${c.dim('  Warnings')} ${this.warnings.size ? c.yellow(String(this.warnings.size)) : c.dim('0')}${!result && this.latestNotice ? c.dim(` · ${this.latestNotice}`) : ''}`
+            ] : []
+        ];
+    }
+    renderProgress(render = true) {
+        if (!this.interactive || !this.timer) return;
+        const projects = new Map();
+        const files = [
+            ...this.files.values()
+        ].filter((file)=>file.started && !file.printed).sort((a, b)=>a.projectName.localeCompare(b.projectName) || a.sourcePath.localeCompare(b.sourcePath));
+        for (const file of files){
+            const group = projects.get(file.projectName) ?? [];
+            group.push(file);
+            projects.set(file.projectName, group);
+        }
+        for (const projectName of this.projectPhases.keys())if (!projects.has(projectName)) projects.set(projectName, []);
+        const footer = this.footer();
+        const budget = Math.max(0, (this.io.rows ?? 24) - 2 - footer.length - 1);
+        let lines = this.liveTree(projects, 'full');
+        if (lines.length > budget) lines = this.liveTree(projects, 'recent');
+        if (lines.length > budget) lines = this.liveTree(projects, 'compact');
+        if (lines.length > budget) lines = this.liveTree(projects, 'active');
+        if (lines.length) lines.push('');
+        if (render) this.progressView.render(lines, footer);
+        else this.progressView.update(lines, footer);
+    }
+    liveTree(projects, mode) {
+        const c = this.color;
+        const lines = [];
+        const groups = [
+            ...projects
+        ];
+        const isActive = ([projectName, files])=>this.projectPhases.has(projectName) || files.some((file)=>!file.status);
+        if ('full' !== mode) groups.sort((a, b)=>Number(isActive(b)) - Number(isActive(a)));
+        for (const [projectName, files] of groups){
+            const phase = this.projectPhases.get(projectName);
+            const running = files.filter((file)=>!file.status);
+            const completed = files.filter((file)=>file.status);
+            const recent = [
+                ...completed
+            ].sort((a, b)=>b.completionOrder - a.completionOrder).slice(0, 'recent' === mode ? 1 : 0);
+            const visible = 'full' === mode ? files : [
+                ...running,
+                ...recent
+            ];
+            const hidden = completed.filter((file)=>!visible.includes(file));
+            const hiddenFailures = hidden.filter((file)=>'failed' === file.status).length;
+            const details = [
+                phase ? c.yellow(`${projectPhaseLabel(phase.phase)} ${formatDuration(Date.now() - phase.since)}`) : '',
+                c.yellow(`${running.length} ${1 === running.length ? 'file' : 'files'} running`),
+                completed.length ? c.dim(`${completed.length} completed`) : '',
+                'active' === mode && hiddenFailures ? c.red(`${hiddenFailures} failed`) : ''
+            ].filter(Boolean);
+            lines.push(this.liveRow(` ${c.yellow('❯')} ${c.bold(terminal_reporter_oneLine(projectName))}`, c.dim(' · ') + details.join(c.dim(' · '))));
+            for (const [fileIndex, file] of visible.entries()){
+                const lastFile = fileIndex === visible.length - 1 && (!hidden.length || 'active' === mode);
+                const stem = lastFile ? '      ' : `   ${c.dim('│')}  `;
+                const outcomes = [
+                    ...new Map([
+                        ...file.attemptOutcomes,
+                        ...file.outcomes
+                    ]).values()
+                ].sort((a, b)=>a.caseIndex - b.caseIndex);
+                const failedCases = outcomes.filter((outcome)=>'failed' === outcome.status).length;
+                lines.push(this.liveRow(`   ${c.dim(lastFile ? '└─' : '├─')} ${file.status ? `${this.statusSymbol(file.status)} ` : ''}${terminal_reporter_oneLine(file.sourcePath)}`, ` ${c.dim(`${outcomes.length}/${file.total} cases`)}${file.status ? c.dim(` ${formatDuration(file.durationMs)}`) : ''}${'active' === mode && failedCases ? c.red(` · ${failedCases} failed`) : ''}`));
+                const tasks = [
+                    ...this.active.values()
+                ].filter((task)=>task.file === file);
+                const shown = 'full' === mode ? outcomes : 'recent' === mode ? outcomes.slice(-1) : [];
+                const children = [
+                    ...tasks.map((task)=>({
+                            task
+                        })),
+                    ...shown.map((outcome)=>({
+                            outcome
+                        }))
+                ];
+                if ('full' === mode) children.sort((a, b)=>this.liveChildIndex(a) - this.liveChildIndex(b));
+                const hiddenCases = outcomes.filter((outcome)=>!shown.includes(outcome));
+                if (hiddenCases.length && 'active' !== mode) {
+                    const failed = hiddenCases.filter((outcome)=>'failed' === outcome.status).length;
+                    children.push({
+                        summary: `… ${hiddenCases.length} completed ${1 === hiddenCases.length ? 'case' : 'cases'}${failed ? ` · ${failed} failed` : ''}`,
+                        failed: failed > 0
+                    });
+                }
+                for (const [index, child] of children.entries()){
+                    const last = index === children.length - 1;
+                    const prefix = `${stem}${c.dim(last ? '└─' : '├─')} `;
+                    if ('outcome' in child) {
+                        lines.push(this.liveRow(`${prefix}${this.formatCaseResult(child.outcome, file.retries)}`, ''));
+                        continue;
+                    }
+                    if ('summary' in child) {
+                        lines.push(this.liveRow(`${prefix}${child.failed ? c.red(child.summary) : c.dim(child.summary)}`, ''));
+                        continue;
+                    }
+                    const { task } = child;
+                    const hint = task.name && task.step ? truncateTerminalLine(` · ${task.step}`, Math.floor(Math.max(0, (this.io.columns ?? 100) - 1) / 2)) : '';
+                    const retry = task.attempt ? ` · attempt ${task.attempt + 1}${task.maxAttempts ? `/${task.maxAttempts}` : ''}` : '';
+                    lines.push(this.liveRow(`${prefix}${terminal_reporter_oneLine(task.name ?? task.step ?? 'file lifecycle')}`, `${c.dim(hint)} ${c.yellow(formatDuration(Date.now() - task.since))}${c.yellow(retry)}`));
+                    if (task.warning) lines.push(this.liveRow(`${stem}${last ? '   ' : `${c.dim('│')}  `}${c.dim('└─')} ${c.yellow(`⚠ ${task.warning}`)}`, ''));
+                }
+            }
+            if (hidden.length && 'active' !== mode) {
+                const summary = `… ${hidden.length} completed ${1 === hidden.length ? 'file' : 'files'}${hiddenFailures ? ` · ${hiddenFailures} failed` : ''}`;
+                lines.push(this.liveRow(`   ${c.dim('└─')} ${hiddenFailures ? c.red(summary) : c.dim(summary)}`, ''));
+            }
+        }
+        return lines;
+    }
+    liveChildIndex(child) {
+        if ('outcome' in child) return child.outcome.caseIndex;
+        if ('summary' in child) return Number.MAX_SAFE_INTEGER;
+        return child.task.caseIndex ?? ('beforeAll' === child.task.phase ? -1 : Number.MAX_SAFE_INTEGER);
+    }
+    liveRow(label, suffix) {
+        const columns = Math.max(0, (this.io.columns ?? 100) - 1);
+        const tail = truncateTerminalLine(suffix, columns);
+        return truncateTerminalLine(label, columns - string_width(tail)) + tail;
+    }
+    tick() {
+        if (this.interactive) return void this.renderProgress();
+        if ((this.active.size || this.projectPhases.size) && Date.now() - this.lastOutput >= 30000) this.log(`… Still running: ${[
+            ...[
+                ...this.projectPhases
+            ].map(([projectName, phase])=>`[${terminal_reporter_oneLine(projectName)}] · ${projectPhaseLabel(phase.phase)} (${formatDuration(Date.now() - phase.since)})`),
+            ...[
+                ...this.active.values()
+            ].map((task)=>`${identity(task.file.projectName, task.file.sourcePath, task.name)} · ${task.step ?? 'between steps'} (${formatDuration(Date.now() - task.since)})`)
+        ].join(' | ')}`);
+    }
+    formatCaseResult(outcome, documentRetries) {
+        const c = this.color;
+        const attempts = outcome.attempts ?? (outcome.run ? [
+            outcome.run
+        ] : []);
+        const retries = Math.max(attempts.length - 1, outcome.run?.attemptIndex ?? 0);
+        const duration = formatDuration(attempts.reduce((sum, attempt)=>sum + attempt.durationMs, 0));
+        const symbol = 'success' === outcome.status ? c.green('✓') : 'failed' === outcome.status ? c.red('×') : c.yellow('–');
+        const detail = 'not-run' === outcome.status ? c.dim(` · ${outcome.notRunReason ?? 'not run'}`) : ` ${c.dim(duration)}${retries ? c.yellow(` · ${'success' === outcome.status ? 'passed after retry' : 'failed after retries'} (${retries + 1} attempts)`) : documentRetries ? c.yellow(` · file retried ${documentRetries}x`) : ''}`;
+        return `${symbol} ${terminal_reporter_oneLine(outcome.name)}${detail}`;
+    }
+    statusSymbol(status) {
+        return 'failed' === status ? this.color.red('×') : 'not-run' === status ? this.color.yellow('–') : this.color.green('✓');
+    }
+    resultFileLines(file, lastFile) {
+        const c = this.color;
+        const stem = lastFile ? '      ' : `   ${c.dim('│')}  `;
+        const cases = [
+            ...file.outcomes.values()
+        ].sort((a, b)=>a.caseIndex - b.caseIndex);
+        const failed = cases.filter((item)=>'failed' === item.status).length;
+        const notRun = cases.filter((item)=>'not-run' === item.status).length;
+        const stats = `(${cases.length} cases${failed ? ` | ${failed} failed` : ''}${notRun ? ` | ${notRun} not run` : ''})`;
+        return [
+            `   ${c.dim(lastFile ? '└─' : '├─')} ${this.statusSymbol(file.status)} ${c.bold(terminal_reporter_oneLine(file.sourcePath))} ${c.dim(stats)} ${c.dim(formatDuration(file.durationMs))}`,
+            ...cases.map((item, caseIndex)=>`${stem}${c.dim(caseIndex === cases.length - 1 ? '└─' : '├─')} ${this.formatCaseResult(item, file.retries)}`)
+        ];
+    }
+    printFile(file) {
+        if (file.printed) return;
+        file.printed = true;
+        this.log([
+            '',
+            ` ${this.color.bold(terminal_reporter_oneLine(file.projectName))}`,
+            ...this.resultFileLines(file, true)
+        ].join('\n'));
+    }
+    printProject(projectName, files, failed) {
+        if (!files.length || files.every((file)=>file.printed)) return;
+        const c = this.color;
+        const status = failed || files.some((file)=>'failed' === file.status) ? 'failed' : files.every((file)=>'not-run' === file.status) ? 'not-run' : files.some((file)=>'not-run' === file.status) ? 'failed' : 'success';
+        const lines = [
+            '',
+            ` ${this.statusSymbol(status)} ${c.bold(terminal_reporter_oneLine(projectName))} ${c.dim(`(${files.length} ${1 === files.length ? 'file' : 'files'})`)}`
+        ];
+        for (const [index, file] of files.entries())if (!file.printed) {
+            file.printed = true;
+            lines.push(...this.resultFileLines(file, index === files.length - 1));
+        }
+        this.log(lines.join('\n'));
+    }
+    failure(source, error, context) {
+        this.failures.push({
+            source,
+            error,
+            context
+        });
+    }
+    completeProject(project) {
+        this.projectPhases.delete(project.name);
+        const projectFiles = new Set();
+        const documents = new Map(project.documents.map((document)=>[
+                document.documentId,
+                document
+            ]));
+        const resultSources = new Set([
+            ...project.cases.map((outcome)=>outcome.sourcePath),
+            ...project.documents.map((document)=>document.sourcePath),
+            ...project.collectionErrors.map((error)=>error.sourcePath)
+        ]);
+        for (const plan of project.plans ?? []){
+            const selected = plan.cases.filter((item)=>item.selected).length;
+            if (selected || resultSources.has(plan.sourcePath)) projectFiles.add(this.file(project.name, plan.sourcePath, selected));
+        }
+        for (const outcome of project.cases)this.file(project.name, outcome.sourcePath).outcomes.set(outcome.caseId, outcome);
+        for (const document of documents.values()){
+            const file = this.file(project.name, document.sourcePath);
+            file.status = document.status;
+            file.retries = document.attemptIndex ?? 0;
+            file.durationMs = project.documents.filter((item)=>item.documentId === document.documentId).reduce((sum, item)=>sum + item.durationMs, 0);
+        }
+        for (const error of project.collectionErrors)this.file(project.name, error.sourcePath).status = 'failed';
+        for (const file of this.files.values())if (file.projectName === project.name) {
+            file.attemptOutcomes.clear();
+            const cases = [
+                ...file.outcomes.values()
+            ];
+            file.status = fileStatus(file.status, cases);
+            projectFiles.add(file);
+        }
+        for (const [key, task] of this.active)if (task.file.projectName === project.name) this.active.delete(key);
+        if (this.interactive) this.printProject(project.name, [
+            ...projectFiles
+        ], 'failed' === project.status);
+        else for (const file of projectFiles)this.printFile(file);
+    }
+    finish(result) {
+        this.dispose();
+        this.finalMetrics = result.metrics ?? this.usage.snapshot();
+        if (result.startedAt) this.startedAt = Date.parse(result.startedAt);
+        for (const project of result.projects)this.completeProject(project);
+        this.total = result.summary.total;
+        this.totalFiles = this.files.size;
+    }
+    sectionHeading(label, kind) {
+        const c = this.color;
+        const width = Math.max(0, (this.io.columns ?? 80) - 2);
+        const title = truncateTerminalLine(` ${label} `, width);
+        const padding = Math.max(0, width - string_width(title));
+        const left = Math.floor(padding / 2);
+        const line = 'warning' === kind ? c.yellow : c.red;
+        const badge = 'warning' === kind ? c.bgYellow.black.bold : c.bgRed.white.bold;
+        this.log(`\n ${line('─'.repeat(left))}${badge(title)}${line('─'.repeat(padding - left))}\n`);
+    }
+    summary(result) {
+        const c = this.color;
+        if (this.interactive && this.warnings.size) {
+            this.sectionHeading(`Warnings ${this.warnings.size}`, 'warning');
+            for (const warning of [
+                ...this.warnings.values()
+            ].slice(0, 5))this.log(` ${c.yellow('WARN')} ${c.dim(warning.scope)}${warning.message}`);
+            if (this.warnings.size > 5) this.log(c.dim(` … ${this.warnings.size - 5} more warnings; see debug logs or --reporter verbose.`));
+        }
+        if (this.failures.length) {
+            this.sectionHeading(`Failures ${this.failures.length}`, 'failure');
+            for (const failure of this.failures){
+                if ('default' === this.mode) {
+                    const detail = formatFailureDetails(failure.source, failure.error, failure.context);
+                    const body = detail.body.map((line)=>{
+                        if (line.startsWith('  Error:')) return c.red(line);
+                        if (line.startsWith('  at ')) return c.dim(line);
+                        return line.replace(/^ {2}(?:Step|Location|Attempt|File try|Phase|Input)\s+/, (label)=>c.dim(label));
+                    }).join('\n');
+                    const block = `${c.bgRed.white.bold(' FAIL ')} ${c.bold(detail.title)}\n${body}\n`;
+                    if (this.interactive) this.log(block);
+                    else this.io.error(`FAIL ${detail.title}\n${detail.body.join('\n')}\n`);
+                    continue;
+                }
+                const message = formatCliError(failure.error);
+                this.io.error(`FAIL midscene-test: ${failure.source}:\n${message.split('\n').map((line)=>`  ${line}`).join('\n')}\n`);
+            }
+        }
+        this.log(`\n${this.footer(result.durationMs, result).join('\n')}`);
+        this.log('');
+        this.failures = [];
+    }
+    dispose() {
+        if (this.timer) clearInterval(this.timer);
+        if (this.scheduled) clearTimeout(this.scheduled);
+        this.timer = void 0;
+        this.scheduled = void 0;
+        this.removeResizeListener?.();
+        this.removeResizeListener = void 0;
+        this.progressView.clear();
+    }
+    constructor(io, mode = 'default'){
+        terminal_reporter_define_property(this, "io", void 0);
+        terminal_reporter_define_property(this, "mode", void 0);
+        terminal_reporter_define_property(this, "total", void 0);
+        terminal_reporter_define_property(this, "completionOrder", void 0);
+        terminal_reporter_define_property(this, "totalFiles", void 0);
+        terminal_reporter_define_property(this, "files", void 0);
+        terminal_reporter_define_property(this, "warnings", void 0);
+        terminal_reporter_define_property(this, "latestNotice", void 0);
+        terminal_reporter_define_property(this, "usage", void 0);
+        terminal_reporter_define_property(this, "finalMetrics", void 0);
+        terminal_reporter_define_property(this, "attempts", void 0);
+        terminal_reporter_define_property(this, "active", void 0);
+        terminal_reporter_define_property(this, "projectPhases", void 0);
+        terminal_reporter_define_property(this, "failures", void 0);
+        terminal_reporter_define_property(this, "lastOutput", void 0);
+        terminal_reporter_define_property(this, "startedAt", void 0);
+        terminal_reporter_define_property(this, "timer", void 0);
+        terminal_reporter_define_property(this, "scheduled", void 0);
+        terminal_reporter_define_property(this, "progressView", void 0);
+        terminal_reporter_define_property(this, "removeResizeListener", void 0);
+        terminal_reporter_define_property(this, "color", void 0);
+        this.io = io;
+        this.mode = mode;
+        this.total = 0;
+        this.completionOrder = 0;
+        this.totalFiles = 0;
+        this.files = new Map();
+        this.warnings = new Map();
+        this.usage = new CliModelUsage();
+        this.attempts = new Map();
+        this.active = new Map();
+        this.projectPhases = new Map();
+        this.failures = [];
+        this.lastOutput = Date.now();
+        this.startedAt = Date.now();
+        this.progressView = new TerminalProgress(io);
+        this.color = new chalk.Instance({
+            level: io.isTTY && !process.env.NO_COLOR ? 1 : 0
+        });
+    }
+}
+const escapeData = (text)=>text.replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+const escapeProperty = (text)=>escapeData(text).replace(/:/g, '%3A').replace(/,/g, '%2C');
+const markdown = (text)=>text.replace(/[&<>`\r\n]/g, (char)=>({
+            '&': '&amp;',
+            '<': '&lt;',
+            '>': '&gt;',
+            '`': '&#96;',
+            '\r': ' ',
+            '\n': ' '
+        })[char]);
+const code = (text)=>{
+    const value = text.replace(/[\r\n]+/g, ' ');
+    const longest = Math.max(0, ...(value.match(/`+/g) ?? []).map((run)=>run.length));
+    const fence = '`'.repeat(longest + 1);
+    const pad = value.startsWith('`') || value.endsWith('`') ? ' ' : '';
+    return `${fence}${pad}${value}${pad}${fence}`;
+};
+function githubFailureAnnotation(source, message, file) {
+    if ('true' !== process.env.GITHUB_ACTIONS) return;
+    const workspace = process.env.GITHUB_WORKSPACE ?? process.cwd();
+    const path = file ? relative(workspace, resolve(file)).split(sep).join('/') : void 0;
+    return `::error ${path ? `file=${escapeProperty(path)},` : ''}title=${escapeProperty(source)}::${escapeData(message)}`;
+}
+function writeGitHubSummary(result) {
+    const output = process.env.GITHUB_STEP_SUMMARY;
+    if ('true' !== process.env.GITHUB_ACTIONS || !output) return;
+    const failedCases = [
+        ...new Map(result.cases.map((item)=>[
+                item.caseId,
+                item
+            ])).values()
+    ].filter((item)=>'failed' === item.status);
+    const summary = [
+        '## Midscene Test',
+        '',
+        ...renderTestBadgeLines(result),
+        '| Passed | Failed | Not run | Passed after retry | Duration |',
+        '| ---: | ---: | ---: | ---: | ---: |',
+        `| ${result.summary.passed} | ${result.summary.failed} | ${result.summary.notRun} | ${result.summary.passedAfterRetry} | ${formatDuration(result.durationMs)} |`,
+        '',
+        'Passed after retry is included in Passed.',
+        '',
+        ...failedCases.map((item)=>`- Failed: **${markdown(item.name)}** — ${markdown(item.projectName)}/${code(item.sourcePath)}`),
+        ...result.summary.collectionErrors ? [
+            `- Collection errors: ${result.summary.collectionErrors}`
+        ] : [],
+        ...result.summary.documentFailures ? [
+            `- Failed files: ${result.summary.documentFailures}`
+        ] : [],
+        ...result.summary.projectFailures ? [
+            `- Failed projects: ${result.summary.projectFailures}`
+        ] : [],
+        '',
+        ...result.reportPath ? [
+            `Report artifact entry: ${code(result.reportPath)}`
+        ] : [],
+        `Structured results: ${code(result.summaryPath)}`,
+        ''
+    ].join('\n');
+    appendFileSync(output, `${summary}\n`);
+}
+const GENERATED_COMMENT = '<!-- Generated by `midscene-test nodes`. Do not edit directly. -->';
+const sortNodesForSpec = (nodes)=>{
+    const priority = (name)=>'aiAct' === name ? 0 : 'aiAssert' === name ? 1 : 2;
+    return [
+        ...nodes
+    ].sort((left, right)=>priority(left.name) - priority(right.name) || (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+};
+const escapeTableCell = (value)=>value.trim().replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/\r\n|\r|\n/g, '<br>');
+const renderNodeOverview = (nodes)=>{
+    const heading = '## Available Nodes';
+    if (0 === nodes.length) return `${heading}\n\nNo nodes are registered by the current Test Project.`;
+    const rows = nodes.map((node)=>`| ${escapeTableCell(node.name)} | ${escapeTableCell(node.description || "Description not declared.")} |`);
+    return `${heading}\n\nThis table lists all available Nodes. See [Node Details](#node-details) below for each Node's usage and input schema.\n\n${[
+        "| Node | Description |",
+        '| --- | --- |',
+        ...rows
+    ].join('\n')}`;
+};
+const renderWorkflowLocations = (location)=>{
+    const sections = [
+        '## Where to use these Nodes',
+        'Use these Nodes in Workflow Documents (`.yaml` or `.yml` files) selected by an Execution Project. Case file patterns and the config file path below are relative to this spec file. Case file patterns use glob syntax. A custom `--config` path does not change where case files are selected.',
+        'Projects created by `midscene-test create` select `cases/**/*.{yaml,yml}` by default, so you can write test cases in `cases/example.yaml` or subdirectories of `cases/`. If an Execution Project has no `files` configuration, Midscene Test searches `**/*.{yaml,yml}` recursively instead. Check `projects[].files` in your configuration before choosing a file location.'
+    ];
+    if (location) {
+        sections.push(`**Config file:** ${location.configPath ? `\`${location.configPath}\`` : 'No config file loaded.'}`);
+        for (const project of location.projects){
+            const patterns = project.files.include.map((pattern)=>`\`${pattern}\``).join(', ');
+            const projectLabel = location.projects.length > 1 || 'default' !== project.name ? ` (Execution Project: ${project.name})` : '';
+            const excludes = project.files.exclude?.length ? `; excludes: ${project.files.exclude.map((pattern)=>`\`${pattern}\``).join(', ')}` : '';
+            sections.push(`**Case files:** ${patterns}${projectLabel}${excludes}`);
+        }
+    }
+    sections.push('Files matching `files.exclude` are not selected. Midscene Test always ignores `.git/`, `.midscene/`, `midscene_run/`, and `node_modules/` directories, including nested ones.', 'Call a Node in `cases[].steps`, or in the Workflow Document lifecycle steps `beforeAll`, `beforeEach`, `afterEach`, and `afterAll`. Root Nodes are shared defaults; `projects[].nodes` adds local Nodes and overrides same-named root Nodes only within that Execution Project. Each Execution Project supplies its own runtime environment.');
+    return sections.join('\n\n');
+};
+const WORKFLOW_STEP_CONTRACT = `## Workflow Step Contract
+
+Each step uses a node name as its key. The \`$\` object contains engine metadata and is not part of the node input.
+
+\`\`\`yaml
+cases:
+  - name: Example case
+    steps:
+      - node.name:
+          prompt: Describe the task.
+          $:
+            timeout: 30000
+            continue-on-error: false
+\`\`\`
+
+A Node may map a string step value to one declared input field. Each Node section states whether it supports this shorthand and names the target field.
+
+Each Node's returned \`data\` is saved on that Step's result. Results are not named or automatically passed to later Steps. A failed Case does not stop later Cases by default; \`test.bail\` controls early stopping across the run.`;
+const sortJsonValue = (value)=>{
+    if (Array.isArray(value)) return value.map(sortJsonValue);
+    if ('object' != typeof value || null === value) return value;
+    return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left < right ? -1 : left > right ? 1 : 0).map(([key, child])=>[
+            key,
+            sortJsonValue(child)
+        ]));
+};
+const assertSelfContainedRefs = (value, node)=>{
+    if (Array.isArray(value)) {
+        for (const child of value)assertSelfContainedRefs(child, node);
+        return;
+    }
+    if ('object' != typeof value || null === value) return;
+    for (const [key, child] of Object.entries(value)){
+        if ('$ref' === key && 'string' == typeof child && !child.startsWith('#')) throw new Error(`Cannot describe node "${node}": inputSchema generated an external $ref.`);
+        assertSelfContainedRefs(child, node);
+    }
+};
+const toJsonSchema = (node)=>{
+    try {
+        const schema = z.toJSONSchema(node.inputSchema, {
+            target: 'draft-2020-12',
+            io: 'input',
+            unrepresentable: 'throw',
+            cycles: 'ref',
+            reused: 'ref'
+        });
+        assertSelfContainedRefs(schema, node.name);
+        return sortJsonValue(schema);
+    } catch (error) {
+        if (error instanceof Error && error.message.startsWith(`Cannot describe node "${node.name}":`)) throw error;
+        throw new Error(`Cannot describe node "${node.name}": inputSchema contains a Zod type that cannot be represented as JSON Schema.`, {
+            cause: error
+        });
+    }
+};
+const renderNode = (node, warnings)=>{
+    const sections = [
+        `### \`${node.name}\``
+    ];
+    if (node.title) sections.push(`**Title:** ${node.title.trim()}`);
+    if (node.description) sections.push(node.description.trim());
+    else {
+        warnings.push(`node "${node.name}" has no description`);
+        sections.push("> Description not declared. Do not infer this node's behavior.");
+    }
+    if (false === node.stringInputKey || void 0 === node.stringInputKey) sections.push('**String shorthand:** Not supported by this Node.');
+    else sections.push(`**String shorthand:** Maps to \`{ ${node.stringInputKey}: value }\`.`);
+    sections.push('#### Input Schema');
+    if (node.inputSchema) sections.push(`\`\`\`json\n${JSON.stringify(toJsonSchema(node), null, 2)}\n\`\`\``);
+    else {
+        warnings.push(`node "${node.name}" has no inputSchema`);
+        sections.push('> Input schema not declared. Do not invent input fields for this node.');
+    }
+    return sections.join('\n\n');
+};
+const renderNodeSpec = (nodes, location)=>{
+    const warnings = [];
+    const sortedNodes = sortNodesForSpec(nodes);
+    const sections = [
+        GENERATED_COMMENT,
+        '# Midscene Test Node Spec',
+        'This document describes the Nodes available in YAML test files (`.yaml` or `.yml`) for the Midscene Test framework (`@midscene/test`). It lists the Nodes registered by the current Test Project, their inputs, and how to call them in test steps and lifecycle hooks.',
+        "Learn about the framework and YAML test authoring:\n\n- [Midscene Test overview](https://midscenejs.com/midscene-test/overview): framework concepts and the role of Nodes.\n- [Create and use test projects](https://midscenejs.com/midscene-test/use): write YAML cases, run tests, and inspect results.\n- [Configure test projects](https://midscenejs.com/midscene-test/configuration): register Nodes, select case files, and manage runtime resources.",
+        renderNodeOverview(sortedNodes),
+        renderWorkflowLocations(location),
+        WORKFLOW_STEP_CONTRACT
+    ];
+    if (sortedNodes.length > 0) {
+        sections.push('## Node Details');
+        for (const node of sortedNodes)sections.push(renderNode(node, warnings));
+    }
+    return {
+        markdown: `${sections.join('\n\n')}\n`,
+        warnings
+    };
+};
+function captureTerminalOutput(output, streams = [
+    process.stdout,
+    process.stderr
+]) {
+    const cleanups = [];
+    for (const stream of streams){
+        const original = stream.write;
+        const forward = original.bind(stream);
+        const intercepted = (chunk, encoding, callback)=>{
+            const done = 'function' == typeof encoding ? encoding : callback;
+            const message = 'string' == typeof chunk ? chunk : Buffer.from(chunk).toString();
+            let accepted = true;
+            output(message, (text)=>{
+                accepted = forward(text, done);
+            });
+            return accepted;
+        };
+        stream.write = intercepted;
+        cleanups.push(()=>{
+            if (stream.write === intercepted) stream.write = original;
+        });
+    }
+    return ()=>{
+        for (const cleanup of cleanups)cleanup();
+    };
+}
+const parseTestCliArgs = (args, cwd = process.cwd())=>{
+    const command = 'nodes' === args[0] ? args[0] : void 0;
+    const commandOffset = command ? 1 : 0;
+    let inputPath;
+    let configPath;
+    let resultDir;
+    const projectNames = [];
+    let reporter;
+    for(let index = commandOffset; index < args.length; index += 1){
+        const token = args[index];
+        const equal = token.startsWith('-') ? token.indexOf('=') : -1;
+        const arg = equal < 0 ? token : token.slice(0, equal);
+        const inlineValue = equal < 0 ? void 0 : token.slice(equal + 1);
+        if (!arg.startsWith('-')) {
+            if (inputPath) throw new Error('Only one test file or directory is allowed.');
+            inputPath = resolve(cwd, arg);
+            continue;
+        }
+        if ('--config' === arg || '--result-dir' === arg || '--project' === arg || '--reporter' === arg) {
+            const value = inlineValue ?? args[index + 1];
+            if (!value || value.startsWith('--')) throw new Error(`${arg} requires a value.`);
+            if ('--config' === arg) configPath = value;
+            else if ('--result-dir' === arg) resultDir = resolve(cwd, value);
+            else if ('--project' === arg) projectNames.push(value);
+            else {
+                if ('default' !== value && 'verbose' !== value) throw new Error(`Unknown reporter: ${value}. Expected default or verbose.`);
+                reporter = value;
+            }
+            if (void 0 === inlineValue) index += 1;
+        } else throw new Error(`Unknown option: ${token}`);
+    }
+    if ('nodes' === command && resultDir) throw new Error('--result-dir is not supported by nodes.');
+    if ('nodes' === command && reporter) throw new Error('--reporter is not supported by nodes.');
+    if ('nodes' === command && projectNames.length > 1) throw new Error('nodes accepts only one --project name.');
+    return {
+        ...command ? {
+            command
+        } : {},
+        cwd,
+        ...command ? {
+            projectRoot: inputPath
+        } : {
+            testPath: inputPath
+        },
+        configPath,
+        resultDir,
+        ...projectNames.length > 0 ? {
+            projectNames
+        } : {},
+        ...reporter ? {
+            reporter
+        } : {}
+    };
+};
+const defaultCliIO = {
+    log: console.log,
+    error: console.error,
+    write: process.stdout.write.bind(process.stdout),
+    isTTY: Boolean(process.stdout.isTTY && !process.env.CI),
+    get columns () {
+        return process.stdout.columns;
+    },
+    get rows () {
+        return process.stdout.rows;
+    },
+    onResize (listener) {
+        process.stdout.on('resize', listener);
+        return ()=>process.stdout.off('resize', listener);
+    }
+};
+const testCliHelp = `Midscene Test: run native cases/steps Test projects.
+
+Usage:
+  midscene-test [file.yaml | directory] [options]
+  midscene-test --config <midscene.config.ts> [options]
+  midscene-test nodes [directory] [--config midscene.config.ts]
+  midscene-test create --help
+  midscene-test model verify    Check model connectivity and Midscene compatibility
+
+Options:
+  --config <path>              Native TypeScript or JavaScript Test config
+  --project <name>             Select a native execution Project (repeatable)
+  --result-dir <path>          Store Test result files in this directory
+  --reporter <default|verbose> Concise Case results or full step diagnostics
+  --help, -h                  Show this help
+  --version                   Show the package version
+
+With a config, run paths filter project files. Without one, they select standalone inputs.
+Run paths never change config discovery or the artifact root.
+For test runs, config discovery checks cwd only; --config is relative to cwd.
+The selected config directory becomes the test root.
+File include/exclude and tag rules still apply to explicit paths.
+
+Legacy tasks/flow YAML and its CLI options belong to the midscene command.
+`;
+const assertDirectory = (path, label)=>{
+    if (!existsSync(path) || !statSync(path).isDirectory()) throw new Error(`${label} does not exist or is not a directory: ${path}`);
+};
+const runNodesCommand = async (options, io)=>{
+    const cwd = resolve(options.cwd);
+    assertDirectory(cwd, 'Test working directory');
+    const projectRoot = options.projectRoot ? resolve(cwd, options.projectRoot) : void 0;
+    if (projectRoot) assertDirectory(projectRoot, 'Test project directory');
+    const configSearchRoot = projectRoot ?? cwd;
+    const configPath = options.configPath ? resolve(configSearchRoot, options.configPath) : discoverTestConfig(configSearchRoot);
+    if (options.configPath && /\.ya?ml$/i.test(configPath)) throw new Error(`midscene-test nodes --config only accepts a native TypeScript or JavaScript project config: ${configPath}.`);
+    if (options.configPath && (!configPath || !existsSync(configPath))) throw new Error(`Midscene config does not exist: ${configPath}`);
+    const project = await loadTestProject(configPath);
+    const projectName = options.projectNames?.[0];
+    const selectedProjects = projectName ? project.projects.filter((candidate)=>candidate.name === projectName) : project.projects;
+    if (0 === selectedProjects.length) throw new Error(`Unknown Midscene project: ${projectName}`);
+    const filenames = new Map();
+    const owners = new Map();
+    for (const executionProject of project.projects){
+        const safeName = executionProject.name.normalize('NFC').replace(/[<>:"/\\|?*\u0000-\u001f]/g, '-').replace(/[. ]+$/g, '-');
+        const filename = project.hasExplicitProjects ? `midscene-node-spec.${safeName}.md` : 'midscene-node-spec.md';
+        const key = filename.toLowerCase();
+        const owner = owners.get(key);
+        if (void 0 !== owner) throw new Error(`Projects "${owner}" and "${executionProject.name}" generate the same Node Spec filename: ${filename}`);
+        owners.set(key, executionProject.name);
+        filenames.set(executionProject.name, filename);
+    }
+    const specs = selectedProjects.map((executionProject)=>{
+        const nodes = sortNodesForSpec(executionProject.nodes.definitions());
+        const document = renderNodeSpec(nodes, {
+            configPath: configPath ? relative(configSearchRoot, configPath).split(sep).join('/') : void 0,
+            projects: [
+                {
+                    name: executionProject.name,
+                    files: executionProject.files ?? DEFAULT_TEST_FILE_SELECTION
+                }
+            ]
+        });
+        return {
+            executionProject,
+            nodes,
+            document
+        };
+    });
+    for (const { executionProject, nodes, document } of specs){
+        for (const warning of document.warnings)io.error(`midscene-test nodes: ${warning}`);
+        const specPath = resolve(configSearchRoot, filenames.get(executionProject.name));
+        writeFileSync(specPath, document.markdown);
+        if (project.hasExplicitProjects || projectName) io.log(`Execution Project: ${executionProject.name}`);
+        io.log(`Registered Nodes (${nodes.length}):`);
+        if (0 === nodes.length) io.log('No nodes are registered by the current Test Project.');
+        for (const node of nodes)io.log(`- ${node.name}: ${node.description?.trim() || "Description not declared."}`);
+        io.log(`\nNode Spec generated: ${specPath}`);
+    }
+};
+const reportTestProjectResult = (result, io, reporter, projectRoot, infrastructureErrors = result.errors ?? [])=>{
+    reporter.finish(result);
+    const reportedErrors = new Set();
+    const reportError = (source, error, sourcePath, context)=>{
+        if (error instanceof Error && reportedErrors.has(error)) return;
+        reporter.failure(source, error, {
+            projectRoot,
+            ...context
+        });
+        const annotation = githubFailureAnnotation(source, formatConciseError(error), sourcePath ? resolve(projectRoot, sourcePath) : void 0);
+        if (annotation) io.log(annotation);
+        const pending = [
+            error
+        ];
+        while(pending.length > 0){
+            const current = pending.pop();
+            if (!(current instanceof Error) || reportedErrors.has(current)) continue;
+            reportedErrors.add(current);
+            pending.push(current.cause);
+            if (current instanceof AggregateError) pending.push(...current.errors);
+        }
+    };
+    for (const failure of result.collectionErrors)reportError(`${failure.projectName}/${failure.sourcePath}`, failure.error, failure.sourcePath, {
+        projectName: failure.projectName,
+        sourcePath: failure.sourcePath,
+        phase: 'collection'
+    });
+    const finalDocuments = new Map(result.documents.map((document)=>[
+            document.documentId,
+            document
+        ]));
+    const documentContext = (projectName, documentId, sourcePath)=>{
+        const project = result.projects.find((project)=>project.name === projectName);
+        const document = finalDocuments.get(documentId);
+        const plan = document?.plan ?? project?.plans?.find((plan)=>plan.documentId === documentId);
+        const fileIndex = document?.attemptIndex ?? 0;
+        return {
+            plan,
+            projectName,
+            sourcePath,
+            ...plan?.retry.scope === 'document' ? {
+                fileAttempt: {
+                    index: fileIndex,
+                    total: Math.max(fileIndex + 1, plan.retry.count + 1)
+                }
+            } : {},
+            caseAttempts: plan?.retry.scope === 'document' ? 1 : (plan?.retry.count ?? project?.retry ?? 0) + 1
+        };
+    };
+    const finalCases = new Map(result.cases.map((outcome)=>[
+            outcome.caseId,
+            outcome
+        ]));
+    for (const outcome of finalCases.values()){
+        if ('failed' !== outcome.status || !outcome.run) continue;
+        const run = outcome.run;
+        const source = `${run.projectName}/${run.sourcePath} / ${run.name}`;
+        const { caseAttempts, plan, ...scope } = documentContext(run.projectName, outcome.documentId, run.sourcePath);
+        const context = {
+            ...scope,
+            caseName: run.name,
+            attempt: {
+                index: run.attemptIndex,
+                total: Math.max(caseAttempts, run.attemptIndex + 1)
+            }
+        };
+        const casePlan = plan?.cases.find((item)=>item.caseId === outcome.caseId);
+        for (const [phase, steps] of [
+            [
+                'beforeEach',
+                run.beforeEach
+            ],
+            [
+                'steps',
+                run.steps
+            ],
+            [
+                'afterEach',
+                run.afterEach
+            ]
+        ])for (const step of steps)if (step.error) reportError(`${source} / ${step.phase}[${step.stepIndex + 1}] ${step.node}${run.attemptIndex ? ` (failed after ${run.attemptIndex + 1} attempts)` : ''}`, step.error, run.sourcePath, {
+            ...context,
+            step,
+            stepCount: casePlan?.[phase].length
+        });
+        for (const [phase, errors] of [
+            [
+                'execution',
+                run.executionErrors
+            ],
+            [
+                'teardown',
+                run.teardownErrors
+            ]
+        ])for (const error of errors ?? [])reportError(source, error, run.sourcePath, {
+            ...context,
+            phase
+        });
+    }
+    for (const document of finalDocuments.values()){
+        if ('failed' !== document.status) continue;
+        const source = `${document.projectName}/${document.sourcePath}`;
+        const { caseAttempts: _, plan, ...context } = documentContext(document.projectName, document.documentId, document.sourcePath);
+        for (const [phase, steps] of [
+            [
+                'beforeAll',
+                document.beforeAll
+            ],
+            [
+                'afterAll',
+                document.afterAll
+            ]
+        ])for (const step of steps)if (step.error) reportError(`${source} / ${step.phase}[${step.stepIndex + 1}] ${step.node}`, step.error, document.sourcePath, {
+            ...context,
+            step,
+            stepCount: plan?.[phase].length
+        });
+        for (const [phase, errors] of [
+            [
+                'execution',
+                document.executionErrors
+            ],
+            [
+                'teardown',
+                document.teardownErrors
+            ]
+        ])for (const error of errors ?? [])reportError(source, error, document.sourcePath, {
+            ...context,
+            phase
+        });
+        for (const failure of document.hostErrors ?? [])reportError(`${source} / host ${failure.phase}`, failure.error, document.sourcePath, {
+            ...context,
+            phase: `host ${failure.phase}`
+        });
+    }
+    for (const project of result.projects){
+        if (project.lifecycle?.setupError) reportError(`${project.name} / setup`, project.lifecycle.setupError, void 0, {
+            projectName: project.name,
+            phase: 'setup'
+        });
+        for (const error of project.lifecycle?.teardownErrors ?? [])reportError(`${project.name} / teardown`, error, void 0, {
+            projectName: project.name,
+            phase: 'teardown'
+        });
+    }
+    for (const error of infrastructureErrors)reportError('infrastructure', error);
+    reporter.summary(result);
+    if ('verbose' === reporter.mode) io.log(`Results: ${result.resultDir}`);
+    io.log(`Summary: ${result.summaryPath}`);
+    if (result.markdownPath && 'verbose' === reporter.mode) io.log(`Markdown: ${result.markdownPath}`);
+    if (result.reportPath) io.log(`Report: ${result.reportPath}`);
+    return result.exitCode;
+};
+async function runTestCli(args, io = defaultCliIO, onResult) {
+    try {
+        if ('model' === args[0]) {
+            const { runModelCommand } = await import("./183.mjs").then((mod)=>({
+                    runModelCommand: mod.runModelCommand
+                }));
+            return runModelCommand(args, void 0, {
+                stdout: io.log,
+                stderr: io.error
+            });
+        }
+        if ('create' === args[0]) {
+            const { runCreateCommand } = await import("./1~112.mjs").then((mod)=>({
+                    runCreateCommand: mod.runCreateCommand
+                }));
+            await runCreateCommand(args.slice(1), io);
+            return 0;
+        }
+        if (args.includes('--help') || args.includes('-h')) {
+            io.log(testCliHelp);
+            return 0;
+        }
+        if (args.includes('--version')) {
+            io.log(package_namespaceObject.rE);
+            return 0;
+        }
+        const options = parseTestCliArgs(args);
+        if ('nodes' === options.command) {
+            await runNodesCommand(options, io);
+            return 0;
+        }
+        const reporter = new TerminalReporter(io, options.reporter);
+        const restoreOutput = io === defaultCliIO && io.isTTY && 'verbose' !== options.reporter ? captureTerminalOutput((message, write)=>reporter.output(message, write)) : void 0;
+        try {
+            return await runWithConsoleLogHandler((entry)=>reporter.console(entry), async ()=>{
+                const plan = await prepareTestRun({
+                    ...options,
+                    onProgress: (message)=>reporter.progress(message),
+                    onEvent: (event)=>reporter.event(event)
+                });
+                const projectRoot = realpathSync(plan.projectRoot);
+                let result;
+                try {
+                    result = await runPreparedTestProject(plan);
+                } catch (error) {
+                    if (!(error instanceof WorkflowExecutionFailure)) throw error;
+                    reportTestProjectResult(error.result, io, reporter, projectRoot, error.errors);
+                    onResult?.(error.result);
+                    return 1;
+                }
+                const exitCode = reportTestProjectResult(result, io, reporter, projectRoot);
+                onResult?.(result);
+                return exitCode;
+            });
+        } finally{
+            try {
+                reporter.dispose();
+            } finally{
+                restoreOutput?.();
+            }
+        }
+    } catch (error) {
+        io.error(formatCliError(error));
+        return 1;
+    }
+}
+runTestCli(process.argv.slice(2), void 0, writeGitHubSummary).then((exitCode)=>{
+    process.exitCode = exitCode;
+});
+export { package_namespaceObject };
+
+//# sourceMappingURL=164.mjs.map