sonamu 0.8.26 → 0.9.0

package/dist/testing/dev-vitest-manager.js

@@ -1,554 +1,529 @@
-export class DevVitestManager {
-    vitest = null;
-    running = false;
-    lastRunAt = null;
-    queue = [];
-    processing = false;
-    closed = false;
-    eventListeners = new Set();
-    currentRunContext = null;
-    addEventListener(listener) {
-        this.eventListeners.add(listener);
-    }
-    removeEventListener(listener) {
-        this.eventListeners.delete(listener);
-    }
-    emitEvent(event, data) {
-        for (const listener of this.eventListeners){
-            listener(event, data);
-        }
-    }
-    async start(vitestConfigPath) {
-        // 이미 시작된 경우 중복 초기화를 방지
-        if (this.vitest) {
-            return;
-        }
-        const { createVitest } = await import("vitest/node");
-        const viteOverrides = {
-            server: {
-                watch: null
-            }
-        };
-        const cliOptions = {
-            watch: true,
-            standalone: true,
-            forceRerunTriggers: [],
-            config: vitestConfigPath,
-            env: {
-                NODE_ENV: "test"
-            }
-        };
-        const realtimeReporter = this.createRealtimeProgressReporter();
-        viteOverrides.plugins = [
-            ...viteOverrides.plugins ?? [],
-            {
-                name: "sonamu-realtime-reporter",
-                configureVitest ({ vitest: vitestInstance }) {
-                    const reporters = vitestInstance.config.reporters;
-                    if (!reporters.includes(realtimeReporter)) {
-                        reporters.push(realtimeReporter);
-                    }
-                }
-            }
-        ];
-        const vitest = await createVitest("test", cliOptions, viteOverrides);
-        try {
-            await vitest.init();
-        } catch (err) {
-            await vitest.close();
-            throw err;
-        }
-        this.vitest = vitest;
-        this.vitest.onFilterWatchedSpecification((_spec)=>false);
-        this.closed = false;
-    }
-    async run(opts, runId) {
-        if (this.closed) {
-            throw new Error("DevVitestManager is already shut down");
-        }
-        if (!this.vitest) {
-            throw new Error("DevVitestManager is not started");
-        }
-        return new Promise((resolve, reject)=>{
-            const task = ()=>this.executeRun(opts, runId);
-            this.queue.push({
-                runId,
-                task,
-                resolve,
-                reject
-            });
-            this.processQueue();
-        });
-    }
-    getStatus() {
-        return {
-            ready: this.vitest !== null && !this.closed,
-            running: this.running,
-            lastRunAt: this.lastRunAt
-        };
-    }
-    /**
-   * 변경된 파일을 Vitest 모듈 그래프에서 무효화합니다.
-   * syncFromWatcher에서 호출되어 다음 테스트 실행 시 최신 코드를 사용하도록 합니다.
-   */ invalidateFiles(filePaths) {
-        if (!this.vitest || this.closed) {
-            return;
-        }
-        for (const filePath of filePaths){
-            this.vitest.invalidateFile(filePath);
-        }
-    }
-    async shutdown() {
-        if (this.closed) {
-            return;
-        }
-        this.closed = true;
-        // 큐에 남은 작업들을 reject하여 호출자가 영구 대기하지 않도록 정리
-        while(this.queue.length > 0){
-            const entry = this.queue.shift();
-            if (entry) {
-                entry.reject(new Error("DevVitestManager is being shut down"));
-            }
-        }
-        if (this.vitest) {
-            await this.vitest.close();
-            this.vitest = null;
-        }
-    }
-    async processQueue() {
-        if (this.processing) {
-            return;
-        }
-        this.processing = true;
-        try {
-            while(this.queue.length > 0){
-                const entry = this.queue.shift();
-                if (!entry) break;
-                if (this.closed) {
-                    entry.reject(new Error("DevVitestManager is already shut down"));
-                    continue;
-                }
-                try {
-                    const result = await entry.task();
-                    entry.resolve(result);
-                } catch (err) {
-                    entry.reject(err);
-                }
-            }
-        } finally{
-            this.processing = false;
-        }
-    }
-    async executeRun(opts, runId) {
-        const vitest = this.vitest;
-        if (!vitest) {
-            throw new Error("DevVitestManager is not started");
-        }
-        this.running = true;
-        const startTime = Date.now();
-        if (opts.pattern) {
-            vitest.setGlobalTestNamePattern(opts.pattern);
-        }
-        try {
-            const specs = opts.files ? await vitest.globTestSpecifications(opts.files) : await vitest.globTestSpecifications();
-            const specModuleIds = new Set(specs.map((s)=>s.moduleId));
-            // routes에서 생성한 runId를 그대로 사용하여 runStarted/runNodeProgress/runCompleted 간 일관성 보장
-            this.currentRunContext = {
-                runId,
-                startedAt: new Date().toISOString(),
-                specModuleIds
-            };
-            const allTestsRun = !opts.files || opts.files.length === 0;
-            const runResult = await vitest.runTestSpecifications(specs, allTestsRun);
-            const durationMs = Date.now() - startTime;
-            this.lastRunAt = new Date().toISOString();
-            return this.collectResults(runResult, durationMs, specModuleIds);
-        } finally{
-            this.currentRunContext = null;
-            if (opts.pattern) {
-                vitest.resetGlobalTestNamePattern();
-            }
-            this.running = false;
-        }
-    }
-    createRealtimeProgressReporter() {
-        const emitProgress = (kind, phase, fileId, nodeId, parentId, node)=>{
-            const ctx = this.currentRunContext;
-            if (!ctx) return;
-            this.emitEvent("runNodeProgress", {
-                schemaVersion: 1,
-                runId: ctx.runId,
-                startedAt: ctx.startedAt,
-                at: new Date().toISOString(),
-                kind,
-                phase,
-                fileId,
-                nodeId,
-                parentId,
-                node
-            });
-        };
-        return {
-            onTestModuleQueued: (testModule)=>{
-                const ctx = this.currentRunContext;
-                if (!ctx || !ctx.specModuleIds.has(testModule.moduleId)) return;
-                const fileId = testModule.moduleId;
-                emitProgress("file", "ready", fileId, fileId, null, this.buildFileProgressNode(testModule, "ready"));
-            },
-            onTestModuleEnd: (testModule)=>{
-                const ctx = this.currentRunContext;
-                if (!ctx || !ctx.specModuleIds.has(testModule.moduleId)) return;
-                const fileId = testModule.moduleId;
-                emitProgress("file", "result", fileId, fileId, null, this.buildFileNode(testModule));
-            },
-            onTestSuiteReady: (testSuite)=>{
-                const ctx = this.currentRunContext;
-                if (!ctx || !ctx.specModuleIds.has(testSuite.module.moduleId)) return;
-                const fileId = testSuite.module.moduleId;
-                const nodeId = `${fileId}::${testSuite.fullName}`;
-                const parentId = this.resolveSuiteParentId(testSuite);
-                emitProgress("suite", "ready", fileId, nodeId, parentId, this.buildSuiteProgressNode(testSuite, "ready"));
-            },
-            onTestSuiteResult: (testSuite)=>{
-                const ctx = this.currentRunContext;
-                if (!ctx || !ctx.specModuleIds.has(testSuite.module.moduleId)) return;
-                const fileId = testSuite.module.moduleId;
-                const nodeId = `${fileId}::${testSuite.fullName}`;
-                const parentId = this.resolveSuiteParentId(testSuite);
-                emitProgress("suite", "result", fileId, nodeId, parentId, this.buildSuiteNode(testSuite, fileId));
-            },
-            onTestCaseReady: (testCase)=>{
-                const ctx = this.currentRunContext;
-                if (!ctx || !ctx.specModuleIds.has(testCase.module.moduleId)) return;
-                const fileId = testCase.module.moduleId;
-                const nodeId = `${fileId}::${testCase.fullName}`;
-                const parentId = this.resolveTestParentId(testCase);
-                emitProgress("test", "ready", fileId, nodeId, parentId, this.buildTestProgressNode(testCase, "ready"));
-            },
-            onTestCaseResult: (testCase)=>{
-                const ctx = this.currentRunContext;
-                if (!ctx || !ctx.specModuleIds.has(testCase.module.moduleId)) return;
-                const fileId = testCase.module.moduleId;
-                const nodeId = `${fileId}::${testCase.fullName}`;
-                const parentId = this.resolveTestParentId(testCase);
-                emitProgress("test", "result", fileId, nodeId, parentId, this.buildTestNode(testCase, fileId));
-            }
-        };
-    }
-    buildFileProgressNode(testModule, _phase) {
-        return {
-            id: testModule.moduleId,
-            kind: "file",
-            name: testModule.moduleId,
-            fullName: testModule.moduleId,
-            file: testModule.moduleId,
-            state: "running",
-            durationMs: null,
-            counts: {
-                total: 0,
-                passed: 0,
-                failed: 0,
-                skipped: 0
-            },
-            error: null,
-            traces: [],
-            children: []
-        };
-    }
-    buildSuiteProgressNode(testSuite, _phase) {
-        const fileId = testSuite.module.moduleId;
-        return {
-            id: `${fileId}::${testSuite.fullName}`,
-            kind: "suite",
-            name: testSuite.name,
-            fullName: testSuite.fullName,
-            file: fileId,
-            state: "running",
-            durationMs: null,
-            counts: {
-                total: 0,
-                passed: 0,
-                failed: 0,
-                skipped: 0
-            },
-            error: null,
-            traces: [],
-            children: []
-        };
-    }
-    buildTestProgressNode(testCase, _phase) {
-        const fileId = testCase.module.moduleId;
-        return {
-            id: `${fileId}::${testCase.fullName}`,
-            kind: "test",
-            name: testCase.name,
-            fullName: testCase.fullName,
-            file: fileId,
-            state: "running",
-            durationMs: null,
-            counts: {
-                total: 1,
-                passed: 0,
-                failed: 0,
-                skipped: 0
-            },
-            error: null,
-            traces: [],
-            children: []
-        };
-    }
-    resolveSuiteParentId(testSuite) {
-        const parent = testSuite.parent;
-        if (parent.type === "suite") {
-            return `${testSuite.module.moduleId}::${parent.fullName}`;
-        }
-        return testSuite.module.moduleId;
-    }
-    resolveTestParentId(testCase) {
-        const parent = testCase.parent;
-        if (parent.type === "suite") {
-            return `${testCase.module.moduleId}::${parent.fullName}`;
-        }
-        return testCase.module.moduleId;
-    }
-    collectResults(runResult, durationMs, specModuleIds) {
-        const resultsByFile = new Map();
-        for (const testModule of runResult.testModules){
-            if (!specModuleIds.has(testModule.moduleId)) continue;
-            const nextResult = this.buildFileNode(testModule);
-            const existingResult = resultsByFile.get(nextResult.id);
-            if (!existingResult) {
-                resultsByFile.set(nextResult.id, nextResult);
-                continue;
-            }
-            const existingScore = getResultCompletenessScore(existingResult);
-            const nextScore = getResultCompletenessScore(nextResult);
-            if (nextScore >= existingScore) {
-                resultsByFile.set(nextResult.id, nextResult);
-            }
-        }
-        const results = Array.from(resultsByFile.values());
-        const summary = aggregateCounts(results);
-        return {
-            ok: summary.failed === 0,
-            summary: {
-                ...summary,
-                durationMs
-            },
-            results
-        };
-    }
-    buildFileNode(testModule) {
-        const file = testModule.moduleId;
-        const children = this.buildChildNodes(testModule, file);
-        const counts = aggregateCounts(children);
-        const moduleState = testModule.state();
-        const diagnostic = testModule.diagnostic();
-        return {
-            id: testModule.moduleId,
-            kind: "file",
-            name: testModule.moduleId,
-            fullName: testModule.moduleId,
-            file,
-            state: mapModuleState(moduleState),
-            durationMs: diagnostic.duration > 0 ? diagnostic.duration : null,
-            counts,
-            error: null,
-            traces: [],
-            children
-        };
-    }
-    buildChildNodes(parent, file) {
-        const result = [];
-        for (const child of parent.children){
-            if (child.type === "suite") {
-                result.push(this.buildSuiteNode(child, file));
-            } else {
-                result.push(this.buildTestNode(child, file));
-            }
-        }
-        return result;
-    }
-    buildSuiteNode(suite, file) {
-        const children = this.buildChildNodes(suite, file);
-        const counts = aggregateCounts(children);
-        const suiteState = suite.state();
-        return {
-            id: `${file}::${suite.fullName}`,
-            kind: "suite",
-            name: suite.name,
-            fullName: suite.fullName,
-            file,
-            state: mapSuiteState(suiteState),
-            durationMs: null,
-            counts,
-            error: null,
-            traces: [],
-            children
-        };
-    }
-    buildTestNode(testCase, file) {
-        const result = testCase.result();
-        const diagnostic = testCase.diagnostic();
-        const state = mapTestResult(result, testCase.options.mode);
-        let error = null;
-        if (result.state === "failed" && result.errors.length > 0) {
-            const firstError = result.errors[0];
-            error = {
-                message: firstError.message ?? String(firstError),
-                stack: firstError.stack
-            };
-        }
-        const raw = testCase.meta().traces;
-        let traces = [];
-        if (Array.isArray(raw) && raw.length > 0) {
-            traces = raw.filter(isSerializedTrace);
-        }
-        return {
-            id: `${file}::${testCase.fullName}`,
-            kind: "test",
-            name: testCase.name,
-            fullName: testCase.fullName,
-            file,
-            state,
-            durationMs: diagnostic ? diagnostic.duration : null,
-            counts: countFromState(state),
-            error,
-            traces,
-            children: []
-        };
-    }
-}
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+
+//#region src/testing/dev-vitest-manager.ts
 function mapModuleState(state) {
-    switch(state){
-        case "passed":
-            return "passed";
-        case "failed":
-            return "failed";
-        case "skipped":
-            return "skipped";
-        case "pending":
-        case "queued":
-            return "running";
-        default:
-            return "unknown";
-    }
+	switch (state) {
+		case "passed": return "passed";
+		case "failed": return "failed";
+		case "skipped": return "skipped";
+		case "pending":
+		case "queued": return "running";
+		default: return "unknown";
+	}
 }
 function mapSuiteState(state) {
-    switch(state){
-        case "passed":
-            return "passed";
-        case "failed":
-            return "failed";
-        case "skipped":
-            return "skipped";
-        case "pending":
-            return "running";
-        default:
-            return "unknown";
-    }
+	switch (state) {
+		case "passed": return "passed";
+		case "failed": return "failed";
+		case "skipped": return "skipped";
+		case "pending": return "running";
+		default: return "unknown";
+	}
 }
 function mapTestResult(result, mode) {
-    switch(result.state){
-        case "passed":
-            return "passed";
-        case "failed":
-            return "failed";
-        case "skipped":
-            return mode === "todo" ? "todo" : "skipped";
-        case "pending":
-            return "running";
-        default:
-            return "unknown";
-    }
+	switch (result.state) {
+		case "passed": return "passed";
+		case "failed": return "failed";
+		case "skipped": return mode === "todo" ? "todo" : "skipped";
+		case "pending": return "running";
+		default: return "unknown";
+	}
 }
 function countFromState(state) {
-    switch(state){
-        case "passed":
-            return {
-                total: 1,
-                passed: 1,
-                failed: 0,
-                skipped: 0
-            };
-        case "failed":
-            return {
-                total: 1,
-                passed: 0,
-                failed: 1,
-                skipped: 0
-            };
-        case "skipped":
-        case "todo":
-            return {
-                total: 1,
-                passed: 0,
-                failed: 0,
-                skipped: 1
-            };
-        default:
-            // running/unknown 상태도 total에 포함하여 파일 노드 counts.total이 하위 합계와 일치하도록 함
-            return {
-                total: 1,
-                passed: 0,
-                failed: 0,
-                skipped: 0
-            };
-    }
+	switch (state) {
+		case "passed": return {
+			total: 1,
+			passed: 1,
+			failed: 0,
+			skipped: 0
+		};
+		case "failed": return {
+			total: 1,
+			passed: 0,
+			failed: 1,
+			skipped: 0
+		};
+		case "skipped":
+		case "todo": return {
+			total: 1,
+			passed: 0,
+			failed: 0,
+			skipped: 1
+		};
+		default: return {
+			total: 1,
+			passed: 0,
+			failed: 0,
+			skipped: 0
+		};
+	}
 }
 function aggregateCounts(children) {
-    let total = 0;
-    let passed = 0;
-    let failed = 0;
-    let skipped = 0;
-    for (const child of children){
-        total += child.counts.total;
-        passed += child.counts.passed;
-        failed += child.counts.failed;
-        skipped += child.counts.skipped;
-    }
-    return {
-        total,
-        passed,
-        failed,
-        skipped
-    };
+	let total = 0;
+	let passed = 0;
+	let failed = 0;
+	let skipped = 0;
+	for (const child of children) {
+		total += child.counts.total;
+		passed += child.counts.passed;
+		failed += child.counts.failed;
+		skipped += child.counts.skipped;
+	}
+	return {
+		total,
+		passed,
+		failed,
+		skipped
+	};
 }
 function getResultCompletenessScore(node) {
-    let score = 0;
-    // 테스트 수가 더 많은 결과를 우선하여 중복 파일 병합 시 정보 손실을 줄입니다.
-    score += node.counts.total * 1000;
-    score += node.children.length * 100;
-    if (node.durationMs !== null) score += 10;
-    switch(node.state){
-        case "failed":
-            score += 5;
-            break;
-        case "passed":
-            score += 4;
-            break;
-        case "skipped":
-            score += 3;
-            break;
-        case "todo":
-            score += 2;
-            break;
-        case "running":
-            score += 1;
-            break;
-        case "unknown":
-            break;
-        default:
-            break;
-    }
-    return score;
+	let score = 0;
+	score += node.counts.total * 1e3;
+	score += node.children.length * 100;
+	if (node.durationMs !== null) score += 10;
+	switch (node.state) {
+		case "failed":
+			score += 5;
+			break;
+		case "passed":
+			score += 4;
+			break;
+		case "skipped":
+			score += 3;
+			break;
+		case "todo":
+			score += 2;
+			break;
+		case "running":
+			score += 1;
+			break;
+		case "unknown": break;
+		default: break;
+	}
+	return score;
 }
 function isSerializedTrace(value) {
-    if (typeof value !== "object" || value === null) {
-        return false;
-    }
-    const v = value;
-    return typeof v.key === "string" && typeof v.filePath === "string" && typeof v.lineNumber === "number" && typeof v.at === "string" && "value" in v;
+	if (typeof value !== "object" || value === null) {
+		return false;
+	}
+	const v = value;
+	return typeof v.key === "string" && typeof v.filePath === "string" && typeof v.lineNumber === "number" && typeof v.at === "string" && "value" in v;
 }
