sonamu 0.8.26 → 0.9.0

package/dist/naite/naite.js

@@ -1,308 +1,274 @@
-/** biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함 */ import { getLogger } from "@logtape/logtape";
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { convertNaiteKeyToCategory, init_category } from "../logger/category.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { init_object_utils, isSerializable } from "../utils/object-utils.js";
+import { getLogger } from "@logtape/logtape";
 import { get } from "radashi";
-import { Sonamu } from "../api/sonamu.js";
-import { convertNaiteKeyToCategory } from "../logger/category.js";
-import { isSerializable } from "../utils/object-utils.js";
-/**
- * 콜스택을 파싱하여 StackFrame 배열로 반환
- * - extractCallStack 자신과 Naite.t는 제외
- * - runWithContext/runWithMockContext 발견 시 거기서 종료
- * - node: 내부 경로는 포함하되, lineNumber는 path에 : 포함 시 붙이지 않음
- */ function extractCallStack() {
-    const stack = new Error().stack;
-    if (!stack) return [];
-    const lines = stack.split("\n");
-    // 콜스택 구조:
-    // [0]: "Error"
-    // [1]: "at extractCallStack"
-    // [2]: "at Naite.t"
-    // [3]: 실제 호출 위치부터 시작
-    const frames = lines.slice(3).map(parseStackFrame).filter((frame)=>frame !== null);
-    // runWithContext 계열 함수 발견 시 거기서 자르기
-    const contextIndex = frames.findIndex((f)=>f.functionName?.includes("runWithContext") || f.functionName?.includes("runWithMockContext"));
-    return contextIndex >= 0 ? frames.slice(0, contextIndex + 1) : frames;
-}
+
+//#region src/naite/naite.ts
 /**
- * 콜스택 한 줄을 파싱
- * 형식1: "at FunctionName (filePath:lineNumber:columnNumber)"
- * 형식2: "at filePath:lineNumber:columnNumber" (익명 함수/모듈 레벨)
- */ function parseStackFrame(line) {
-    // 패턴1: "at FunctionName (filePath:lineNumber:columnNumber)"
-    const matchWithFunc = line.match(/at\s+(.+?)\s+\((.+?):(\d+):\d+\)/);
-    if (matchWithFunc) {
-        const functionName = matchWithFunc[1];
-        const filePath = matchWithFunc[2];
-        const lineNumberStr = matchWithFunc[3];
-        // filePath에 이미 :가 포함되어 있으면 (예: "node:internal/...")
-        if (filePath.includes(":")) {
-            return {
-                functionName,
-                filePath,
-                lineNumber: 0
-            };
-        }
-        return {
-            functionName,
-            filePath,
-            lineNumber: Number.parseInt(lineNumberStr, 10)
-        };
-    }
-    // 패턴2: "at filePath:lineNumber:columnNumber" (함수명 없음)
-    const matchNoFunc = line.match(/at\s+(.+?):(\d+):\d+$/);
-    if (matchNoFunc) {
-        const filePath = matchNoFunc[1];
-        const lineNumberStr = matchNoFunc[2];
-        return {
-            functionName: null,
-            filePath,
-            lineNumber: Number.parseInt(lineNumberStr, 10)
-        };
-    }
-    return null;
+* 콜스택을 파싱하여 StackFrame 배열로 반환
+* - extractCallStack 자신과 Naite.t는 제외
+* - runWithContext/runWithMockContext 발견 시 거기서 종료
+* - node: 내부 경로는 포함하되, lineNumber는 path에 : 포함 시 붙이지 않음
+*/
+function extractCallStack() {
+	const stack = new Error().stack;
+	if (!stack) return [];
+	const lines = stack.split("\n");
+	const frames = lines.slice(3).map(parseStackFrame).filter((frame) => frame !== null);
+	const contextIndex = frames.findIndex((f) => f.functionName?.includes("runWithContext") || f.functionName?.includes("runWithMockContext"));
+	return contextIndex >= 0 ? frames.slice(0, contextIndex + 1) : frames;
 }
 /**
- * wildcard 패턴 매칭
- * 예시:
- * - "syncer:*" → "syncer:a", "syncer:a:b" 모두 매칭
- * - "syncer:*:user" → "syncer:renderTemplate:user" 매칭
- * - "syncer:renderTemplate:*" → "syncer:renderTemplate:service" 매칭
- */ function matchesPattern(key, pattern) {
-    const keyParts = key.split(":");
-    const patternParts = pattern.split(":");
-    // 마지막이 * → prefix 매칭 (길이 무관)
-    // 예: "syncer:*"는 "syncer:a", "syncer:a:b" 모두 매칭
-    if (patternParts[patternParts.length - 1] === "*") {
-        const prefixParts = patternParts.slice(0, -1);
-        // prefix가 모두 일치하는지 확인
-        return prefixParts.every((part, i)=>part === keyParts[i]);
-    }
-    // 길이가 같아야 함
-    if (patternParts.length !== keyParts.length) {
-        return false;
-    }
-    // 각 파트가 * 또는 정확히 일치
-    return patternParts.every((part, i)=>part === "*" || part === keyParts[i]);
+* 콜스택 한 줄을 파싱
+* 형식1: "at FunctionName (filePath:lineNumber:columnNumber)"
+* 형식2: "at filePath:lineNumber:columnNumber" (익명 함수/모듈 레벨)
+*/
+function parseStackFrame(line) {
+	const matchWithFunc = line.match(/at\s+(.+?)\s+\((.+?):(\d+):\d+\)/);
+	if (matchWithFunc) {
+		const functionName = matchWithFunc[1];
+		const filePath = matchWithFunc[2];
+		const lineNumberStr = matchWithFunc[3];
+		if (filePath.includes(":")) {
+			return {
+				functionName,
+				filePath,
+				lineNumber: 0
+			};
+		}
+		return {
+			functionName,
+			filePath,
+			lineNumber: Number.parseInt(lineNumberStr, 10)
+		};
+	}
+	const matchNoFunc = line.match(/at\s+(.+?):(\d+):\d+$/);
+	if (matchNoFunc) {
+		const filePath = matchNoFunc[1];
+		const lineNumberStr = matchNoFunc[2];
+		return {
+			functionName: null,
+			filePath,
+			lineNumber: Number.parseInt(lineNumberStr, 10)
+		};
+	}
+	return null;
 }
 /**
- * NaiteQuery 클래스
- * 체이닝을 통한 trace 필터링 및 조회
- */ export class NaiteQuery {
-    traces;
-    constructor(traces){
-        this.traces = traces;
-    }
-    /**
-   * 파일명으로 필터링
-   * @param fileName 파일명 (예: "syncer.test.ts")
-   */ fromFile(fileName) {
-        const filtered = this.traces.filter((t)=>t.stack.some((frame)=>frame.filePath.endsWith(`/${fileName}`)));
-        return new NaiteQuery(filtered);
-    }
-    /**
-   * 함수명으로 필터링
-   * @param funcName 함수명 (includes 체크)
-   * @param options.from 'direct' = 직접 호출만, 'indirect' = 간접 호출만, 'both' = 모두
-   */ fromFunction(funcName, options = {
-        from: "both"
-    }) {
-        const filtered = this.traces.filter((t)=>{
-            if (options.from === "direct") {
-                // stack[0]만 확인 (직접 호출)
-                return t.stack[0]?.functionName?.includes(funcName);
-            }
-            if (options.from === "indirect") {
-                // stack[1+]에서 확인 (간접 호출)
-                return t.stack.slice(1).some((f)=>f.functionName?.includes(funcName));
-            }
-            // 전체 스택에서 확인
-            return t.stack.some((f)=>f.functionName?.includes(funcName));
-        });
-        return new NaiteQuery(filtered);
-    }
-    /**
-   * 데이터 경로 기반 필터링
-   * @param path radash get 경로 (예: "data.userId")
-   * @param operator 비교 연산자
-   * @param value 비교값
-   */ where(path, operator, value) {
-        const filtered = this.traces.filter((trace)=>{
-            const actual = get(trace, path);
-            switch(operator){
-                case ">":
-                    return actual > value;
-                case "<":
-                    return actual < value;
-                case ">=":
-                    return actual >= value;
-                case "<=":
-                    return actual <= value;
-                case "=":
-                    return actual === value;
-                case "!=":
-                    return actual !== value;
-                case "includes":
-                    return typeof actual === "string" && actual.includes(value);
-                default:
-                    return false;
-            }
-        });
-        return new NaiteQuery(filtered);
-    }
-    /**
-   * 전체 데이터 배열 반환
-   */ result() {
-        return this.traces.map((t)=>t.data);
-    }
-    /**
-   * 첫 번째 데이터 반환
-   */ first() {
-        return this.traces[0]?.data;
-    }
-    /**
-   * 마지막 데이터 반환
-   */ last() {
-        return this.traces[this.traces.length - 1]?.data;
-    }
-    /**
-   * n번째 데이터 반환
-   */ at(index) {
-        return this.traces[index]?.data;
-    }
-    /**
-   * 원본 trace 배열 반환 (디버깅/NaiteViewer용)
-   */ getTraces() {
-        return this.traces;
-    }
-}
-// Naite 싱글턴 객체 (추후 logger 연결 등의 상태 관리 필요성 고려)
-export class NaiteClass {
-    // 테스트 로그 기록
-    t(name, value/*이렇게 받은 값이 NaiteTrace로 저장되어 있다가 추후에 vitest에게 meta를 통해 넘겨져 프로세스간 통신을 통해 직렬화되어야 하는 점을 고려하였을 때 여기에 Serializable을 써서 제한을 둘 수도 있지만, 사용상의 편의를 생각하여 any로 받습니다.*/ ) {
-        // 이 t 함수는 테스트 환경에서만 작동해야 합니다.
-        // 그리고 테스트 환경 판단에 왜 isTest() 함수를 사용하지 않았냐면요,,
-        // 이렇게 하는게 유틸 함수 불러와서 사용하는 것보다 조금이나마 빠를 것 같았기 때문입니다.
-        if (process.env.NODE_ENV !== "test") {
-            return;
-        }
-        try {
-            const context = Sonamu.getContext();
-            const store = context?.naiteStore;
-            if (!store) {
-                return;
-            }
-            // 콜스택 수집
-            const stack = extractCallStack();
-            const trace = {
-                key: name,
-                data: value,
-                stack,
-                at: new Date()
-            };
-            // 항상 배열로 관리
-            const existing = store.get(name) ?? [];
-            getLogger([
-                "naite",
-                ...convertNaiteKeyToCategory(name)
-            ]).debug(`naite: {name} ${existing.length === 0 ? "is empty state" : `already existing with ${existing.length} entries`}, appending new entry`, {
-                name,
-                value
-            });
-            store.set(name, [
-                ...existing,
-                trace
-            ]);
-        } catch  {
-        // Context 없는 상황에서 Naite.t 호출
-        }
-    }
-    /**
-   * key 또는 wildcard 패턴으로 trace 조회
-   * 항상 NaiteQuery 반환하여 체이닝 가능
-   */ get(keyPattern) {
-        const context = Sonamu.getContext();
-        const store = context?.naiteStore;
-        if (!store) {
-            return new NaiteQuery([]);
-        }
-        // wildcard 없으면 exact match
-        if (!keyPattern.includes("*")) {
-            const traces = store.get(keyPattern) ?? [];
-            return new NaiteQuery(traces);
-        }
-        // wildcard 패턴 매칭
-        const allTraces = [];
-        for (const [key, traces] of store.entries()){
-            if (matchesPattern(key, keyPattern)) {
-                allTraces.push(...traces);
-            }
-        }
-        return new NaiteQuery(allTraces);
-    }
-    // 전체 리스트 가져오기
-    getAll() {
-        const context = Sonamu.getContext();
-        if (!context?.naiteStore) {
-            return {};
-        }
-        // NaiteTrace 배열을 data만 추출하여 반환
-        const result = {};
-        for (const [key, traces] of context.naiteStore.entries()){
-            if (key.startsWith("mock:")) {
-                // Mock 설정은 그대로 반환
-                result[key] = traces;
-            } else {
-                // NaiteTrace 배열은 data만 추출
-                result[key] = traces.map((t)=>t.data);
-            }
-        }
-        return result;
-    }
-    /**
-   * 스토어에 들어있던 트레이스를 고대로 꺼내옵니다.
-   * 이때 값들은 모두 직렬화 가능한 상태로 나가게 됩니다.
-   * 테스트 정보와 함께 extensions에 보낼 용도로 만들었습니다.
-   * @returns
-   */ getAllTraces() {
-        const context = Sonamu.getContext();
-        if (!context?.naiteStore) {
-            return [];
-        }
-        const traces = Array.from(context.naiteStore.values()).flat();
-        // 직렬화 불가능한 값이 존재한다면 이를 대문짝만하게 알려줍니다! 그치만 알리기만 하고 그냥 지나갑니다 ㅎㅎ
-        // 왜 직렬화가 중요한가? 이(getAllTraces) 호출의 결과는 외부로 나가게 되는데,
-        // 이때 주 용도가 vitest의 task.meta 필드를 통해 afterEach에서 Sonamu extension으로 전달하는 것입니다.
-        // 여기서 meta 필드에 담긴 내용은 프로세스간 통신(process.send) 또는 스레드간 통신(message port)을 통해 전달되어야 하는데,
-        // 이로 인해 "직렬화 가능한 값들만 허용"하는 제약이 생깁니다.
-        //
-        // 이 제약을 의식하여 Naite.t에 직렬화 가능한 값만 넘기게 할 수도 있었지만, 그렇게 하면 불편해질 것 같아서 하지 않았습니다.
-        // 따라서 현재 Naite.t는 모든 값을 받을 수 있게 되어 있습니다.
-        // 대신 이렇게(getAllTraces) 그 값들을 빼낼 때 JSON.stringify를 사용하여 강제로 직렬화 가능하게 만들었습니다,,
-        for (const trace of traces){
-            const check = isSerializable(trace.data);
-            if (!check.valid) {
-                console.warn("\n" + "╔════════════════════════════════════════════════════════════════╗\n" + "║  [Naite] Non-serializable value detected!                      ║\n" + "╠════════════════════════════════════════════════════════════════╣\n" + `║  Key: ${trace.key.padEnd(57)}║\n` + `║  Reason: ${(check.reason ?? "unknown").slice(0, 54).padEnd(54)}║\n` + `║  Location: ${(trace.stack[0]?.filePath ?? "unknown").slice(-51).padEnd(52)}║\n` + `║  Line: ${String(trace.stack[0]?.lineNumber ?? 0).padEnd(56)}║\n` + "╠════════════════════════════════════════════════════════════════╣\n" + "║  Naite.t() accepts any type of value. However, values will     ║\n" + "║  be serialized to JSON when exported via Naite.getAllTraces(). ║\n" + "╚════════════════════════════════════════════════════════════════╝\n");
-            }
-        }
-        return traces.map((trace)=>({
-                key: trace.key,
-                value: JSON.parse(JSON.stringify(trace.data ?? "")),
-                filePath: trace.stack[0]?.filePath ?? "",
-                lineNumber: trace.stack[0]?.lineNumber ?? 0,
-                at: trace.at.toISOString()
-            }));
-    }
-    // 특정 키 삭제하기
-    del(key) {
-        const context = Sonamu.getContext();
-        if (!context?.naiteStore) {
-            return;
-        }
-        context.naiteStore.delete(key);
-    }
-    createStore() {
-        return new Map();
-    }
+* wildcard 패턴 매칭
+* 예시:
+* - "syncer:*" → "syncer:a", "syncer:a:b" 모두 매칭
+* - "syncer:*:user" → "syncer:renderTemplate:user" 매칭
+* - "syncer:renderTemplate:*" → "syncer:renderTemplate:service" 매칭
+*/
+function matchesPattern(key, pattern) {
+	const keyParts = key.split(":");
+	const patternParts = pattern.split(":");
+	if (patternParts[patternParts.length - 1] === "*") {
+		const prefixParts = patternParts.slice(0, -1);
+		return prefixParts.every((part, i) => part === keyParts[i]);
+	}
+	if (patternParts.length !== keyParts.length) {
+		return false;
+	}
+	return patternParts.every((part, i) => part === "*" || part === keyParts[i]);
 }
-export const Naite = new NaiteClass();
+var NaiteQuery, NaiteClass, Naite;
+var init_naite = __esmMin((() => {
+	init_sonamu();
+	init_category();
+	init_object_utils();
+	NaiteQuery = class NaiteQuery {
+		constructor(traces) {
+			this.traces = traces;
+		}
+		isComparableValue(value) {
+			return typeof value === "number" || typeof value === "string";
+		}
+		/**
+		* 파일명으로 필터링
+		* @param fileName 파일명 (예: "syncer.test.ts")
+		*/
+		fromFile(fileName) {
+			const filtered = this.traces.filter((t) => t.stack.some((frame) => frame.filePath.endsWith(`/${fileName}`)));
+			return new NaiteQuery(filtered);
+		}
+		/**
+		* 함수명으로 필터링
+		* @param funcName 함수명 (includes 체크)
+		* @param options.from 'direct' = 직접 호출만, 'indirect' = 간접 호출만, 'both' = 모두
+		*/
+		fromFunction(funcName, options = { from: "both" }) {
+			const filtered = this.traces.filter((t) => {
+				if (options.from === "direct") {
+					return t.stack[0]?.functionName?.includes(funcName);
+				}
+				if (options.from === "indirect") {
+					return t.stack.slice(1).some((f) => f.functionName?.includes(funcName));
+				}
+				return t.stack.some((f) => f.functionName?.includes(funcName));
+			});
+			return new NaiteQuery(filtered);
+		}
+		/**
+		* 데이터 경로 기반 필터링
+		* @param path radash get 경로 (예: "data.userId")
+		* @param operator 비교 연산자
+		* @param value 비교값
+		*/
+		where(path, operator, value) {
+			const filtered = this.traces.filter((trace) => {
+				const actual = get(trace, path);
+				switch (operator) {
+					case ">": return this.isComparableValue(actual) && this.isComparableValue(value) && actual > value;
+					case "<": return this.isComparableValue(actual) && this.isComparableValue(value) && actual < value;
+					case ">=": return this.isComparableValue(actual) && this.isComparableValue(value) && actual >= value;
+					case "<=": return this.isComparableValue(actual) && this.isComparableValue(value) && actual <= value;
+					case "=": return actual === value;
+					case "!=": return actual !== value;
+					case "includes": return typeof actual === "string" && actual.includes(value);
+					default: return false;
+				}
+			});
+			return new NaiteQuery(filtered);
+		}
+		/**
+		* 전체 데이터 배열 반환
+		*/
+		result() {
+			return this.traces.map((t) => t.data);
+		}
+		/**
+		* 첫 번째 데이터 반환
+		*/
+		first() {
+			return this.traces[0]?.data;
+		}
+		/**
+		* 마지막 데이터 반환
+		*/
+		last() {
+			return this.traces[this.traces.length - 1]?.data;
+		}
+		/**
+		* n번째 데이터 반환
+		*/
+		at(index) {
+			return this.traces[index]?.data;
+		}
+		/**
+		* 원본 trace 배열 반환 (디버깅/NaiteViewer용)
+		*/
+		getTraces() {
+			return this.traces;
+		}
+	};
+	NaiteClass = class {
+		t(name, value) {
+			if (process.env.NODE_ENV !== "test") {
+				return;
+			}
+			try {
+				const context = Sonamu.getContext();
+				const store = context?.naiteStore;
+				if (!store) {
+					return;
+				}
+				const stack = extractCallStack();
+				const trace = {
+					key: name,
+					data: value,
+					stack,
+					at: new Date()
+				};
+				const existing = store.get(name) ?? [];
+				getLogger(["naite", ...convertNaiteKeyToCategory(name)]).debug(`naite: {name} ${existing.length === 0 ? "is empty state" : `already existing with ${existing.length} entries`}, appending new entry`, {
+					name,
+					value
+				});
+				store.set(name, [...existing, trace]);
+			} catch {}
+		}
+		/**
+		* key 또는 wildcard 패턴으로 trace 조회
+		* 항상 NaiteQuery 반환하여 체이닝 가능
+		*/
+		get(keyPattern) {
+			const context = Sonamu.getContext();
+			const store = context?.naiteStore;
+			if (!store) {
+				return new NaiteQuery([]);
+			}
+			if (!keyPattern.includes("*")) {
+				const traces = store.get(keyPattern) ?? [];
+				return new NaiteQuery(traces);
+			}
+			const allTraces = [];
+			for (const [key, traces] of store.entries()) {
+				if (matchesPattern(key, keyPattern)) {
+					allTraces.push(...traces);
+				}
+			}
+			return new NaiteQuery(allTraces);
+		}
+		getAll() {
+			const context = Sonamu.getContext();
+			if (!context?.naiteStore) {
+				return {};
+			}
+			const result = {};
+			for (const [key, traces] of context.naiteStore.entries()) {
+				if (key.startsWith("mock:")) {
+					result[key] = traces;
+				} else {
+					result[key] = traces.map((t) => t.data);
+				}
+			}
+			return result;
+		}
+		/**
+		* 스토어에 들어있던 트레이스를 고대로 꺼내옵니다.
+		* 이때 값들은 모두 직렬화 가능한 상태로 나가게 됩니다.
+		* 테스트 정보와 함께 extensions에 보낼 용도로 만들었습니다.
+		* @returns
+		*/
+		getAllTraces() {
+			const context = Sonamu.getContext();
+			if (!context?.naiteStore) {
+				return [];
+			}
+			const traces = Array.from(context.naiteStore.values()).flat();
+			for (const trace of traces) {
+				const check = isSerializable(trace.data);
+				if (!check.valid) {
+					console.warn("\n" + "╔════════════════════════════════════════════════════════════════╗\n" + "║  [Naite] Non-serializable value detected!                      ║\n" + "╠════════════════════════════════════════════════════════════════╣\n" + `║  Key: ${trace.key.padEnd(57)}║\n` + `║  Reason: ${(check.reason ?? "unknown").slice(0, 54).padEnd(54)}║\n` + `║  Location: ${(trace.stack[0]?.filePath ?? "unknown").slice(-51).padEnd(52)}║\n` + `║  Line: ${String(trace.stack[0]?.lineNumber ?? 0).padEnd(56)}║\n` + "╠════════════════════════════════════════════════════════════════╣\n" + "║  Naite.t() accepts any type of value. However, values will     ║\n" + "║  be serialized to JSON when exported via Naite.getAllTraces(). ║\n" + "╚════════════════════════════════════════════════════════════════╝\n");
+				}
+			}
+			return traces.map((trace) => ({
+				key: trace.key,
+				value: JSON.parse(JSON.stringify(trace.data ?? "")),
+				filePath: trace.stack[0]?.filePath ?? "",
+				lineNumber: trace.stack[0]?.lineNumber ?? 0,
+				at: trace.at.toISOString()
+			}));
+		}
+		del(key) {
+			const context = Sonamu.getContext();
+			if (!context?.naiteStore) {
+				return;
+			}
+			context.naiteStore.delete(key);
+		}
+		createStore() {
+			return new Map();
+		}
+	};
+	Naite = new NaiteClass();
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/naite/naite.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함 */\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { get } from \"radashi\";\nimport { Sonamu } from \"../api/sonamu\";\nimport type { ComparisonOperator } from \"../database/puri.types\";\nimport { convertNaiteKeyToCategory } from \"../logger/category\";\nimport { isSerializable } from \"../utils/object-utils\";\n\n// StackFrame 타입\ninterface StackFrame {\n  functionName: string | null;\n  filePath: string; // \"/Users/.../syncer.ts\" 또는 \"node:internal/...\"\n  lineNumber: number; // TS 파일 기준 라인 번호\n}\n\n// NaiteTrace 타입\ninterface NaiteTrace {\n  key: string;\n  data: any;\n  stack: StackFrame[]; // 콜스택 정보\n  at: Date;\n}\n\n// Naite.t가 저장되는 타입 (항상 배열로 통일)\nexport type NaiteStore = Map<string, NaiteTrace[]>;\n\n// getAllTraces()가 반환하는 직렬화된 trace 타입\n// bootstrap.ts의 TaskMeta augmentation, dev-vitest-manager.ts에서도 이 타입을 공유합니다.\nexport type SerializedTrace = {\n  key: string;\n  value: any;\n  filePath: string;\n  lineNumber: number;\n  at: string;\n};\n\n/**\n * 콜스택을 파싱하여 StackFrame 배열로 반환\n * - extractCallStack 자신과 Naite.t는 제외\n * - runWithContext/runWithMockContext 발견 시 거기서 종료\n * - node: 내부 경로는 포함하되, lineNumber는 path에 : 포함 시 붙이지 않음\n */\nfunction extractCallStack(): StackFrame[] {\n  const stack = new Error().stack;\n  if (!stack) return [];\n\n  const lines = stack.split(\"\\n\");\n\n  // 콜스택 구조:\n  // [0]: \"Error\"\n  // [1]: \"at extractCallStack\"\n  // [2]: \"at Naite.t\"\n  // [3]: 실제 호출 위치부터 시작\n  const frames = lines\n    .slice(3)\n    .map(parseStackFrame)\n    .filter((frame): frame is StackFrame => frame !== null);\n\n  // runWithContext 계열 함수 발견 시 거기서 자르기\n  const contextIndex = frames.findIndex(\n    (f) =>\n      f.functionName?.includes(\"runWithContext\") || f.functionName?.includes(\"runWithMockContext\"),\n  );\n\n  return contextIndex >= 0 ? frames.slice(0, contextIndex + 1) : frames;\n}\n\n/**\n * 콜스택 한 줄을 파싱\n * 형식1: \"at FunctionName (filePath:lineNumber:columnNumber)\"\n * 형식2: \"at filePath:lineNumber:columnNumber\" (익명 함수/모듈 레벨)\n */\nfunction parseStackFrame(line: string): StackFrame | null {\n  // 패턴1: \"at FunctionName (filePath:lineNumber:columnNumber)\"\n  const matchWithFunc = line.match(/at\\s+(.+?)\\s+\\((.+?):(\\d+):\\d+\\)/);\n  if (matchWithFunc) {\n    const functionName = matchWithFunc[1];\n    const filePath = matchWithFunc[2];\n    const lineNumberStr = matchWithFunc[3];\n\n    // filePath에 이미 :가 포함되어 있으면 (예: \"node:internal/...\")\n    if (filePath.includes(\":\")) {\n      return { functionName, filePath, lineNumber: 0 };\n    }\n\n    return {\n      functionName,\n      filePath,\n      lineNumber: Number.parseInt(lineNumberStr, 10),\n    };\n  }\n\n  // 패턴2: \"at filePath:lineNumber:columnNumber\" (함수명 없음)\n  const matchNoFunc = line.match(/at\\s+(.+?):(\\d+):\\d+$/);\n  if (matchNoFunc) {\n    const filePath = matchNoFunc[1];\n    const lineNumberStr = matchNoFunc[2];\n\n    return {\n      functionName: null,\n      filePath,\n      lineNumber: Number.parseInt(lineNumberStr, 10),\n    };\n  }\n\n  return null;\n}\n\n/**\n * wildcard 패턴 매칭\n * 예시:\n * - \"syncer:*\" → \"syncer:a\", \"syncer:a:b\" 모두 매칭\n * - \"syncer:*:user\" → \"syncer:renderTemplate:user\" 매칭\n * - \"syncer:renderTemplate:*\" → \"syncer:renderTemplate:service\" 매칭\n */\nfunction matchesPattern(key: string, pattern: string): boolean {\n  const keyParts = key.split(\":\");\n  const patternParts = pattern.split(\":\");\n\n  // 마지막이 * → prefix 매칭 (길이 무관)\n  // 예: \"syncer:*\"는 \"syncer:a\", \"syncer:a:b\" 모두 매칭\n  if (patternParts[patternParts.length - 1] === \"*\") {\n    const prefixParts = patternParts.slice(0, -1);\n    // prefix가 모두 일치하는지 확인\n    return prefixParts.every((part, i) => part === keyParts[i]);\n  }\n\n  // 길이가 같아야 함\n  if (patternParts.length !== keyParts.length) {\n    return false;\n  }\n\n  // 각 파트가 * 또는 정확히 일치\n  return patternParts.every((part, i) => part === \"*\" || part === keyParts[i]);\n}\n\n/**\n * NaiteQuery 클래스\n * 체이닝을 통한 trace 필터링 및 조회\n */\nexport class NaiteQuery {\n  constructor(private traces: NaiteTrace[]) {}\n\n  /**\n   * 파일명으로 필터링\n   * @param fileName 파일명 (예: \"syncer.test.ts\")\n   */\n  fromFile(fileName: string): NaiteQuery {\n    const filtered = this.traces.filter((t) =>\n      t.stack.some((frame) => frame.filePath.endsWith(`/${fileName}`)),\n    );\n    return new NaiteQuery(filtered);\n  }\n\n  /**\n   * 함수명으로 필터링\n   * @param funcName 함수명 (includes 체크)\n   * @param options.from 'direct' = 직접 호출만, 'indirect' = 간접 호출만, 'both' = 모두\n   */\n  fromFunction(\n    funcName: string,\n    options: { from: \"direct\" | \"indirect\" | \"both\" } = { from: \"both\" },\n  ): NaiteQuery {\n    const filtered = this.traces.filter((t) => {\n      if (options.from === \"direct\") {\n        // stack[0]만 확인 (직접 호출)\n        return t.stack[0]?.functionName?.includes(funcName);\n      }\n      if (options.from === \"indirect\") {\n        // stack[1+]에서 확인 (간접 호출)\n        return t.stack.slice(1).some((f) => f.functionName?.includes(funcName));\n      }\n      // 전체 스택에서 확인\n      return t.stack.some((f) => f.functionName?.includes(funcName));\n    });\n    return new NaiteQuery(filtered);\n  }\n\n  /**\n   * 데이터 경로 기반 필터링\n   * @param path radash get 경로 (예: \"data.userId\")\n   * @param operator 비교 연산자\n   * @param value 비교값\n   */\n  where(path: string, operator: ComparisonOperator | \"includes\", value: any): NaiteQuery {\n    const filtered = this.traces.filter((trace) => {\n      const actual = get(trace, path) as any;\n\n      switch (operator) {\n        case \">\":\n          return actual > value;\n        case \"<\":\n          return actual < value;\n        case \">=\":\n          return actual >= value;\n        case \"<=\":\n          return actual <= value;\n        case \"=\":\n          return actual === value;\n        case \"!=\":\n          return actual !== value;\n        case \"includes\":\n          return typeof actual === \"string\" && actual.includes(value);\n        default:\n          return false;\n      }\n    });\n    return new NaiteQuery(filtered);\n  }\n\n  /**\n   * 전체 데이터 배열 반환\n   */\n  result(): any[] {\n    return this.traces.map((t) => t.data);\n  }\n\n  /**\n   * 첫 번째 데이터 반환\n   */\n  first(): any | undefined {\n    return this.traces[0]?.data;\n  }\n\n  /**\n   * 마지막 데이터 반환\n   */\n  last(): any | undefined {\n    return this.traces[this.traces.length - 1]?.data;\n  }\n\n  /**\n   * n번째 데이터 반환\n   */\n  at(index: number): any | undefined {\n    return this.traces[index]?.data;\n  }\n\n  /**\n   * 원본 trace 배열 반환 (디버깅/NaiteViewer용)\n   */\n  getTraces(): NaiteTrace[] {\n    return this.traces;\n  }\n}\n\n// Naite 싱글턴 객체 (추후 logger 연결 등의 상태 관리 필요성 고려)\nexport class NaiteClass {\n  // 테스트 로그 기록\n  t(\n    name: string,\n    value: any /*이렇게 받은 값이 NaiteTrace로 저장되어 있다가 추후에 vitest에게 meta를 통해 넘겨져 프로세스간 통신을 통해 직렬화되어야 하는 점을 고려하였을 때 여기에 Serializable을 써서 제한을 둘 수도 있지만, 사용상의 편의를 생각하여 any로 받습니다.*/,\n  ) {\n    // 이 t 함수는 테스트 환경에서만 작동해야 합니다.\n    // 그리고 테스트 환경 판단에 왜 isTest() 함수를 사용하지 않았냐면요,,\n    // 이렇게 하는게 유틸 함수 불러와서 사용하는 것보다 조금이나마 빠를 것 같았기 때문입니다.\n    if (process.env.NODE_ENV !== \"test\") {\n      return;\n    }\n\n    try {\n      const context = Sonamu.getContext();\n      const store = context?.naiteStore;\n\n      if (!store) {\n        return;\n      }\n\n      // 콜스택 수집\n      const stack = extractCallStack();\n\n      const trace: NaiteTrace = {\n        key: name,\n        data: value,\n        stack,\n        at: new Date(),\n      };\n\n      // 항상 배열로 관리\n      const existing = store.get(name) ?? [];\n      getLogger([\"naite\", ...convertNaiteKeyToCategory(name)]).debug(\n        `naite: {name} ${existing.length === 0 ? \"is empty state\" : `already existing with ${existing.length} entries`}, appending new entry`,\n        {\n          name,\n          value,\n        },\n      );\n\n      store.set(name, [...existing, trace]);\n    } catch {\n      // Context 없는 상황에서 Naite.t 호출\n    }\n  }\n\n  /**\n   * key 또는 wildcard 패턴으로 trace 조회\n   * 항상 NaiteQuery 반환하여 체이닝 가능\n   */\n  get(keyPattern: string): NaiteQuery {\n    const context = Sonamu.getContext();\n    const store = context?.naiteStore;\n\n    if (!store) {\n      return new NaiteQuery([]);\n    }\n\n    // wildcard 없으면 exact match\n    if (!keyPattern.includes(\"*\")) {\n      const traces = store.get(keyPattern) ?? [];\n      return new NaiteQuery(traces);\n    }\n\n    // wildcard 패턴 매칭\n    const allTraces: NaiteTrace[] = [];\n    for (const [key, traces] of store.entries()) {\n      if (matchesPattern(key, keyPattern)) {\n        allTraces.push(...traces);\n      }\n    }\n\n    return new NaiteQuery(allTraces);\n  }\n\n  // 전체 리스트 가져오기\n  getAll(): { [key: string]: any } {\n    const context = Sonamu.getContext();\n    if (!context?.naiteStore) {\n      return {};\n    }\n    // NaiteTrace 배열을 data만 추출하여 반환\n    const result: { [key: string]: any } = {};\n    for (const [key, traces] of context.naiteStore.entries()) {\n      if (key.startsWith(\"mock:\")) {\n        // Mock 설정은 그대로 반환\n        result[key] = traces;\n      } else {\n        // NaiteTrace 배열은 data만 추출\n        result[key] = traces.map((t: NaiteTrace) => t.data);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * 스토어에 들어있던 트레이스를 고대로 꺼내옵니다.\n   * 이때 값들은 모두 직렬화 가능한 상태로 나가게 됩니다.\n   * 테스트 정보와 함께 extensions에 보낼 용도로 만들었습니다.\n   * @returns\n   */\n  getAllTraces(): SerializedTrace[] {\n    const context = Sonamu.getContext();\n    if (!context?.naiteStore) {\n      return [];\n    }\n\n    const traces = Array.from(context.naiteStore.values()).flat();\n\n    // 직렬화 불가능한 값이 존재한다면 이를 대문짝만하게 알려줍니다! 그치만 알리기만 하고 그냥 지나갑니다 ㅎㅎ\n    // 왜 직렬화가 중요한가? 이(getAllTraces) 호출의 결과는 외부로 나가게 되는데,\n    // 이때 주 용도가 vitest의 task.meta 필드를 통해 afterEach에서 Sonamu extension으로 전달하는 것입니다.\n    // 여기서 meta 필드에 담긴 내용은 프로세스간 통신(process.send) 또는 스레드간 통신(message port)을 통해 전달되어야 하는데,\n    // 이로 인해 \"직렬화 가능한 값들만 허용\"하는 제약이 생깁니다.\n    //\n    // 이 제약을 의식하여 Naite.t에 직렬화 가능한 값만 넘기게 할 수도 있었지만, 그렇게 하면 불편해질 것 같아서 하지 않았습니다.\n    // 따라서 현재 Naite.t는 모든 값을 받을 수 있게 되어 있습니다.\n    // 대신 이렇게(getAllTraces) 그 값들을 빼낼 때 JSON.stringify를 사용하여 강제로 직렬화 가능하게 만들었습니다,,\n    for (const trace of traces) {\n      const check = isSerializable(trace.data);\n      if (!check.valid) {\n        console.warn(\n          \"\\n\" +\n            \"╔════════════════════════════════════════════════════════════════╗\\n\" +\n            \"║  [Naite] Non-serializable value detected!                      ║\\n\" +\n            \"╠════════════════════════════════════════════════════════════════╣\\n\" +\n            `║  Key: ${trace.key.padEnd(57)}║\\n` +\n            `║  Reason: ${(check.reason ?? \"unknown\").slice(0, 54).padEnd(54)}║\\n` +\n            `║  Location: ${(trace.stack[0]?.filePath ?? \"unknown\").slice(-51).padEnd(52)}║\\n` +\n            `║  Line: ${String(trace.stack[0]?.lineNumber ?? 0).padEnd(56)}║\\n` +\n            \"╠════════════════════════════════════════════════════════════════╣\\n\" +\n            \"║  Naite.t() accepts any type of value. However, values will     ║\\n\" +\n            \"║  be serialized to JSON when exported via Naite.getAllTraces(). ║\\n\" +\n            \"╚════════════════════════════════════════════════════════════════╝\\n\",\n        );\n      }\n    }\n\n    return traces.map((trace) => ({\n      key: trace.key,\n      value: JSON.parse(JSON.stringify(trace.data ?? \"\")), // 직렬화 가능한 것만 남기려는 눈물겨운 노력,, 안그러면 task.meta에 들어가서 프로세스간 통신 할 때 문제 생기거든요,,\n      filePath: trace.stack[0]?.filePath ?? \"\",\n      lineNumber: trace.stack[0]?.lineNumber ?? 0,\n      at: trace.at.toISOString(),\n    }));\n  }\n\n  // 특정 키 삭제하기\n  del(key: string) {\n    const context = Sonamu.getContext();\n    if (!context?.naiteStore) {\n      return;\n    }\n    context.naiteStore.delete(key);\n  }\n\n  createStore(): NaiteStore {\n    return new Map<string, NaiteTrace[]>();\n  }\n}\n\nexport const Naite = new NaiteClass();\n"],"names":["getLogger","get","Sonamu","convertNaiteKeyToCategory","isSerializable","extractCallStack","stack","Error","lines","split","frames","slice","map","parseStackFrame","filter","frame","contextIndex","findIndex","f","functionName","includes","line","matchWithFunc","match","filePath","lineNumberStr","lineNumber","Number","parseInt","matchNoFunc","matchesPattern","key","pattern","keyParts","patternParts","length","prefixParts","every","part","i","NaiteQuery","traces","fromFile","fileName","filtered","t","some","endsWith","fromFunction","funcName","options","from","where","path","operator","value","trace","actual","result","data","first","last","at","index","getTraces","NaiteClass","name","process","env","NODE_ENV","context","getContext","store","naiteStore","Date","existing","debug","set","keyPattern","allTraces","entries","push","getAll","startsWith","getAllTraces","Array","values","flat","check","valid","console","warn","padEnd","reason","String","JSON","parse","stringify","toISOString","del","delete","createStore","Map","Naite"],"mappings":"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"}
+//#endregion
+init_naite();
+export { Naite, NaiteClass, NaiteQuery, init_naite };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"naite.js","names":["traces: NaiteTrace[]","trace: NaiteTrace","allTraces: NaiteTrace[]","result: { [key: string]: any }"],"sources":["../../src/naite/naite.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */ // Naite는 expect와 호응하도록 any를 허용함\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { get } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { type ComparisonOperator } from \"../database/puri.types\";\nimport { convertNaiteKeyToCategory } from \"../logger/category\";\nimport { isSerializable } from \"../utils/object-utils\";\n\n// StackFrame 타입\ninterface StackFrame {\n  functionName: string | null;\n  filePath: string; // \"/Users/.../syncer.ts\" 또는 \"node:internal/...\"\n  lineNumber: number; // TS 파일 기준 라인 번호\n}\n\n// NaiteTrace 타입\ninterface NaiteTrace {\n  key: string;\n  data: any;\n  stack: StackFrame[]; // 콜스택 정보\n  at: Date;\n}\n\n// Naite.t가 저장되는 타입 (항상 배열로 통일)\nexport type NaiteStore = Map<string, NaiteTrace[]>;\n\n// getAllTraces()가 반환하는 직렬화된 trace 타입\n// bootstrap.ts의 TaskMeta augmentation, dev-vitest-manager.ts에서도 이 타입을 공유합니다.\nexport type SerializedTrace = {\n  key: string;\n  value: any;\n  filePath: string;\n  lineNumber: number;\n  at: string;\n};\n\n/**\n * 콜스택을 파싱하여 StackFrame 배열로 반환\n * - extractCallStack 자신과 Naite.t는 제외\n * - runWithContext/runWithMockContext 발견 시 거기서 종료\n * - node: 내부 경로는 포함하되, lineNumber는 path에 : 포함 시 붙이지 않음\n */\nfunction extractCallStack(): StackFrame[] {\n  const stack = new Error().stack;\n  if (!stack) return [];\n\n  const lines = stack.split(\"\\n\");\n\n  // 콜스택 구조:\n  // [0]: \"Error\"\n  // [1]: \"at extractCallStack\"\n  // [2]: \"at Naite.t\"\n  // [3]: 실제 호출 위치부터 시작\n  const frames = lines\n    .slice(3)\n    .map(parseStackFrame)\n    .filter((frame): frame is StackFrame => frame !== null);\n\n  // runWithContext 계열 함수 발견 시 거기서 자르기\n  const contextIndex = frames.findIndex(\n    (f) =>\n      f.functionName?.includes(\"runWithContext\") || f.functionName?.includes(\"runWithMockContext\"),\n  );\n\n  return contextIndex >= 0 ? frames.slice(0, contextIndex + 1) : frames;\n}\n\n/**\n * 콜스택 한 줄을 파싱\n * 형식1: \"at FunctionName (filePath:lineNumber:columnNumber)\"\n * 형식2: \"at filePath:lineNumber:columnNumber\" (익명 함수/모듈 레벨)\n */\nfunction parseStackFrame(line: string): StackFrame | null {\n  // 패턴1: \"at FunctionName (filePath:lineNumber:columnNumber)\"\n  const matchWithFunc = line.match(/at\\s+(.+?)\\s+\\((.+?):(\\d+):\\d+\\)/);\n  if (matchWithFunc) {\n    const functionName = matchWithFunc[1];\n    const filePath = matchWithFunc[2];\n    const lineNumberStr = matchWithFunc[3];\n\n    // filePath에 이미 :가 포함되어 있으면 (예: \"node:internal/...\")\n    if (filePath.includes(\":\")) {\n      return { functionName, filePath, lineNumber: 0 };\n    }\n\n    return {\n      functionName,\n      filePath,\n      lineNumber: Number.parseInt(lineNumberStr, 10),\n    };\n  }\n\n  // 패턴2: \"at filePath:lineNumber:columnNumber\" (함수명 없음)\n  const matchNoFunc = line.match(/at\\s+(.+?):(\\d+):\\d+$/);\n  if (matchNoFunc) {\n    const filePath = matchNoFunc[1];\n    const lineNumberStr = matchNoFunc[2];\n\n    return {\n      functionName: null,\n      filePath,\n      lineNumber: Number.parseInt(lineNumberStr, 10),\n    };\n  }\n\n  return null;\n}\n\n/**\n * wildcard 패턴 매칭\n * 예시:\n * - \"syncer:*\" → \"syncer:a\", \"syncer:a:b\" 모두 매칭\n * - \"syncer:*:user\" → \"syncer:renderTemplate:user\" 매칭\n * - \"syncer:renderTemplate:*\" → \"syncer:renderTemplate:service\" 매칭\n */\nfunction matchesPattern(key: string, pattern: string): boolean {\n  const keyParts = key.split(\":\");\n  const patternParts = pattern.split(\":\");\n\n  // 마지막이 * → prefix 매칭 (길이 무관)\n  // 예: \"syncer:*\"는 \"syncer:a\", \"syncer:a:b\" 모두 매칭\n  if (patternParts[patternParts.length - 1] === \"*\") {\n    const prefixParts = patternParts.slice(0, -1);\n    // prefix가 모두 일치하는지 확인\n    return prefixParts.every((part, i) => part === keyParts[i]);\n  }\n\n  // 길이가 같아야 함\n  if (patternParts.length !== keyParts.length) {\n    return false;\n  }\n\n  // 각 파트가 * 또는 정확히 일치\n  return patternParts.every((part, i) => part === \"*\" || part === keyParts[i]);\n}\n\n/**\n * NaiteQuery 클래스\n * 체이닝을 통한 trace 필터링 및 조회\n */\nexport class NaiteQuery {\n  constructor(private traces: NaiteTrace[]) {}\n\n  private isComparableValue(value: unknown): value is number | string {\n    return typeof value === \"number\" || typeof value === \"string\";\n  }\n\n  /**\n   * 파일명으로 필터링\n   * @param fileName 파일명 (예: \"syncer.test.ts\")\n   */\n  fromFile(fileName: string): NaiteQuery {\n    const filtered = this.traces.filter((t) =>\n      t.stack.some((frame) => frame.filePath.endsWith(`/${fileName}`)),\n    );\n    return new NaiteQuery(filtered);\n  }\n\n  /**\n   * 함수명으로 필터링\n   * @param funcName 함수명 (includes 체크)\n   * @param options.from 'direct' = 직접 호출만, 'indirect' = 간접 호출만, 'both' = 모두\n   */\n  fromFunction(\n    funcName: string,\n    options: { from: \"direct\" | \"indirect\" | \"both\" } = { from: \"both\" },\n  ): NaiteQuery {\n    const filtered = this.traces.filter((t) => {\n      if (options.from === \"direct\") {\n        // stack[0]만 확인 (직접 호출)\n        return t.stack[0]?.functionName?.includes(funcName);\n      }\n      if (options.from === \"indirect\") {\n        // stack[1+]에서 확인 (간접 호출)\n        return t.stack.slice(1).some((f) => f.functionName?.includes(funcName));\n      }\n      // 전체 스택에서 확인\n      return t.stack.some((f) => f.functionName?.includes(funcName));\n    });\n    return new NaiteQuery(filtered);\n  }\n\n  /**\n   * 데이터 경로 기반 필터링\n   * @param path radash get 경로 (예: \"data.userId\")\n   * @param operator 비교 연산자\n   * @param value 비교값\n   */\n  where(path: string, operator: ComparisonOperator | \"includes\", value: any): NaiteQuery {\n    const filtered = this.traces.filter((trace) => {\n      const actual = get(trace, path);\n\n      switch (operator) {\n        case \">\":\n          return this.isComparableValue(actual) && this.isComparableValue(value) && actual > value;\n        case \"<\":\n          return this.isComparableValue(actual) && this.isComparableValue(value) && actual < value;\n        case \">=\":\n          return this.isComparableValue(actual) && this.isComparableValue(value) && actual >= value;\n        case \"<=\":\n          return this.isComparableValue(actual) && this.isComparableValue(value) && actual <= value;\n        case \"=\":\n          return actual === value;\n        case \"!=\":\n          return actual !== value;\n        case \"includes\":\n          return typeof actual === \"string\" && actual.includes(value);\n        default:\n          return false;\n      }\n    });\n    return new NaiteQuery(filtered);\n  }\n\n  /**\n   * 전체 데이터 배열 반환\n   */\n  result(): any[] {\n    return this.traces.map((t) => t.data);\n  }\n\n  /**\n   * 첫 번째 데이터 반환\n   */\n  first(): any | undefined {\n    return this.traces[0]?.data;\n  }\n\n  /**\n   * 마지막 데이터 반환\n   */\n  last(): any | undefined {\n    return this.traces[this.traces.length - 1]?.data;\n  }\n\n  /**\n   * n번째 데이터 반환\n   */\n  at(index: number): any | undefined {\n    return this.traces[index]?.data;\n  }\n\n  /**\n   * 원본 trace 배열 반환 (디버깅/NaiteViewer용)\n   */\n  getTraces(): NaiteTrace[] {\n    return this.traces;\n  }\n}\n\n// Naite 싱글턴 객체 (추후 logger 연결 등의 상태 관리 필요성 고려)\nexport class NaiteClass {\n  // 테스트 로그 기록\n  t(\n    name: string,\n    value: any /*이렇게 받은 값이 NaiteTrace로 저장되어 있다가 추후에 vitest에게 meta를 통해 넘겨져 프로세스간 통신을 통해 직렬화되어야 하는 점을 고려하였을 때 여기에 Serializable을 써서 제한을 둘 수도 있지만, 사용상의 편의를 생각하여 any로 받습니다.*/,\n  ) {\n    // 이 t 함수는 테스트 환경에서만 작동해야 합니다.\n    // 그리고 테스트 환경 판단에 왜 isTest() 함수를 사용하지 않았냐면요,,\n    // 이렇게 하는게 유틸 함수 불러와서 사용하는 것보다 조금이나마 빠를 것 같았기 때문입니다.\n    if (process.env.NODE_ENV !== \"test\") {\n      return;\n    }\n\n    try {\n      const context = Sonamu.getContext();\n      const store = context?.naiteStore;\n\n      if (!store) {\n        return;\n      }\n\n      // 콜스택 수집\n      const stack = extractCallStack();\n\n      const trace: NaiteTrace = {\n        key: name,\n        data: value,\n        stack,\n        at: new Date(),\n      };\n\n      // 항상 배열로 관리\n      const existing = store.get(name) ?? [];\n      getLogger([\"naite\", ...convertNaiteKeyToCategory(name)]).debug(\n        `naite: {name} ${existing.length === 0 ? \"is empty state\" : `already existing with ${existing.length} entries`}, appending new entry`,\n        {\n          name,\n          value,\n        },\n      );\n\n      store.set(name, [...existing, trace]);\n    } catch {\n      // Context 없는 상황에서 Naite.t 호출\n    }\n  }\n\n  /**\n   * key 또는 wildcard 패턴으로 trace 조회\n   * 항상 NaiteQuery 반환하여 체이닝 가능\n   */\n  get(keyPattern: string): NaiteQuery {\n    const context = Sonamu.getContext();\n    const store = context?.naiteStore;\n\n    if (!store) {\n      return new NaiteQuery([]);\n    }\n\n    // wildcard 없으면 exact match\n    if (!keyPattern.includes(\"*\")) {\n      const traces = store.get(keyPattern) ?? [];\n      return new NaiteQuery(traces);\n    }\n\n    // wildcard 패턴 매칭\n    const allTraces: NaiteTrace[] = [];\n    for (const [key, traces] of store.entries()) {\n      if (matchesPattern(key, keyPattern)) {\n        allTraces.push(...traces);\n      }\n    }\n\n    return new NaiteQuery(allTraces);\n  }\n\n  // 전체 리스트 가져오기\n  getAll(): { [key: string]: any } {\n    const context = Sonamu.getContext();\n    if (!context?.naiteStore) {\n      return {};\n    }\n    // NaiteTrace 배열을 data만 추출하여 반환\n    const result: { [key: string]: any } = {};\n    for (const [key, traces] of context.naiteStore.entries()) {\n      if (key.startsWith(\"mock:\")) {\n        // Mock 설정은 그대로 반환\n        result[key] = traces;\n      } else {\n        // NaiteTrace 배열은 data만 추출\n        result[key] = traces.map((t: NaiteTrace) => t.data);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * 스토어에 들어있던 트레이스를 고대로 꺼내옵니다.\n   * 이때 값들은 모두 직렬화 가능한 상태로 나가게 됩니다.\n   * 테스트 정보와 함께 extensions에 보낼 용도로 만들었습니다.\n   * @returns\n   */\n  getAllTraces(): SerializedTrace[] {\n    const context = Sonamu.getContext();\n    if (!context?.naiteStore) {\n      return [];\n    }\n\n    const traces = Array.from(context.naiteStore.values()).flat();\n\n    // 직렬화 불가능한 값이 존재한다면 이를 대문짝만하게 알려줍니다! 그치만 알리기만 하고 그냥 지나갑니다 ㅎㅎ\n    // 왜 직렬화가 중요한가? 이(getAllTraces) 호출의 결과는 외부로 나가게 되는데,\n    // 이때 주 용도가 vitest의 task.meta 필드를 통해 afterEach에서 Sonamu extension으로 전달하는 것입니다.\n    // 여기서 meta 필드에 담긴 내용은 프로세스간 통신(process.send) 또는 스레드간 통신(message port)을 통해 전달되어야 하는데,\n    // 이로 인해 \"직렬화 가능한 값들만 허용\"하는 제약이 생깁니다.\n    //\n    // 이 제약을 의식하여 Naite.t에 직렬화 가능한 값만 넘기게 할 수도 있었지만, 그렇게 하면 불편해질 것 같아서 하지 않았습니다.\n    // 따라서 현재 Naite.t는 모든 값을 받을 수 있게 되어 있습니다.\n    // 대신 이렇게(getAllTraces) 그 값들을 빼낼 때 JSON.stringify를 사용하여 강제로 직렬화 가능하게 만들었습니다,,\n    for (const trace of traces) {\n      const check = isSerializable(trace.data);\n      if (!check.valid) {\n        console.warn(\n          \"\\n\" +\n            \"╔════════════════════════════════════════════════════════════════╗\\n\" +\n            \"║  [Naite] Non-serializable value detected!                      ║\\n\" +\n            \"╠════════════════════════════════════════════════════════════════╣\\n\" +\n            `║  Key: ${trace.key.padEnd(57)}║\\n` +\n            `║  Reason: ${(check.reason ?? \"unknown\").slice(0, 54).padEnd(54)}║\\n` +\n            `║  Location: ${(trace.stack[0]?.filePath ?? \"unknown\").slice(-51).padEnd(52)}║\\n` +\n            `║  Line: ${String(trace.stack[0]?.lineNumber ?? 0).padEnd(56)}║\\n` +\n            \"╠════════════════════════════════════════════════════════════════╣\\n\" +\n            \"║  Naite.t() accepts any type of value. However, values will     ║\\n\" +\n            \"║  be serialized to JSON when exported via Naite.getAllTraces(). ║\\n\" +\n            \"╚════════════════════════════════════════════════════════════════╝\\n\",\n        );\n      }\n    }\n\n    return traces.map((trace) => ({\n      key: trace.key,\n      value: JSON.parse(JSON.stringify(trace.data ?? \"\")), // 직렬화 가능한 것만 남기려는 눈물겨운 노력,, 안그러면 task.meta에 들어가서 프로세스간 통신 할 때 문제 생기거든요,,\n      filePath: trace.stack[0]?.filePath ?? \"\",\n      lineNumber: trace.stack[0]?.lineNumber ?? 0,\n      at: trace.at.toISOString(),\n    }));\n  }\n\n  // 특정 키 삭제하기\n  del(key: string) {\n    const context = Sonamu.getContext();\n    if (!context?.naiteStore) {\n      return;\n    }\n    context.naiteStore.delete(key);\n  }\n\n  createStore(): NaiteStore {\n    return new Map<string, NaiteTrace[]>();\n  }\n}\n\nexport const Naite = new NaiteClass();\n"],"mappings":"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"}