+var DevVitestManager;
+var init_dev_vitest_manager = __esmMin((() => {
+	DevVitestManager = class {
+		vitest = null;
+		running = false;
+		lastRunAt = null;
+		queue = [];
+		processing = false;
+		closed = false;
+		eventListeners = new Set();
+		currentRunContext = null;
+		addEventListener(listener) {
+			this.eventListeners.add(listener);
+		}
+		removeEventListener(listener) {
+			this.eventListeners.delete(listener);
+		}
+		emitEvent(event, data) {
+			for (const listener of this.eventListeners) {
+				listener(event, data);
+			}
+		}
+		async start(vitestConfigPath) {
+			if (this.vitest) {
+				return;
+			}
+			const { createVitest } = await import("vitest/node");
+			const viteOverrides = { server: { watch: null } };
+			const cliOptions = {
+				watch: true,
+				standalone: true,
+				forceRerunTriggers: [],
+				config: vitestConfigPath,
+				env: { NODE_ENV: "test" }
+			};
+			const realtimeReporter = this.createRealtimeProgressReporter();
+			viteOverrides.plugins = [...viteOverrides.plugins ?? [], {
+				name: "sonamu-realtime-reporter",
+				configureVitest({ vitest: vitestInstance }) {
+					const reporters = vitestInstance.config.reporters;
+					if (!reporters.includes(realtimeReporter)) {
+						reporters.push(realtimeReporter);
+					}
+				}
+			}];
+			const vitest = await createVitest("test", cliOptions, viteOverrides);
+			try {
+				await vitest.standalone();
+			} catch (err) {
+				await vitest.close();
+				throw err;
+			}
+			this.vitest = vitest;
+			this.vitest.onFilterWatchedSpecification((_spec) => false);
+			this.closed = false;
+		}
+		async run(opts, runId) {
+			if (this.closed) {
+				throw new Error("DevVitestManager is already shut down");
+			}
+			if (!this.vitest) {
+				throw new Error("DevVitestManager is not started");
+			}
+			return new Promise((resolve, reject) => {
+				const task = () => this.executeRun(opts, runId);
+				this.queue.push({
+					runId,
+					task,
+					resolve,
+					reject
+				});
+				this.processQueue();
+			});
+		}
+		getStatus() {
+			return {
+				ready: this.vitest !== null && !this.closed,
+				running: this.running,
+				lastRunAt: this.lastRunAt
+			};
+		}
+		/**
+		* 변경된 파일을 Vitest 모듈 그래프에서 무효화합니다.
+		* syncFromWatcher에서 호출되어 다음 테스트 실행 시 최신 코드를 사용하도록 합니다.
+		*/
+		invalidateFiles(filePaths) {
+			if (!this.vitest || this.closed) {
+				return;
+			}
+			for (const filePath of filePaths) {
+				this.vitest.invalidateFile(filePath);
+			}
+		}
+		async shutdown() {
+			if (this.closed) {
+				return;
+			}
+			this.closed = true;
+			while (this.queue.length > 0) {
+				const entry = this.queue.shift();
+				if (entry) {
+					entry.reject(new Error("DevVitestManager is being shut down"));
+				}
+			}
+			if (this.vitest) {
+				await this.vitest.close();
+				this.vitest = null;
+			}
+		}
+		async processQueue() {
+			if (this.processing) {
+				return;
+			}
+			this.processing = true;
+			try {
+				while (this.queue.length > 0) {
+					const entry = this.queue.shift();
+					if (!entry) break;
+					if (this.closed) {
+						entry.reject(new Error("DevVitestManager is already shut down"));
+						continue;
+					}
+					try {
+						const result = await entry.task();
+						entry.resolve(result);
+					} catch (err) {
+						entry.reject(err);
+					}
+				}
+			} finally {
+				this.processing = false;
+			}
+		}
+		async executeRun(opts, runId) {
+			const vitest = this.vitest;
+			if (!vitest) {
+				throw new Error("DevVitestManager is not started");
+			}
+			this.running = true;
+			const startTime = Date.now();
+			if (opts.pattern) {
+				vitest.setGlobalTestNamePattern(opts.pattern);
+			}
+			try {
+				const specs = opts.files ? await vitest.globTestSpecifications(opts.files) : await vitest.globTestSpecifications();
+				const specModuleIds = new Set(specs.map((s) => s.moduleId));
+				this.currentRunContext = {
+					runId,
+					startedAt: new Date().toISOString(),
+					specModuleIds
+				};
+				const allTestsRun = !opts.files || opts.files.length === 0;
+				const runResult = await vitest.runTestSpecifications(specs, allTestsRun);
+				const durationMs = Date.now() - startTime;
+				this.lastRunAt = new Date().toISOString();
+				return this.collectResults(runResult, durationMs, specModuleIds);
+			} finally {
+				this.currentRunContext = null;
+				if (opts.pattern) {
+					vitest.resetGlobalTestNamePattern();
+				}
+				this.running = false;
+			}
+		}
+		createRealtimeProgressReporter() {
+			const emitProgress = (kind, phase, fileId, nodeId, parentId, node) => {
+				const ctx = this.currentRunContext;
+				if (!ctx) return;
+				this.emitEvent("runNodeProgress", {
+					schemaVersion: 1,
+					runId: ctx.runId,
+					startedAt: ctx.startedAt,
+					at: new Date().toISOString(),
+					kind,
+					phase,
+					fileId,
+					nodeId,
+					parentId,
+					node
+				});
+			};
+			return {
+				onTestModuleQueued: (testModule) => {
+					const ctx = this.currentRunContext;
+					if (!ctx || !ctx.specModuleIds.has(testModule.moduleId)) return;
+					const fileId = testModule.moduleId;
+					emitProgress("file", "ready", fileId, fileId, null, this.buildFileProgressNode(testModule, "ready"));
+				},
+				onTestModuleEnd: (testModule) => {
+					const ctx = this.currentRunContext;
+					if (!ctx || !ctx.specModuleIds.has(testModule.moduleId)) return;
+					const fileId = testModule.moduleId;
+					emitProgress("file", "result", fileId, fileId, null, this.buildFileNode(testModule));
+				},
+				onTestSuiteReady: (testSuite) => {
+					const ctx = this.currentRunContext;
+					if (!ctx || !ctx.specModuleIds.has(testSuite.module.moduleId)) return;
+					const fileId = testSuite.module.moduleId;
+					const nodeId = `${fileId}::${testSuite.fullName}`;
+					const parentId = this.resolveSuiteParentId(testSuite);
+					emitProgress("suite", "ready", fileId, nodeId, parentId, this.buildSuiteProgressNode(testSuite, "ready"));
+				},
+				onTestSuiteResult: (testSuite) => {
+					const ctx = this.currentRunContext;
+					if (!ctx || !ctx.specModuleIds.has(testSuite.module.moduleId)) return;
+					const fileId = testSuite.module.moduleId;
+					const nodeId = `${fileId}::${testSuite.fullName}`;
+					const parentId = this.resolveSuiteParentId(testSuite);
+					emitProgress("suite", "result", fileId, nodeId, parentId, this.buildSuiteNode(testSuite, fileId));
+				},
+				onTestCaseReady: (testCase) => {
+					const ctx = this.currentRunContext;
+					if (!ctx || !ctx.specModuleIds.has(testCase.module.moduleId)) return;
+					const fileId = testCase.module.moduleId;
+					const nodeId = `${fileId}::${testCase.fullName}`;
+					const parentId = this.resolveTestParentId(testCase);
+					emitProgress("test", "ready", fileId, nodeId, parentId, this.buildTestProgressNode(testCase, "ready"));
+				},
+				onTestCaseResult: (testCase) => {
+					const ctx = this.currentRunContext;
+					if (!ctx || !ctx.specModuleIds.has(testCase.module.moduleId)) return;
+					const fileId = testCase.module.moduleId;
+					const nodeId = `${fileId}::${testCase.fullName}`;
+					const parentId = this.resolveTestParentId(testCase);
+					emitProgress("test", "result", fileId, nodeId, parentId, this.buildTestNode(testCase, fileId));
+				}
+			};
+		}
+		buildFileProgressNode(testModule, _phase) {
+			return {
+				id: testModule.moduleId,
+				kind: "file",
+				name: testModule.moduleId,
+				fullName: testModule.moduleId,
+				file: testModule.moduleId,
+				state: "running",
+				durationMs: null,
+				counts: {
+					total: 0,
+					passed: 0,
+					failed: 0,
+					skipped: 0
+				},
+				error: null,
+				traces: [],
+				children: []
+			};
+		}
+		buildSuiteProgressNode(testSuite, _phase) {
+			const fileId = testSuite.module.moduleId;
+			return {
+				id: `${fileId}::${testSuite.fullName}`,
+				kind: "suite",
+				name: testSuite.name,
+				fullName: testSuite.fullName,
+				file: fileId,
+				state: "running",
+				durationMs: null,
+				counts: {
+					total: 0,
+					passed: 0,
+					failed: 0,
+					skipped: 0
+				},
+				error: null,
+				traces: [],
+				children: []
+			};
+		}
+		buildTestProgressNode(testCase, _phase) {
+			const fileId = testCase.module.moduleId;
+			return {
+				id: `${fileId}::${testCase.fullName}`,
+				kind: "test",
+				name: testCase.name,
+				fullName: testCase.fullName,
+				file: fileId,
+				state: "running",
+				durationMs: null,
+				counts: {
+					total: 1,
+					passed: 0,
+					failed: 0,
+					skipped: 0
+				},
+				error: null,
+				traces: [],
+				children: []
+			};
+		}
+		resolveSuiteParentId(testSuite) {
+			const parent = testSuite.parent;
+			if (parent.type === "suite") {
+				return `${testSuite.module.moduleId}::${parent.fullName}`;
+			}
+			return testSuite.module.moduleId;
+		}
+		resolveTestParentId(testCase) {
+			const parent = testCase.parent;
+			if (parent.type === "suite") {
+				return `${testCase.module.moduleId}::${parent.fullName}`;
+			}
+			return testCase.module.moduleId;
+		}
+		collectResults(runResult, durationMs, specModuleIds) {
+			const resultsByFile = new Map();
+			for (const testModule of runResult.testModules) {
+				if (!specModuleIds.has(testModule.moduleId)) continue;
+				const nextResult = this.buildFileNode(testModule);
+				const existingResult = resultsByFile.get(nextResult.id);
+				if (!existingResult) {
+					resultsByFile.set(nextResult.id, nextResult);
+					continue;
+				}
+				const existingScore = getResultCompletenessScore(existingResult);
+				const nextScore = getResultCompletenessScore(nextResult);
+				if (nextScore >= existingScore) {
+					resultsByFile.set(nextResult.id, nextResult);
+				}
+			}
+			const results = Array.from(resultsByFile.values());
+			const summary = aggregateCounts(results);
+			return {
+				ok: summary.failed === 0,
+				summary: {
+					...summary,
+					durationMs
+				},
+				results
+			};
+		}
+		buildFileNode(testModule) {
+			const file = testModule.moduleId;
+			const children = this.buildChildNodes(testModule, file);
+			const counts = aggregateCounts(children);
+			const moduleState = testModule.state();
+			const diagnostic = testModule.diagnostic();
+			return {
+				id: testModule.moduleId,
+				kind: "file",
+				name: testModule.moduleId,
+				fullName: testModule.moduleId,
+				file,
+				state: mapModuleState(moduleState),
+				durationMs: diagnostic.duration > 0 ? diagnostic.duration : null,
+				counts,
+				error: null,
+				traces: [],
+				children
+			};
+		}
+		buildChildNodes(parent, file) {
+			const result = [];
+			for (const child of parent.children) {
+				if (child.type === "suite") {
+					result.push(this.buildSuiteNode(child, file));
+				} else {
+					result.push(this.buildTestNode(child, file));
+				}
+			}
+			return result;
+		}
+		buildSuiteNode(suite, file) {
+			const children = this.buildChildNodes(suite, file);
+			const counts = aggregateCounts(children);
+			const suiteState = suite.state();
+			return {
+				id: `${file}::${suite.fullName}`,
+				kind: "suite",
+				name: suite.name,
+				fullName: suite.fullName,
+				file,
+				state: mapSuiteState(suiteState),
+				durationMs: null,
+				counts,
+				error: null,
+				traces: [],
+				children
+			};
+		}
+		buildTestNode(testCase, file) {
+			const result = testCase.result();
+			const diagnostic = testCase.diagnostic();
+			const state = mapTestResult(result, testCase.options.mode);
+			let error = null;
+			if (result.state === "failed" && result.errors.length > 0) {
+				const firstError = result.errors[0];
+				error = {
+					message: firstError.message ?? String(firstError),
+					stack: firstError.stack
+				};
+			}
+			const raw = testCase.meta().traces;
+			let traces = [];
+			if (Array.isArray(raw) && raw.length > 0) {
+				traces = raw.filter(isSerializedTrace);
+			}
+			return {
+				id: `${file}::${testCase.fullName}`,
+				kind: "test",
+				name: testCase.name,
+				fullName: testCase.fullName,
+				file,
+				state,
+				durationMs: diagnostic ? diagnostic.duration : null,
+				counts: countFromState(state),
+				error,
+				traces,
+				children: []
+			};
+		}
+	};
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/testing/dev-vitest-manager.ts"],"sourcesContent":["import type { UserConfig as ViteUserConfig } from \"vite\";\nimport type {\n  CliOptions,\n  Reporter,\n  TestCase,\n  TestModule,\n  TestRunResult,\n  TestSpecification,\n  TestSuite,\n  Vitest,\n} from \"vitest/node\";\nimport type { SerializedTrace } from \"../naite/naite\";\n\n// 테스트 한 건의 trace 모음\nexport type TestNodeKind = \"file\" | \"suite\" | \"test\";\nexport type TestState = \"passed\" | \"failed\" | \"skipped\" | \"todo\" | \"running\" | \"unknown\";\n\nexport type TestCaseResult = {\n  id: string;\n  kind: TestNodeKind;\n  name: string;\n  fullName: string;\n  file: string;\n  state: TestState;\n  durationMs: number | null;\n  counts: { total: number; passed: number; failed: number; skipped: number };\n  error: { message: string; stack?: string } | null;\n  traces: SerializedTrace[];\n  children: TestCaseResult[];\n};\n\nexport type RunResult = {\n  ok: boolean;\n  summary: {\n    total: number;\n    passed: number;\n    failed: number;\n    skipped: number;\n    durationMs: number;\n  };\n  results: TestCaseResult[];\n};\n\nexport type ManagerStatus = {\n  ready: boolean;\n  running: boolean;\n  lastRunAt: string | null;\n};\n\nexport type TestEventListener = (event: string, data: unknown) => void;\n\ntype QueueEntry = {\n  runId: string;\n  task: () => Promise<RunResult>;\n  resolve: (result: RunResult) => void;\n  reject: (error: unknown) => void;\n};\n\nexport class DevVitestManager {\n  private vitest: Vitest | null = null;\n  private running = false;\n  private lastRunAt: string | null = null;\n  private queue: QueueEntry[] = [];\n  private processing = false;\n  private closed = false;\n  private eventListeners = new Set<TestEventListener>();\n  private currentRunContext: {\n    runId: string;\n    startedAt: string;\n    specModuleIds: Set<string>;\n  } | null = null;\n\n  addEventListener(listener: TestEventListener): void {\n    this.eventListeners.add(listener);\n  }\n\n  removeEventListener(listener: TestEventListener): void {\n    this.eventListeners.delete(listener);\n  }\n\n  emitEvent(event: string, data: unknown): void {\n    for (const listener of this.eventListeners) {\n      listener(event, data);\n    }\n  }\n\n  async start(vitestConfigPath?: string): Promise<void> {\n    // 이미 시작된 경우 중복 초기화를 방지\n    if (this.vitest) {\n      return;\n    }\n\n    const { createVitest } = await import(\"vitest/node\");\n\n    const viteOverrides: ViteUserConfig = {\n      server: { watch: null },\n    };\n\n    const cliOptions: CliOptions = {\n      watch: true,\n      standalone: true,\n      forceRerunTriggers: [],\n      config: vitestConfigPath,\n      env: {\n        NODE_ENV: \"test\",\n      },\n    };\n\n    const realtimeReporter = this.createRealtimeProgressReporter();\n    viteOverrides.plugins = [\n      ...(viteOverrides.plugins ?? []),\n      {\n        name: \"sonamu-realtime-reporter\",\n        configureVitest({ vitest: vitestInstance }: { vitest: Vitest }) {\n          const reporters = vitestInstance.config.reporters;\n          if (!reporters.includes(realtimeReporter)) {\n            reporters.push(realtimeReporter);\n          }\n        },\n      },\n    ];\n\n    const vitest = await createVitest(\"test\", cliOptions, viteOverrides);\n    try {\n      await vitest.init();\n    } catch (err) {\n      await vitest.close();\n      throw err;\n    }\n\n    this.vitest = vitest;\n    this.vitest.onFilterWatchedSpecification((_spec) => false);\n    this.closed = false;\n  }\n\n  async run(opts: { files?: string[]; pattern?: string }, runId: string): Promise<RunResult> {\n    if (this.closed) {\n      throw new Error(\"DevVitestManager is already shut down\");\n    }\n    if (!this.vitest) {\n      throw new Error(\"DevVitestManager is not started\");\n    }\n\n    return new Promise<RunResult>((resolve, reject) => {\n      const task = () => this.executeRun(opts, runId);\n      this.queue.push({ runId, task, resolve, reject });\n      this.processQueue();\n    });\n  }\n\n  getStatus(): ManagerStatus {\n    return {\n      ready: this.vitest !== null && !this.closed,\n      running: this.running,\n      lastRunAt: this.lastRunAt,\n    };\n  }\n\n  /**\n   * 변경된 파일을 Vitest 모듈 그래프에서 무효화합니다.\n   * syncFromWatcher에서 호출되어 다음 테스트 실행 시 최신 코드를 사용하도록 합니다.\n   */\n  invalidateFiles(filePaths: string[]): void {\n    if (!this.vitest || this.closed) {\n      return;\n    }\n    for (const filePath of filePaths) {\n      this.vitest.invalidateFile(filePath);\n    }\n  }\n\n  async shutdown(): Promise<void> {\n    if (this.closed) {\n      return;\n    }\n    this.closed = true;\n\n    // 큐에 남은 작업들을 reject하여 호출자가 영구 대기하지 않도록 정리\n    while (this.queue.length > 0) {\n      const entry = this.queue.shift();\n      if (entry) {\n        entry.reject(new Error(\"DevVitestManager is being shut down\"));\n      }\n    }\n\n    if (this.vitest) {\n      await this.vitest.close();\n      this.vitest = null;\n    }\n  }\n\n  private async processQueue(): Promise<void> {\n    if (this.processing) {\n      return;\n    }\n    this.processing = true;\n\n    try {\n      while (this.queue.length > 0) {\n        const entry = this.queue.shift();\n        if (!entry) break;\n        if (this.closed) {\n          entry.reject(new Error(\"DevVitestManager is already shut down\"));\n          continue;\n        }\n\n        try {\n          const result = await entry.task();\n          entry.resolve(result);\n        } catch (err) {\n          entry.reject(err);\n        }\n      }\n    } finally {\n      this.processing = false;\n    }\n  }\n\n  private async executeRun(\n    opts: { files?: string[]; pattern?: string },\n    runId: string,\n  ): Promise<RunResult> {\n    const vitest = this.vitest;\n    if (!vitest) {\n      throw new Error(\"DevVitestManager is not started\");\n    }\n\n    this.running = true;\n    const startTime = Date.now();\n\n    if (opts.pattern) {\n      vitest.setGlobalTestNamePattern(opts.pattern);\n    }\n\n    try {\n      const specs: TestSpecification[] = opts.files\n        ? await vitest.globTestSpecifications(opts.files)\n        : await vitest.globTestSpecifications();\n\n      const specModuleIds = new Set(specs.map((s) => s.moduleId));\n      // routes에서 생성한 runId를 그대로 사용하여 runStarted/runNodeProgress/runCompleted 간 일관성 보장\n      this.currentRunContext = {\n        runId,\n        startedAt: new Date().toISOString(),\n        specModuleIds,\n      };\n\n      const allTestsRun = !opts.files || opts.files.length === 0;\n      const runResult: TestRunResult = await vitest.runTestSpecifications(specs, allTestsRun);\n\n      const durationMs = Date.now() - startTime;\n      this.lastRunAt = new Date().toISOString();\n\n      return this.collectResults(runResult, durationMs, specModuleIds);\n    } finally {\n      this.currentRunContext = null;\n      if (opts.pattern) {\n        vitest.resetGlobalTestNamePattern();\n      }\n      this.running = false;\n    }\n  }\n\n  private createRealtimeProgressReporter(): Reporter {\n    const emitProgress = (\n      kind: \"file\" | \"suite\" | \"test\",\n      phase: \"ready\" | \"result\",\n      fileId: string,\n      nodeId: string,\n      parentId: string | null,\n      node: TestCaseResult,\n    ) => {\n      const ctx = this.currentRunContext;\n      if (!ctx) return;\n      this.emitEvent(\"runNodeProgress\", {\n        schemaVersion: 1,\n        runId: ctx.runId,\n        startedAt: ctx.startedAt,\n        at: new Date().toISOString(),\n        kind,\n        phase,\n        fileId,\n        nodeId,\n        parentId,\n        node,\n      });\n    };\n\n    return {\n      onTestModuleQueued: (testModule: TestModule) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testModule.moduleId)) return;\n        const fileId = testModule.moduleId;\n        emitProgress(\n          \"file\",\n          \"ready\",\n          fileId,\n          fileId,\n          null,\n          this.buildFileProgressNode(testModule, \"ready\"),\n        );\n      },\n      onTestModuleEnd: (testModule: TestModule) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testModule.moduleId)) return;\n        const fileId = testModule.moduleId;\n        emitProgress(\"file\", \"result\", fileId, fileId, null, this.buildFileNode(testModule));\n      },\n      onTestSuiteReady: (testSuite: TestSuite) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testSuite.module.moduleId)) return;\n        const fileId = testSuite.module.moduleId;\n        const nodeId = `${fileId}::${testSuite.fullName}`;\n        const parentId = this.resolveSuiteParentId(testSuite);\n        emitProgress(\n          \"suite\",\n          \"ready\",\n          fileId,\n          nodeId,\n          parentId,\n          this.buildSuiteProgressNode(testSuite, \"ready\"),\n        );\n      },\n      onTestSuiteResult: (testSuite: TestSuite) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testSuite.module.moduleId)) return;\n        const fileId = testSuite.module.moduleId;\n        const nodeId = `${fileId}::${testSuite.fullName}`;\n        const parentId = this.resolveSuiteParentId(testSuite);\n        emitProgress(\n          \"suite\",\n          \"result\",\n          fileId,\n          nodeId,\n          parentId,\n          this.buildSuiteNode(testSuite, fileId),\n        );\n      },\n      onTestCaseReady: (testCase: TestCase) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testCase.module.moduleId)) return;\n        const fileId = testCase.module.moduleId;\n        const nodeId = `${fileId}::${testCase.fullName}`;\n        const parentId = this.resolveTestParentId(testCase);\n        emitProgress(\n          \"test\",\n          \"ready\",\n          fileId,\n          nodeId,\n          parentId,\n          this.buildTestProgressNode(testCase, \"ready\"),\n        );\n      },\n      onTestCaseResult: (testCase: TestCase) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testCase.module.moduleId)) return;\n        const fileId = testCase.module.moduleId;\n        const nodeId = `${fileId}::${testCase.fullName}`;\n        const parentId = this.resolveTestParentId(testCase);\n        emitProgress(\n          \"test\",\n          \"result\",\n          fileId,\n          nodeId,\n          parentId,\n          this.buildTestNode(testCase, fileId),\n        );\n      },\n    };\n  }\n\n  private buildFileProgressNode(testModule: TestModule, _phase: \"ready\"): TestCaseResult {\n    return {\n      id: testModule.moduleId,\n      kind: \"file\",\n      name: testModule.moduleId,\n      fullName: testModule.moduleId,\n      file: testModule.moduleId,\n      state: \"running\",\n      durationMs: null,\n      counts: { total: 0, passed: 0, failed: 0, skipped: 0 },\n      error: null,\n      traces: [],\n      children: [],\n    };\n  }\n\n  private buildSuiteProgressNode(testSuite: TestSuite, _phase: \"ready\"): TestCaseResult {\n    const fileId = testSuite.module.moduleId;\n    return {\n      id: `${fileId}::${testSuite.fullName}`,\n      kind: \"suite\",\n      name: testSuite.name,\n      fullName: testSuite.fullName,\n      file: fileId,\n      state: \"running\",\n      durationMs: null,\n      counts: { total: 0, passed: 0, failed: 0, skipped: 0 },\n      error: null,\n      traces: [],\n      children: [],\n    };\n  }\n\n  private buildTestProgressNode(testCase: TestCase, _phase: \"ready\"): TestCaseResult {\n    const fileId = testCase.module.moduleId;\n    return {\n      id: `${fileId}::${testCase.fullName}`,\n      kind: \"test\",\n      name: testCase.name,\n      fullName: testCase.fullName,\n      file: fileId,\n      state: \"running\",\n      durationMs: null,\n      counts: { total: 1, passed: 0, failed: 0, skipped: 0 },\n      error: null,\n      traces: [],\n      children: [],\n    };\n  }\n\n  private resolveSuiteParentId(testSuite: TestSuite): string {\n    const parent = testSuite.parent;\n    if (parent.type === \"suite\") {\n      return `${testSuite.module.moduleId}::${parent.fullName}`;\n    }\n    return testSuite.module.moduleId;\n  }\n\n  private resolveTestParentId(testCase: TestCase): string {\n    const parent = testCase.parent;\n    if (parent.type === \"suite\") {\n      return `${testCase.module.moduleId}::${parent.fullName}`;\n    }\n    return testCase.module.moduleId;\n  }\n\n  private collectResults(\n    runResult: TestRunResult,\n    durationMs: number,\n    specModuleIds: Set<string>,\n  ): RunResult {\n    const resultsByFile = new Map<string, TestCaseResult>();\n\n    for (const testModule of runResult.testModules) {\n      if (!specModuleIds.has(testModule.moduleId)) continue;\n      const nextResult = this.buildFileNode(testModule);\n      const existingResult = resultsByFile.get(nextResult.id);\n\n      if (!existingResult) {\n        resultsByFile.set(nextResult.id, nextResult);\n        continue;\n      }\n\n      const existingScore = getResultCompletenessScore(existingResult);\n      const nextScore = getResultCompletenessScore(nextResult);\n      if (nextScore >= existingScore) {\n        resultsByFile.set(nextResult.id, nextResult);\n      }\n    }\n\n    const results = Array.from(resultsByFile.values());\n    const summary = aggregateCounts(results);\n\n    return {\n      ok: summary.failed === 0,\n      summary: { ...summary, durationMs },\n      results,\n    };\n  }\n\n  private buildFileNode(testModule: TestModule): TestCaseResult {\n    const file = testModule.moduleId;\n    const children = this.buildChildNodes(testModule, file);\n    const counts = aggregateCounts(children);\n    const moduleState = testModule.state();\n    const diagnostic = testModule.diagnostic();\n\n    return {\n      id: testModule.moduleId,\n      kind: \"file\",\n      name: testModule.moduleId,\n      fullName: testModule.moduleId,\n      file,\n      state: mapModuleState(moduleState),\n      durationMs: diagnostic.duration > 0 ? diagnostic.duration : null,\n      counts,\n      error: null,\n      traces: [],\n      children,\n    };\n  }\n\n  private buildChildNodes(parent: TestModule | TestSuite, file: string): TestCaseResult[] {\n    const result: TestCaseResult[] = [];\n    for (const child of parent.children) {\n      if (child.type === \"suite\") {\n        result.push(this.buildSuiteNode(child, file));\n      } else {\n        result.push(this.buildTestNode(child, file));\n      }\n    }\n    return result;\n  }\n\n  private buildSuiteNode(suite: TestSuite, file: string): TestCaseResult {\n    const children = this.buildChildNodes(suite, file);\n    const counts = aggregateCounts(children);\n    const suiteState = suite.state();\n\n    return {\n      id: `${file}::${suite.fullName}`,\n      kind: \"suite\",\n      name: suite.name,\n      fullName: suite.fullName,\n      file,\n      state: mapSuiteState(suiteState),\n      durationMs: null,\n      counts,\n      error: null,\n      traces: [],\n      children,\n    };\n  }\n\n  private buildTestNode(testCase: TestCase, file: string): TestCaseResult {\n    const result = testCase.result();\n    const diagnostic = testCase.diagnostic();\n    const state = mapTestResult(result, testCase.options.mode);\n\n    let error: { message: string; stack?: string } | null = null;\n    if (result.state === \"failed\" && result.errors.length > 0) {\n      const firstError = result.errors[0];\n      error = {\n        message: firstError.message ?? String(firstError),\n        stack: firstError.stack,\n      };\n    }\n\n    const raw = testCase.meta().traces;\n    let traces: SerializedTrace[] = [];\n    if (Array.isArray(raw) && raw.length > 0) {\n      traces = raw.filter(isSerializedTrace);\n    }\n\n    return {\n      id: `${file}::${testCase.fullName}`,\n      kind: \"test\",\n      name: testCase.name,\n      fullName: testCase.fullName,\n      file,\n      state,\n      durationMs: diagnostic ? diagnostic.duration : null,\n      counts: countFromState(state),\n      error,\n      traces,\n      children: [],\n    };\n  }\n}\n\nfunction mapModuleState(state: \"skipped\" | \"pending\" | \"failed\" | \"passed\" | \"queued\"): TestState {\n  switch (state) {\n    case \"passed\":\n      return \"passed\";\n    case \"failed\":\n      return \"failed\";\n    case \"skipped\":\n      return \"skipped\";\n    case \"pending\":\n    case \"queued\":\n      return \"running\";\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction mapSuiteState(state: \"skipped\" | \"pending\" | \"failed\" | \"passed\"): TestState {\n  switch (state) {\n    case \"passed\":\n      return \"passed\";\n    case \"failed\":\n      return \"failed\";\n    case \"skipped\":\n      return \"skipped\";\n    case \"pending\":\n      return \"running\";\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction mapTestResult(\n  result: ReturnType<TestCase[\"result\"]>,\n  mode: \"run\" | \"only\" | \"skip\" | \"todo\",\n): TestState {\n  switch (result.state) {\n    case \"passed\":\n      return \"passed\";\n    case \"failed\":\n      return \"failed\";\n    case \"skipped\":\n      return mode === \"todo\" ? \"todo\" : \"skipped\";\n    case \"pending\":\n      return \"running\";\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction countFromState(state: TestState): {\n  total: number;\n  passed: number;\n  failed: number;\n  skipped: number;\n} {\n  switch (state) {\n    case \"passed\":\n      return { total: 1, passed: 1, failed: 0, skipped: 0 };\n    case \"failed\":\n      return { total: 1, passed: 0, failed: 1, skipped: 0 };\n    case \"skipped\":\n    case \"todo\":\n      return { total: 1, passed: 0, failed: 0, skipped: 1 };\n    default:\n      // running/unknown 상태도 total에 포함하여 파일 노드 counts.total이 하위 합계와 일치하도록 함\n      return { total: 1, passed: 0, failed: 0, skipped: 0 };\n  }\n}\n\nfunction aggregateCounts(children: TestCaseResult[]): {\n  total: number;\n  passed: number;\n  failed: number;\n  skipped: number;\n} {\n  let total = 0;\n  let passed = 0;\n  let failed = 0;\n  let skipped = 0;\n  for (const child of children) {\n    total += child.counts.total;\n    passed += child.counts.passed;\n    failed += child.counts.failed;\n    skipped += child.counts.skipped;\n  }\n  return { total, passed, failed, skipped };\n}\n\nfunction getResultCompletenessScore(node: TestCaseResult): number {\n  let score = 0;\n  // 테스트 수가 더 많은 결과를 우선하여 중복 파일 병합 시 정보 손실을 줄입니다.\n  score += node.counts.total * 1000;\n  score += node.children.length * 100;\n  if (node.durationMs !== null) score += 10;\n\n  switch (node.state) {\n    case \"failed\":\n      score += 5;\n      break;\n    case \"passed\":\n      score += 4;\n      break;\n    case \"skipped\":\n      score += 3;\n      break;\n    case \"todo\":\n      score += 2;\n      break;\n    case \"running\":\n      score += 1;\n      break;\n    case \"unknown\":\n      break;\n    default:\n      break;\n  }\n\n  return score;\n}\n\nfunction isSerializedTrace(value: unknown): value is SerializedTrace {\n  if (typeof value !== \"object\" || value === null) {\n    return false;\n  }\n  const v = value as Record<string, unknown>;\n  return (\n    typeof v.key === \"string\" &&\n    typeof v.filePath === \"string\" &&\n    typeof v.lineNumber === \"number\" &&\n    typeof v.at === \"string\" &&\n    \"value\" in v\n  );\n}\n"],"names":["DevVitestManager","vitest","running","lastRunAt","queue","processing","closed","eventListeners","Set","currentRunContext","addEventListener","listener","add","removeEventListener","delete","emitEvent","event","data","start","vitestConfigPath","createVitest","viteOverrides","server","watch","cliOptions","standalone","forceRerunTriggers","config","env","NODE_ENV","realtimeReporter","createRealtimeProgressReporter","plugins","name","configureVitest","vitestInstance","reporters","includes","push","init","err","close","onFilterWatchedSpecification","_spec","run","opts","runId","Error","Promise","resolve","reject","task","executeRun","processQueue","getStatus","ready","invalidateFiles","filePaths","filePath","invalidateFile","shutdown","length","entry","shift","result","startTime","Date","now","pattern","setGlobalTestNamePattern","specs","files","globTestSpecifications","specModuleIds","map","s","moduleId","startedAt","toISOString","allTestsRun","runResult","runTestSpecifications","durationMs","collectResults","resetGlobalTestNamePattern","emitProgress","kind","phase","fileId","nodeId","parentId","node","ctx","schemaVersion","at","onTestModuleQueued","testModule","has","buildFileProgressNode","onTestModuleEnd","buildFileNode","onTestSuiteReady","testSuite","module","fullName","resolveSuiteParentId","buildSuiteProgressNode","onTestSuiteResult","buildSuiteNode","onTestCaseReady","testCase","resolveTestParentId","buildTestProgressNode","onTestCaseResult","buildTestNode","_phase","id","file","state","counts","total","passed","failed","skipped","error","traces","children","parent","type","resultsByFile","Map","testModules","nextResult","existingResult","get","set","existingScore","getResultCompletenessScore","nextScore","results","Array","from","values","summary","aggregateCounts","ok","buildChildNodes","moduleState","diagnostic","mapModuleState","duration","child","suite","suiteState","mapSuiteState","mapTestResult","options","mode","errors","firstError","message","String","stack","raw","meta","isArray","filter","isSerializedTrace","countFromState","score","value","v","key","lineNumber"],"mappings":"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"}
+//#endregion
+init_dev_vitest_manager();
+export { DevVitestManager, init_dev_vitest_manager };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"dev-vitest-manager.js","names":["viteOverrides: ViteUserConfig","cliOptions: CliOptions","specs: TestSpecification[]","runResult: TestRunResult","result: TestCaseResult[]","error: { message: string; stack?: string } | null","traces: SerializedTrace[]"],"sources":["../../src/testing/dev-vitest-manager.ts"],"sourcesContent":["import { type UserConfig as ViteUserConfig } from \"vite\";\nimport {\n  type CliOptions,\n  type Reporter,\n  type TestCase,\n  type TestModule,\n  type TestRunResult,\n  type TestSpecification,\n  type TestSuite,\n  type Vitest,\n} from \"vitest/node\";\n\nimport { type SerializedTrace } from \"../naite/naite\";\n\n// 테스트 한 건의 trace 모음\nexport type TestNodeKind = \"file\" | \"suite\" | \"test\";\nexport type TestState = \"passed\" | \"failed\" | \"skipped\" | \"todo\" | \"running\" | \"unknown\";\n\nexport type TestCaseResult = {\n  id: string;\n  kind: TestNodeKind;\n  name: string;\n  fullName: string;\n  file: string;\n  state: TestState;\n  durationMs: number | null;\n  counts: { total: number; passed: number; failed: number; skipped: number };\n  error: { message: string; stack?: string } | null;\n  traces: SerializedTrace[];\n  children: TestCaseResult[];\n};\n\nexport type RunResult = {\n  ok: boolean;\n  summary: {\n    total: number;\n    passed: number;\n    failed: number;\n    skipped: number;\n    durationMs: number;\n  };\n  results: TestCaseResult[];\n};\n\nexport type ManagerStatus = {\n  ready: boolean;\n  running: boolean;\n  lastRunAt: string | null;\n};\n\nexport type TestEventListener = (event: string, data: unknown) => void;\n\ntype QueueEntry = {\n  runId: string;\n  task: () => Promise<RunResult>;\n  resolve: (result: RunResult) => void;\n  reject: (error: unknown) => void;\n};\n\nexport class DevVitestManager {\n  private vitest: Vitest | null = null;\n  private running = false;\n  private lastRunAt: string | null = null;\n  private queue: QueueEntry[] = [];\n  private processing = false;\n  private closed = false;\n  private eventListeners = new Set<TestEventListener>();\n  private currentRunContext: {\n    runId: string;\n    startedAt: string;\n    specModuleIds: Set<string>;\n  } | null = null;\n\n  addEventListener(listener: TestEventListener): void {\n    this.eventListeners.add(listener);\n  }\n\n  removeEventListener(listener: TestEventListener): void {\n    this.eventListeners.delete(listener);\n  }\n\n  emitEvent(event: string, data: unknown): void {\n    for (const listener of this.eventListeners) {\n      listener(event, data);\n    }\n  }\n\n  async start(vitestConfigPath?: string): Promise<void> {\n    // 이미 시작된 경우 중복 초기화를 방지\n    if (this.vitest) {\n      return;\n    }\n\n    const { createVitest } = await import(\"vitest/node\");\n\n    const viteOverrides: ViteUserConfig = {\n      server: { watch: null },\n    };\n\n    const cliOptions: CliOptions = {\n      watch: true,\n      standalone: true,\n      forceRerunTriggers: [],\n      config: vitestConfigPath,\n      env: {\n        NODE_ENV: \"test\",\n      },\n    };\n\n    const realtimeReporter = this.createRealtimeProgressReporter();\n    viteOverrides.plugins = [\n      ...(viteOverrides.plugins ?? []),\n      {\n        name: \"sonamu-realtime-reporter\",\n        configureVitest({ vitest: vitestInstance }: { vitest: Vitest }) {\n          const reporters = vitestInstance.config.reporters;\n          if (!reporters.includes(realtimeReporter)) {\n            reporters.push(realtimeReporter);\n          }\n        },\n      },\n    ];\n\n    const vitest = await createVitest(\"test\", cliOptions, viteOverrides);\n    try {\n      await vitest.standalone();\n    } catch (err) {\n      await vitest.close();\n      throw err;\n    }\n\n    this.vitest = vitest;\n    this.vitest.onFilterWatchedSpecification((_spec) => false);\n    this.closed = false;\n  }\n\n  async run(opts: { files?: string[]; pattern?: string }, runId: string): Promise<RunResult> {\n    if (this.closed) {\n      throw new Error(\"DevVitestManager is already shut down\");\n    }\n    if (!this.vitest) {\n      throw new Error(\"DevVitestManager is not started\");\n    }\n\n    return new Promise<RunResult>((resolve, reject) => {\n      const task = () => this.executeRun(opts, runId);\n      this.queue.push({ runId, task, resolve, reject });\n      this.processQueue();\n    });\n  }\n\n  getStatus(): ManagerStatus {\n    return {\n      ready: this.vitest !== null && !this.closed,\n      running: this.running,\n      lastRunAt: this.lastRunAt,\n    };\n  }\n\n  /**\n   * 변경된 파일을 Vitest 모듈 그래프에서 무효화합니다.\n   * syncFromWatcher에서 호출되어 다음 테스트 실행 시 최신 코드를 사용하도록 합니다.\n   */\n  invalidateFiles(filePaths: string[]): void {\n    if (!this.vitest || this.closed) {\n      return;\n    }\n    for (const filePath of filePaths) {\n      this.vitest.invalidateFile(filePath);\n    }\n  }\n\n  async shutdown(): Promise<void> {\n    if (this.closed) {\n      return;\n    }\n    this.closed = true;\n\n    // 큐에 남은 작업들을 reject하여 호출자가 영구 대기하지 않도록 정리\n    while (this.queue.length > 0) {\n      const entry = this.queue.shift();\n      if (entry) {\n        entry.reject(new Error(\"DevVitestManager is being shut down\"));\n      }\n    }\n\n    if (this.vitest) {\n      await this.vitest.close();\n      this.vitest = null;\n    }\n  }\n\n  private async processQueue(): Promise<void> {\n    if (this.processing) {\n      return;\n    }\n    this.processing = true;\n\n    try {\n      while (this.queue.length > 0) {\n        const entry = this.queue.shift();\n        if (!entry) break;\n        if (this.closed) {\n          entry.reject(new Error(\"DevVitestManager is already shut down\"));\n          continue;\n        }\n\n        try {\n          const result = await entry.task();\n          entry.resolve(result);\n        } catch (err) {\n          entry.reject(err);\n        }\n      }\n    } finally {\n      this.processing = false;\n    }\n  }\n\n  private async executeRun(\n    opts: { files?: string[]; pattern?: string },\n    runId: string,\n  ): Promise<RunResult> {\n    const vitest = this.vitest;\n    if (!vitest) {\n      throw new Error(\"DevVitestManager is not started\");\n    }\n\n    this.running = true;\n    const startTime = Date.now();\n\n    if (opts.pattern) {\n      vitest.setGlobalTestNamePattern(opts.pattern);\n    }\n\n    try {\n      const specs: TestSpecification[] = opts.files\n        ? await vitest.globTestSpecifications(opts.files)\n        : await vitest.globTestSpecifications();\n\n      const specModuleIds = new Set(specs.map((s) => s.moduleId));\n      // routes에서 생성한 runId를 그대로 사용하여 runStarted/runNodeProgress/runCompleted 간 일관성 보장\n      this.currentRunContext = {\n        runId,\n        startedAt: new Date().toISOString(),\n        specModuleIds,\n      };\n\n      const allTestsRun = !opts.files || opts.files.length === 0;\n      const runResult: TestRunResult = await vitest.runTestSpecifications(specs, allTestsRun);\n\n      const durationMs = Date.now() - startTime;\n      this.lastRunAt = new Date().toISOString();\n\n      return this.collectResults(runResult, durationMs, specModuleIds);\n    } finally {\n      this.currentRunContext = null;\n      if (opts.pattern) {\n        vitest.resetGlobalTestNamePattern();\n      }\n      this.running = false;\n    }\n  }\n\n  private createRealtimeProgressReporter(): Reporter {\n    const emitProgress = (\n      kind: \"file\" | \"suite\" | \"test\",\n      phase: \"ready\" | \"result\",\n      fileId: string,\n      nodeId: string,\n      parentId: string | null,\n      node: TestCaseResult,\n    ) => {\n      const ctx = this.currentRunContext;\n      if (!ctx) return;\n      this.emitEvent(\"runNodeProgress\", {\n        schemaVersion: 1,\n        runId: ctx.runId,\n        startedAt: ctx.startedAt,\n        at: new Date().toISOString(),\n        kind,\n        phase,\n        fileId,\n        nodeId,\n        parentId,\n        node,\n      });\n    };\n\n    return {\n      onTestModuleQueued: (testModule: TestModule) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testModule.moduleId)) return;\n        const fileId = testModule.moduleId;\n        emitProgress(\n          \"file\",\n          \"ready\",\n          fileId,\n          fileId,\n          null,\n          this.buildFileProgressNode(testModule, \"ready\"),\n        );\n      },\n      onTestModuleEnd: (testModule: TestModule) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testModule.moduleId)) return;\n        const fileId = testModule.moduleId;\n        emitProgress(\"file\", \"result\", fileId, fileId, null, this.buildFileNode(testModule));\n      },\n      onTestSuiteReady: (testSuite: TestSuite) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testSuite.module.moduleId)) return;\n        const fileId = testSuite.module.moduleId;\n        const nodeId = `${fileId}::${testSuite.fullName}`;\n        const parentId = this.resolveSuiteParentId(testSuite);\n        emitProgress(\n          \"suite\",\n          \"ready\",\n          fileId,\n          nodeId,\n          parentId,\n          this.buildSuiteProgressNode(testSuite, \"ready\"),\n        );\n      },\n      onTestSuiteResult: (testSuite: TestSuite) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testSuite.module.moduleId)) return;\n        const fileId = testSuite.module.moduleId;\n        const nodeId = `${fileId}::${testSuite.fullName}`;\n        const parentId = this.resolveSuiteParentId(testSuite);\n        emitProgress(\n          \"suite\",\n          \"result\",\n          fileId,\n          nodeId,\n          parentId,\n          this.buildSuiteNode(testSuite, fileId),\n        );\n      },\n      onTestCaseReady: (testCase: TestCase) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testCase.module.moduleId)) return;\n        const fileId = testCase.module.moduleId;\n        const nodeId = `${fileId}::${testCase.fullName}`;\n        const parentId = this.resolveTestParentId(testCase);\n        emitProgress(\n          \"test\",\n          \"ready\",\n          fileId,\n          nodeId,\n          parentId,\n          this.buildTestProgressNode(testCase, \"ready\"),\n        );\n      },\n      onTestCaseResult: (testCase: TestCase) => {\n        const ctx = this.currentRunContext;\n        if (!ctx || !ctx.specModuleIds.has(testCase.module.moduleId)) return;\n        const fileId = testCase.module.moduleId;\n        const nodeId = `${fileId}::${testCase.fullName}`;\n        const parentId = this.resolveTestParentId(testCase);\n        emitProgress(\n          \"test\",\n          \"result\",\n          fileId,\n          nodeId,\n          parentId,\n          this.buildTestNode(testCase, fileId),\n        );\n      },\n    };\n  }\n\n  private buildFileProgressNode(testModule: TestModule, _phase: \"ready\"): TestCaseResult {\n    return {\n      id: testModule.moduleId,\n      kind: \"file\",\n      name: testModule.moduleId,\n      fullName: testModule.moduleId,\n      file: testModule.moduleId,\n      state: \"running\",\n      durationMs: null,\n      counts: { total: 0, passed: 0, failed: 0, skipped: 0 },\n      error: null,\n      traces: [],\n      children: [],\n    };\n  }\n\n  private buildSuiteProgressNode(testSuite: TestSuite, _phase: \"ready\"): TestCaseResult {\n    const fileId = testSuite.module.moduleId;\n    return {\n      id: `${fileId}::${testSuite.fullName}`,\n      kind: \"suite\",\n      name: testSuite.name,\n      fullName: testSuite.fullName,\n      file: fileId,\n      state: \"running\",\n      durationMs: null,\n      counts: { total: 0, passed: 0, failed: 0, skipped: 0 },\n      error: null,\n      traces: [],\n      children: [],\n    };\n  }\n\n  private buildTestProgressNode(testCase: TestCase, _phase: \"ready\"): TestCaseResult {\n    const fileId = testCase.module.moduleId;\n    return {\n      id: `${fileId}::${testCase.fullName}`,\n      kind: \"test\",\n      name: testCase.name,\n      fullName: testCase.fullName,\n      file: fileId,\n      state: \"running\",\n      durationMs: null,\n      counts: { total: 1, passed: 0, failed: 0, skipped: 0 },\n      error: null,\n      traces: [],\n      children: [],\n    };\n  }\n\n  private resolveSuiteParentId(testSuite: TestSuite): string {\n    const parent = testSuite.parent;\n    if (parent.type === \"suite\") {\n      return `${testSuite.module.moduleId}::${parent.fullName}`;\n    }\n    return testSuite.module.moduleId;\n  }\n\n  private resolveTestParentId(testCase: TestCase): string {\n    const parent = testCase.parent;\n    if (parent.type === \"suite\") {\n      return `${testCase.module.moduleId}::${parent.fullName}`;\n    }\n    return testCase.module.moduleId;\n  }\n\n  private collectResults(\n    runResult: TestRunResult,\n    durationMs: number,\n    specModuleIds: Set<string>,\n  ): RunResult {\n    const resultsByFile = new Map<string, TestCaseResult>();\n\n    for (const testModule of runResult.testModules) {\n      if (!specModuleIds.has(testModule.moduleId)) continue;\n      const nextResult = this.buildFileNode(testModule);\n      const existingResult = resultsByFile.get(nextResult.id);\n\n      if (!existingResult) {\n        resultsByFile.set(nextResult.id, nextResult);\n        continue;\n      }\n\n      const existingScore = getResultCompletenessScore(existingResult);\n      const nextScore = getResultCompletenessScore(nextResult);\n      if (nextScore >= existingScore) {\n        resultsByFile.set(nextResult.id, nextResult);\n      }\n    }\n\n    const results = Array.from(resultsByFile.values());\n    const summary = aggregateCounts(results);\n\n    return {\n      ok: summary.failed === 0,\n      summary: { ...summary, durationMs },\n      results,\n    };\n  }\n\n  private buildFileNode(testModule: TestModule): TestCaseResult {\n    const file = testModule.moduleId;\n    const children = this.buildChildNodes(testModule, file);\n    const counts = aggregateCounts(children);\n    const moduleState = testModule.state();\n    const diagnostic = testModule.diagnostic();\n\n    return {\n      id: testModule.moduleId,\n      kind: \"file\",\n      name: testModule.moduleId,\n      fullName: testModule.moduleId,\n      file,\n      state: mapModuleState(moduleState),\n      durationMs: diagnostic.duration > 0 ? diagnostic.duration : null,\n      counts,\n      error: null,\n      traces: [],\n      children,\n    };\n  }\n\n  private buildChildNodes(parent: TestModule | TestSuite, file: string): TestCaseResult[] {\n    const result: TestCaseResult[] = [];\n    for (const child of parent.children) {\n      if (child.type === \"suite\") {\n        result.push(this.buildSuiteNode(child, file));\n      } else {\n        result.push(this.buildTestNode(child, file));\n      }\n    }\n    return result;\n  }\n\n  private buildSuiteNode(suite: TestSuite, file: string): TestCaseResult {\n    const children = this.buildChildNodes(suite, file);\n    const counts = aggregateCounts(children);\n    const suiteState = suite.state();\n\n    return {\n      id: `${file}::${suite.fullName}`,\n      kind: \"suite\",\n      name: suite.name,\n      fullName: suite.fullName,\n      file,\n      state: mapSuiteState(suiteState),\n      durationMs: null,\n      counts,\n      error: null,\n      traces: [],\n      children,\n    };\n  }\n\n  private buildTestNode(testCase: TestCase, file: string): TestCaseResult {\n    const result = testCase.result();\n    const diagnostic = testCase.diagnostic();\n    const state = mapTestResult(result, testCase.options.mode);\n\n    let error: { message: string; stack?: string } | null = null;\n    if (result.state === \"failed\" && result.errors.length > 0) {\n      const firstError = result.errors[0];\n      error = {\n        message: firstError.message ?? String(firstError),\n        stack: firstError.stack,\n      };\n    }\n\n    const raw = testCase.meta().traces;\n    let traces: SerializedTrace[] = [];\n    if (Array.isArray(raw) && raw.length > 0) {\n      traces = raw.filter(isSerializedTrace);\n    }\n\n    return {\n      id: `${file}::${testCase.fullName}`,\n      kind: \"test\",\n      name: testCase.name,\n      fullName: testCase.fullName,\n      file,\n      state,\n      durationMs: diagnostic ? diagnostic.duration : null,\n      counts: countFromState(state),\n      error,\n      traces,\n      children: [],\n    };\n  }\n}\n\nfunction mapModuleState(state: \"skipped\" | \"pending\" | \"failed\" | \"passed\" | \"queued\"): TestState {\n  switch (state) {\n    case \"passed\":\n      return \"passed\";\n    case \"failed\":\n      return \"failed\";\n    case \"skipped\":\n      return \"skipped\";\n    case \"pending\":\n    case \"queued\":\n      return \"running\";\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction mapSuiteState(state: \"skipped\" | \"pending\" | \"failed\" | \"passed\"): TestState {\n  switch (state) {\n    case \"passed\":\n      return \"passed\";\n    case \"failed\":\n      return \"failed\";\n    case \"skipped\":\n      return \"skipped\";\n    case \"pending\":\n      return \"running\";\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction mapTestResult(\n  result: ReturnType<TestCase[\"result\"]>,\n  mode: \"run\" | \"only\" | \"skip\" | \"todo\",\n): TestState {\n  switch (result.state) {\n    case \"passed\":\n      return \"passed\";\n    case \"failed\":\n      return \"failed\";\n    case \"skipped\":\n      return mode === \"todo\" ? \"todo\" : \"skipped\";\n    case \"pending\":\n      return \"running\";\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction countFromState(state: TestState): {\n  total: number;\n  passed: number;\n  failed: number;\n  skipped: number;\n} {\n  switch (state) {\n    case \"passed\":\n      return { total: 1, passed: 1, failed: 0, skipped: 0 };\n    case \"failed\":\n      return { total: 1, passed: 0, failed: 1, skipped: 0 };\n    case \"skipped\":\n    case \"todo\":\n      return { total: 1, passed: 0, failed: 0, skipped: 1 };\n    default:\n      // running/unknown 상태도 total에 포함하여 파일 노드 counts.total이 하위 합계와 일치하도록 함\n      return { total: 1, passed: 0, failed: 0, skipped: 0 };\n  }\n}\n\nfunction aggregateCounts(children: TestCaseResult[]): {\n  total: number;\n  passed: number;\n  failed: number;\n  skipped: number;\n} {\n  let total = 0;\n  let passed = 0;\n  let failed = 0;\n  let skipped = 0;\n  for (const child of children) {\n    total += child.counts.total;\n    passed += child.counts.passed;\n    failed += child.counts.failed;\n    skipped += child.counts.skipped;\n  }\n  return { total, passed, failed, skipped };\n}\n\nfunction getResultCompletenessScore(node: TestCaseResult): number {\n  let score = 0;\n  // 테스트 수가 더 많은 결과를 우선하여 중복 파일 병합 시 정보 손실을 줄입니다.\n  score += node.counts.total * 1000;\n  score += node.children.length * 100;\n  if (node.durationMs !== null) score += 10;\n\n  switch (node.state) {\n    case \"failed\":\n      score += 5;\n      break;\n    case \"passed\":\n      score += 4;\n      break;\n    case \"skipped\":\n      score += 3;\n      break;\n    case \"todo\":\n      score += 2;\n      break;\n    case \"running\":\n      score += 1;\n      break;\n    case \"unknown\":\n      break;\n    default:\n      break;\n  }\n\n  return score;\n}\n\nfunction isSerializedTrace(value: unknown): value is SerializedTrace {\n  if (typeof value !== \"object\" || value === null) {\n    return false;\n  }\n  const v = value as Record<string, unknown>;\n  return (\n    typeof v.key === \"string\" &&\n    typeof v.filePath === \"string\" &&\n    typeof v.lineNumber === \"number\" &&\n    typeof v.at === \"string\" &&\n    \"value\" in v\n  );\n}\n"],"mappings":"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"}