sonamu 0.8.26 → 0.9.0

package/dist/testing/dev-test-routes.d.ts

@@ -1,4 +1,4 @@
-import type { FastifyInstance } from "fastify";
-import type { SonamuDevRunnerConfig } from "../api/config";
+import { type FastifyInstance } from "fastify";
+import { type SonamuDevRunnerConfig } from "../api/config";
 export declare function registerDevTestRoutes(server: FastifyInstance, config: SonamuDevRunnerConfig): Promise<void>;
 //# sourceMappingURL=dev-test-routes.d.ts.map

package/dist/testing/dev-test-routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-test-routes.d.ts","sourceRoot":"","sources":["../../src/testing/dev-test-routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAqJ3D,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAkIf"}
+{"version":3,"file":"dev-test-routes.d.ts","sourceRoot":"","sources":["../../src/testing/dev-test-routes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAG/C,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAsJ3D,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAkIf"}

package/dist/testing/dev-test-routes.js

@@ -1,262 +1,271 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { createSSEFactory, init_sse } from "../stream/sse.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { DevVitestManager, init_dev_vitest_manager } from "./dev-vitest-manager.js";
+import { z as z$1 } from "zod";
 import { randomUUID } from "crypto";
-import { z } from "zod";
-import { Sonamu } from "../api/sonamu.js";
-import { createSSEFactory } from "../stream/sse.js";
-import { DevVitestManager } from "./dev-vitest-manager.js";
-const SCHEMA_VERSION = 1;
-const HEARTBEAT_INTERVAL_MS = 30_000;
-const SerializedTraceSchema = z.object({
-    key: z.string(),
-    value: z.unknown(),
-    filePath: z.string(),
-    lineNumber: z.number(),
-    at: z.string()
-});
-const TestCaseResultSchema = z.lazy(()=>z.object({
-        id: z.string(),
-        kind: z.enum([
-            "file",
-            "suite",
-            "test"
-        ]),
-        name: z.string(),
-        fullName: z.string(),
-        file: z.string(),
-        state: z.enum([
-            "passed",
-            "failed",
-            "skipped",
-            "todo",
-            "running",
-            "unknown"
-        ]),
-        durationMs: z.number().nullable(),
-        counts: z.object({
-            total: z.number(),
-            passed: z.number(),
-            failed: z.number(),
-            skipped: z.number()
-        }),
-        error: z.object({
-            message: z.string(),
-            stack: z.string().optional()
-        }).nullable(),
-        traces: z.array(SerializedTraceSchema),
-        children: z.array(TestCaseResultSchema)
-    }));
-const TestEventSchema = z.object({
-    snapshot: z.object({
-        schemaVersion: z.number(),
-        serverTime: z.string(),
-        status: z.object({
-            ready: z.boolean(),
-            running: z.boolean(),
-            lastRunAt: z.string().nullable()
-        })
-    }),
-    runQueued: z.object({
-        schemaVersion: z.number(),
-        runId: z.string(),
-        queuedAt: z.string(),
-        request: z.object({
-            files: z.array(z.string()).optional(),
-            pattern: z.string().optional()
-        })
-    }),
-    runStarted: z.object({
-        schemaVersion: z.number(),
-        runId: z.string(),
-        startedAt: z.string()
-    }),
-    runCompleted: z.object({
-        schemaVersion: z.number(),
-        runId: z.string(),
-        startedAt: z.string(),
-        finishedAt: z.string(),
-        result: z.record(z.string(), z.unknown())
-    }),
-    runErrored: z.object({
-        schemaVersion: z.number(),
-        runId: z.string(),
-        finishedAt: z.string(),
-        error: z.object({
-            message: z.string(),
-            stack: z.string().optional()
-        })
-    }),
-    runNodeProgress: z.object({
-        schemaVersion: z.literal(1),
-        runId: z.string(),
-        startedAt: z.string(),
-        at: z.string(),
-        kind: z.enum([
-            "file",
-            "suite",
-            "test"
-        ]),
-        phase: z.enum([
-            "ready",
-            "result"
-        ]),
-        fileId: z.string(),
-        nodeId: z.string(),
-        parentId: z.string().nullable(),
-        node: TestCaseResultSchema
-    }),
-    heartbeat: z.object({
-        schemaVersion: z.number(),
-        at: z.string()
-    })
-});
+
+//#region src/testing/dev-test-routes.ts
 function toPathPrefix(basePath) {
-    return basePath.endsWith("/") ? basePath : `${basePath}/`;
+	return basePath.endsWith("/") ? basePath : `${basePath}/`;
 }
 function relativizeTrace(trace, prefix) {
-    return {
-        ...trace,
-        filePath: trace.filePath.replace(prefix, "")
-    };
+	return {
+		...trace,
+		filePath: trace.filePath.replace(prefix, "")
+	};
 }
 function relativizeNode(node, basePath) {
-    const prefix = toPathPrefix(basePath);
-    return {
-        ...node,
-        name: node.name.replace(prefix, ""),
-        file: node.file.replace(prefix, ""),
-        traces: node.traces.map((t)=>relativizeTrace(t, prefix)),
-        children: node.children.map((c)=>relativizeNode(c, prefix))
-    };
+	const prefix = toPathPrefix(basePath);
+	return {
+		...node,
+		name: node.name.replace(prefix, ""),
+		file: node.file.replace(prefix, ""),
+		traces: node.traces.map((t) => relativizeTrace(t, prefix)),
+		children: node.children.map((c) => relativizeNode(c, prefix))
+	};
 }
 function isRunNodeProgressData(data) {
-    if (typeof data !== "object" || data === null) return false;
-    const d = data;
-    return d.schemaVersion === 1 && typeof d.runId === "string" && typeof d.startedAt === "string" && typeof d.at === "string" && (d.kind === "file" || d.kind === "suite" || d.kind === "test") && (d.phase === "ready" || d.phase === "result") && typeof d.fileId === "string" && typeof d.nodeId === "string" && (d.parentId === null || typeof d.parentId === "string") && typeof d.node === "object" && d.node !== null;
+	if (typeof data !== "object" || data === null) return false;
+	const d = data;
+	return d.schemaVersion === 1 && typeof d.runId === "string" && typeof d.startedAt === "string" && typeof d.at === "string" && (d.kind === "file" || d.kind === "suite" || d.kind === "test") && (d.phase === "ready" || d.phase === "result") && typeof d.fileId === "string" && typeof d.nodeId === "string" && (d.parentId === null || typeof d.parentId === "string") && typeof d.node === "object" && d.node !== null;
 }
 function relativizeResult(result, basePath) {
-    const prefix = toPathPrefix(basePath);
-    return {
-        ...result,
-        results: result.results.map((n)=>relativizeNode(n, prefix))
-    };
+	const prefix = toPathPrefix(basePath);
+	return {
+		...result,
+		results: result.results.map((n) => relativizeNode(n, prefix))
+	};
 }
-export async function registerDevTestRoutes(server, config) {
-    const prefix = config.routePrefix ?? "/__test__";
-    const manager = new DevVitestManager();
-    await manager.start(config.vitestConfigPath);
-    Sonamu.devVitestManager = manager;
-    const sseAvailable = !!Sonamu.config.server.plugins?.sse;
-    if (sseAvailable) {
-        server.get(`${prefix}/events`, (request, reply)=>{
-            const sse = createSSEFactory(request.socket, reply, TestEventSchema);
-            const status = manager.getStatus();
-            sse.publish("snapshot", {
-                schemaVersion: SCHEMA_VERSION,
-                serverTime: new Date().toISOString(),
-                status
-            });
-            const heartbeatTimer = setInterval(()=>{
-                sse.publish("heartbeat", {
-                    schemaVersion: SCHEMA_VERSION,
-                    at: new Date().toISOString()
-                });
-            }, HEARTBEAT_INTERVAL_MS);
-            const basePath = Sonamu.apiRootPath;
-            const listener = (event, data)=>{
-                const key = event;
-                if (key === "runNodeProgress") {
-                    if (!isRunNodeProgressData(data)) return;
-                    const relativized = {
-                        ...data,
-                        node: relativizeNode(data.node, basePath)
-                    };
-                    sse.publish(key, relativized);
-                    return;
-                }
-                sse.publish(key, data);
-            };
-            manager.addEventListener(listener);
-            let cleaned = false;
-            const cleanup = ()=>{
-                if (cleaned) return;
-                cleaned = true;
-                clearInterval(heartbeatTimer);
-                manager.removeEventListener(listener);
-            };
-            request.socket.on("close", cleanup);
-            request.socket.on("error", cleanup);
-        });
-    }
-    server.post(`${prefix}/run`, async (request, reply)=>{
-        if (!Sonamu.devVitestManager) {
-            reply.status(503);
-            return {
-                ok: false,
-                error: "DevVitestManager is not initialized"
-            };
-        }
-        const runId = randomUUID();
-        const body = request.body;
-        const runRequest = {
-            files: body?.files,
-            pattern: body?.pattern
-        };
-        manager.emitEvent("runQueued", {
-            schemaVersion: SCHEMA_VERSION,
-            runId,
-            queuedAt: new Date().toISOString(),
-            request: runRequest
-        });
-        try {
-            const startedAt = new Date().toISOString();
-            manager.emitEvent("runStarted", {
-                schemaVersion: SCHEMA_VERSION,
-                runId,
-                startedAt
-            });
-            const rawResult = await Sonamu.devVitestManager.run(runRequest, runId);
-            const result = relativizeResult(rawResult, Sonamu.apiRootPath);
-            const finishedAt = new Date().toISOString();
-            manager.emitEvent("runCompleted", {
-                schemaVersion: SCHEMA_VERSION,
-                runId,
-                startedAt,
-                finishedAt,
-                result
-            });
-            return result;
-        } catch (err) {
-            const finishedAt = new Date().toISOString();
-            manager.emitEvent("runErrored", {
-                schemaVersion: SCHEMA_VERSION,
-                runId,
-                finishedAt,
-                error: {
-                    message: err instanceof Error ? err.message : String(err),
-                    stack: err instanceof Error ? err.stack : undefined
-                }
-            });
-            reply.status(500);
-            return {
-                ok: false,
-                error: err instanceof Error ? err.message : String(err)
-            };
-        }
-    });
-    server.get(`${prefix}/status`, async ()=>{
-        const status = Sonamu.devVitestManager?.getStatus() ?? {
-            ready: false,
-            running: false,
-            lastRunAt: null
-        };
-        return {
-            ...status,
-            sseAvailable
-        };
-    });
-    server.addHook("onClose", async ()=>{
-        await Sonamu.devVitestManager?.shutdown();
-        Sonamu.devVitestManager = null;
-    });
+async function registerDevTestRoutes(server, config) {
+	const prefix = config.routePrefix ?? "/__test__";
+	const manager = new DevVitestManager();
+	await manager.start(config.vitestConfigPath);
+	Sonamu.devVitestManager = manager;
+	const sseAvailable = !!Sonamu.config.server.plugins?.sse;
+	if (sseAvailable) {
+		server.get(`${prefix}/events`, (request, reply) => {
+			const sse = createSSEFactory(request.socket, reply, TestEventSchema);
+			const status = manager.getStatus();
+			sse.publish("snapshot", {
+				schemaVersion: SCHEMA_VERSION,
+				serverTime: new Date().toISOString(),
+				status
+			});
+			const heartbeatTimer = setInterval(() => {
+				sse.publish("heartbeat", {
+					schemaVersion: SCHEMA_VERSION,
+					at: new Date().toISOString()
+				});
+			}, HEARTBEAT_INTERVAL_MS);
+			const basePath = Sonamu.apiRootPath;
+			const listener = (event, data) => {
+				const key = event;
+				if (key === "runNodeProgress") {
+					if (!isRunNodeProgressData(data)) return;
+					const relativized = {
+						...data,
+						node: relativizeNode(data.node, basePath)
+					};
+					sse.publish(key, relativized);
+					return;
+				}
+				sse.publish(key, data);
+			};
+			manager.addEventListener(listener);
+			let cleaned = false;
+			const cleanup = () => {
+				if (cleaned) return;
+				cleaned = true;
+				clearInterval(heartbeatTimer);
+				manager.removeEventListener(listener);
+			};
+			request.socket.on("close", cleanup);
+			request.socket.on("error", cleanup);
+		});
+	}
+	server.post(`${prefix}/run`, async (request, reply) => {
+		if (!Sonamu.devVitestManager) {
+			reply.status(503);
+			return {
+				ok: false,
+				error: "DevVitestManager is not initialized"
+			};
+		}
+		const runId = randomUUID();
+		const body = request.body;
+		const runRequest = {
+			files: body?.files,
+			pattern: body?.pattern
+		};
+		manager.emitEvent("runQueued", {
+			schemaVersion: SCHEMA_VERSION,
+			runId,
+			queuedAt: new Date().toISOString(),
+			request: runRequest
+		});
+		try {
+			const startedAt = new Date().toISOString();
+			manager.emitEvent("runStarted", {
+				schemaVersion: SCHEMA_VERSION,
+				runId,
+				startedAt
+			});
+			const rawResult = await Sonamu.devVitestManager.run(runRequest, runId);
+			const result = relativizeResult(rawResult, Sonamu.apiRootPath);
+			const finishedAt = new Date().toISOString();
+			manager.emitEvent("runCompleted", {
+				schemaVersion: SCHEMA_VERSION,
+				runId,
+				startedAt,
+				finishedAt,
+				result
+			});
+			return result;
+		} catch (err) {
+			const finishedAt = new Date().toISOString();
+			manager.emitEvent("runErrored", {
+				schemaVersion: SCHEMA_VERSION,
+				runId,
+				finishedAt,
+				error: {
+					message: err instanceof Error ? err.message : String(err),
+					stack: err instanceof Error ? err.stack : undefined
+				}
+			});
+			reply.status(500);
+			return {
+				ok: false,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	});
+	server.get(`${prefix}/status`, async () => {
+		const status = Sonamu.devVitestManager?.getStatus() ?? {
+			ready: false,
+			running: false,
+			lastRunAt: null
+		};
+		return {
+			...status,
+			sseAvailable
+		};
+	});
+	server.addHook("onClose", async () => {
+		await Sonamu.devVitestManager?.shutdown();
+		Sonamu.devVitestManager = null;
+	});
 }
+var SCHEMA_VERSION, HEARTBEAT_INTERVAL_MS, SerializedTraceSchema, TestCaseResultSchema, TestEventSchema;
+var init_dev_test_routes = __esmMin((() => {
+	init_sonamu();
+	init_sse();
+	init_dev_vitest_manager();
+	SCHEMA_VERSION = 1;
+	HEARTBEAT_INTERVAL_MS = 3e4;
+	SerializedTraceSchema = z$1.object({
+		key: z$1.string(),
+		value: z$1.unknown(),
+		filePath: z$1.string(),
+		lineNumber: z$1.number(),
+		at: z$1.string()
+	});
+	TestCaseResultSchema = z$1.lazy(() => z$1.object({
+		id: z$1.string(),
+		kind: z$1.enum([
+			"file",
+			"suite",
+			"test"
+		]),
+		name: z$1.string(),
+		fullName: z$1.string(),
+		file: z$1.string(),
+		state: z$1.enum([
+			"passed",
+			"failed",
+			"skipped",
+			"todo",
+			"running",
+			"unknown"
+		]),
+		durationMs: z$1.number().nullable(),
+		counts: z$1.object({
+			total: z$1.number(),
+			passed: z$1.number(),
+			failed: z$1.number(),
+			skipped: z$1.number()
+		}),
+		error: z$1.object({
+			message: z$1.string(),
+			stack: z$1.string().optional()
+		}).nullable(),
+		traces: z$1.array(SerializedTraceSchema),
+		children: z$1.array(TestCaseResultSchema)
+	}));
+	TestEventSchema = z$1.object({
+		snapshot: z$1.object({
+			schemaVersion: z$1.number(),
+			serverTime: z$1.string(),
+			status: z$1.object({
+				ready: z$1.boolean(),
+				running: z$1.boolean(),
+				lastRunAt: z$1.string().nullable()
+			})
+		}),
+		runQueued: z$1.object({
+			schemaVersion: z$1.number(),
+			runId: z$1.string(),
+			queuedAt: z$1.string(),
+			request: z$1.object({
+				files: z$1.array(z$1.string()).optional(),
+				pattern: z$1.string().optional()
+			})
+		}),
+		runStarted: z$1.object({
+			schemaVersion: z$1.number(),
+			runId: z$1.string(),
+			startedAt: z$1.string()
+		}),
+		runCompleted: z$1.object({
+			schemaVersion: z$1.number(),
+			runId: z$1.string(),
+			startedAt: z$1.string(),
+			finishedAt: z$1.string(),
+			result: z$1.record(z$1.string(), z$1.unknown())
+		}),
+		runErrored: z$1.object({
+			schemaVersion: z$1.number(),
+			runId: z$1.string(),
+			finishedAt: z$1.string(),
+			error: z$1.object({
+				message: z$1.string(),
+				stack: z$1.string().optional()
+			})
+		}),
+		runNodeProgress: z$1.object({
+			schemaVersion: z$1.literal(1),
+			runId: z$1.string(),
+			startedAt: z$1.string(),
+			at: z$1.string(),
+			kind: z$1.enum([
+				"file",
+				"suite",
+				"test"
+			]),
+			phase: z$1.enum(["ready", "result"]),
+			fileId: z$1.string(),
+			nodeId: z$1.string(),
+			parentId: z$1.string().nullable(),
+			node: TestCaseResultSchema
+		}),
+		heartbeat: z$1.object({
+			schemaVersion: z$1.number(),
+			at: z$1.string()
+		})
+	});
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/testing/dev-test-routes.ts"],"sourcesContent":["import { randomUUID } from \"crypto\";\nimport type { FastifyInstance } from \"fastify\";\nimport { z } from \"zod\";\nimport type { SonamuDevRunnerConfig } from \"../api/config\";\nimport { Sonamu } from \"../api/sonamu\";\nimport type { SerializedTrace } from \"../naite/naite\";\nimport { createSSEFactory, type SSEConnection } from \"../stream/sse\";\nimport type { ManagerStatus, RunResult, TestCaseResult } from \"./dev-vitest-manager\";\nimport { DevVitestManager } from \"./dev-vitest-manager\";\n\nconst SCHEMA_VERSION = 1;\nconst HEARTBEAT_INTERVAL_MS = 30_000;\n\nconst SerializedTraceSchema = z.object({\n  key: z.string(),\n  value: z.unknown(),\n  filePath: z.string(),\n  lineNumber: z.number(),\n  at: z.string(),\n});\n\nconst TestCaseResultSchema: z.ZodType<TestCaseResult> = z.lazy(() =>\n  z.object({\n    id: z.string(),\n    kind: z.enum([\"file\", \"suite\", \"test\"]),\n    name: z.string(),\n    fullName: z.string(),\n    file: z.string(),\n    state: z.enum([\"passed\", \"failed\", \"skipped\", \"todo\", \"running\", \"unknown\"]),\n    durationMs: z.number().nullable(),\n    counts: z.object({\n      total: z.number(),\n      passed: z.number(),\n      failed: z.number(),\n      skipped: z.number(),\n    }),\n    error: z\n      .object({\n        message: z.string(),\n        stack: z.string().optional(),\n      })\n      .nullable(),\n    traces: z.array(SerializedTraceSchema),\n    children: z.array(TestCaseResultSchema),\n  }),\n);\n\nconst TestEventSchema = z.object({\n  snapshot: z.object({\n    schemaVersion: z.number(),\n    serverTime: z.string(),\n    status: z.object({\n      ready: z.boolean(),\n      running: z.boolean(),\n      lastRunAt: z.string().nullable(),\n    }),\n  }),\n  runQueued: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    queuedAt: z.string(),\n    request: z.object({\n      files: z.array(z.string()).optional(),\n      pattern: z.string().optional(),\n    }),\n  }),\n  runStarted: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    startedAt: z.string(),\n  }),\n  runCompleted: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    startedAt: z.string(),\n    finishedAt: z.string(),\n    result: z.record(z.string(), z.unknown()),\n  }),\n  runErrored: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    finishedAt: z.string(),\n    error: z.object({\n      message: z.string(),\n      stack: z.string().optional(),\n    }),\n  }),\n  runNodeProgress: z.object({\n    schemaVersion: z.literal(1),\n    runId: z.string(),\n    startedAt: z.string(),\n    at: z.string(),\n    kind: z.enum([\"file\", \"suite\", \"test\"]),\n    phase: z.enum([\"ready\", \"result\"]),\n    fileId: z.string(),\n    nodeId: z.string(),\n    parentId: z.string().nullable(),\n    node: TestCaseResultSchema,\n  }),\n  heartbeat: z.object({\n    schemaVersion: z.number(),\n    at: z.string(),\n  }),\n});\n\ntype TestEvents = z.infer<typeof TestEventSchema>;\n\nfunction toPathPrefix(basePath: string): string {\n  return basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n}\n\nfunction relativizeTrace(trace: SerializedTrace, prefix: string): SerializedTrace {\n  return { ...trace, filePath: trace.filePath.replace(prefix, \"\") };\n}\n\nfunction relativizeNode(node: TestCaseResult, basePath: string): TestCaseResult {\n  const prefix = toPathPrefix(basePath);\n  return {\n    ...node,\n    name: node.name.replace(prefix, \"\"),\n    file: node.file.replace(prefix, \"\"),\n    traces: node.traces.map((t) => relativizeTrace(t, prefix)),\n    children: node.children.map((c) => relativizeNode(c, prefix)),\n  };\n}\n\nfunction isRunNodeProgressData(data: unknown): data is TestEvents[\"runNodeProgress\"] {\n  if (typeof data !== \"object\" || data === null) return false;\n  const d = data as Record<string, unknown>;\n  return (\n    d.schemaVersion === 1 &&\n    typeof d.runId === \"string\" &&\n    typeof d.startedAt === \"string\" &&\n    typeof d.at === \"string\" &&\n    (d.kind === \"file\" || d.kind === \"suite\" || d.kind === \"test\") &&\n    (d.phase === \"ready\" || d.phase === \"result\") &&\n    typeof d.fileId === \"string\" &&\n    typeof d.nodeId === \"string\" &&\n    (d.parentId === null || typeof d.parentId === \"string\") &&\n    typeof d.node === \"object\" &&\n    d.node !== null\n  );\n}\n\nfunction relativizeResult(result: RunResult, basePath: string): RunResult {\n  const prefix = toPathPrefix(basePath);\n  return {\n    ...result,\n    results: result.results.map((n) => relativizeNode(n, prefix)),\n  };\n}\n\nexport async function registerDevTestRoutes(\n  server: FastifyInstance,\n  config: SonamuDevRunnerConfig,\n): Promise<void> {\n  const prefix = config.routePrefix ?? \"/__test__\";\n\n  const manager = new DevVitestManager();\n  await manager.start(config.vitestConfigPath);\n  Sonamu.devVitestManager = manager;\n\n  const sseAvailable = !!Sonamu.config.server.plugins?.sse;\n\n  if (sseAvailable) {\n    server.get(`${prefix}/events`, (request, reply): void => {\n      const sse: SSEConnection<typeof TestEventSchema> = createSSEFactory(\n        request.socket,\n        reply,\n        TestEventSchema,\n      );\n\n      const status: ManagerStatus = manager.getStatus();\n      sse.publish(\"snapshot\", {\n        schemaVersion: SCHEMA_VERSION,\n        serverTime: new Date().toISOString(),\n        status,\n      });\n\n      const heartbeatTimer = setInterval(() => {\n        sse.publish(\"heartbeat\", {\n          schemaVersion: SCHEMA_VERSION,\n          at: new Date().toISOString(),\n        });\n      }, HEARTBEAT_INTERVAL_MS);\n\n      const basePath = Sonamu.apiRootPath;\n      const listener = (event: string, data: unknown) => {\n        const key = event as keyof TestEvents;\n        if (key === \"runNodeProgress\") {\n          if (!isRunNodeProgressData(data)) return;\n          const relativized = {\n            ...data,\n            node: relativizeNode(data.node, basePath),\n          };\n          sse.publish(key, relativized);\n          return;\n        }\n        sse.publish(key, data as TestEvents[typeof key]);\n      };\n      manager.addEventListener(listener);\n\n      let cleaned = false;\n      const cleanup = () => {\n        if (cleaned) return;\n        cleaned = true;\n        clearInterval(heartbeatTimer);\n        manager.removeEventListener(listener);\n      };\n      request.socket.on(\"close\", cleanup);\n      request.socket.on(\"error\", cleanup);\n    });\n  }\n\n  server.post(`${prefix}/run`, async (request, reply) => {\n    if (!Sonamu.devVitestManager) {\n      reply.status(503);\n      return { ok: false, error: \"DevVitestManager is not initialized\" };\n    }\n\n    const runId = randomUUID();\n    const body = request.body as { files?: string[]; pattern?: string } | null;\n    const runRequest = {\n      files: body?.files,\n      pattern: body?.pattern,\n    };\n\n    manager.emitEvent(\"runQueued\", {\n      schemaVersion: SCHEMA_VERSION,\n      runId,\n      queuedAt: new Date().toISOString(),\n      request: runRequest,\n    });\n\n    try {\n      const startedAt = new Date().toISOString();\n      manager.emitEvent(\"runStarted\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        startedAt,\n      });\n\n      const rawResult: RunResult = await Sonamu.devVitestManager.run(runRequest, runId);\n      const result = relativizeResult(rawResult, Sonamu.apiRootPath);\n\n      const finishedAt = new Date().toISOString();\n      manager.emitEvent(\"runCompleted\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        startedAt,\n        finishedAt,\n        result,\n      });\n\n      return result;\n    } catch (err) {\n      const finishedAt = new Date().toISOString();\n      manager.emitEvent(\"runErrored\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        finishedAt,\n        error: {\n          message: err instanceof Error ? err.message : String(err),\n          stack: err instanceof Error ? err.stack : undefined,\n        },\n      });\n\n      reply.status(500);\n      return { ok: false, error: err instanceof Error ? err.message : String(err) };\n    }\n  });\n\n  server.get(`${prefix}/status`, async () => {\n    const status: ManagerStatus = Sonamu.devVitestManager?.getStatus() ?? {\n      ready: false,\n      running: false,\n      lastRunAt: null,\n    };\n    return { ...status, sseAvailable };\n  });\n\n  server.addHook(\"onClose\", async () => {\n    await Sonamu.devVitestManager?.shutdown();\n    Sonamu.devVitestManager = null;\n  });\n}\n"],"names":["randomUUID","z","Sonamu","createSSEFactory","DevVitestManager","SCHEMA_VERSION","HEARTBEAT_INTERVAL_MS","SerializedTraceSchema","object","key","string","value","unknown","filePath","lineNumber","number","at","TestCaseResultSchema","lazy","id","kind","enum","name","fullName","file","state","durationMs","nullable","counts","total","passed","failed","skipped","error","message","stack","optional","traces","array","children","TestEventSchema","snapshot","schemaVersion","serverTime","status","ready","boolean","running","lastRunAt","runQueued","runId","queuedAt","request","files","pattern","runStarted","startedAt","runCompleted","finishedAt","result","record","runErrored","runNodeProgress","literal","phase","fileId","nodeId","parentId","node","heartbeat","toPathPrefix","basePath","endsWith","relativizeTrace","trace","prefix","replace","relativizeNode","map","t","c","isRunNodeProgressData","data","d","relativizeResult","results","n","registerDevTestRoutes","server","config","routePrefix","manager","start","vitestConfigPath","devVitestManager","sseAvailable","plugins","sse","get","reply","socket","getStatus","publish","Date","toISOString","heartbeatTimer","setInterval","apiRootPath","listener","event","relativized","addEventListener","cleaned","cleanup","clearInterval","removeEventListener","on","post","ok","body","runRequest","emitEvent","rawResult","run","err","Error","String","undefined","addHook","shutdown"],"mappings":"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"}
+//#endregion
+init_dev_test_routes();
+export { registerDevTestRoutes };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"dev-test-routes.js","names":["sse: SSEConnection<typeof TestEventSchema>","status: ManagerStatus","rawResult: RunResult","z","TestCaseResultSchema: z.ZodType<TestCaseResult>"],"sources":["../../src/testing/dev-test-routes.ts"],"sourcesContent":["import { randomUUID } from \"crypto\";\n\nimport { type FastifyInstance } from \"fastify\";\nimport { z } from \"zod\";\n\nimport { type SonamuDevRunnerConfig } from \"../api/config\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { type SerializedTrace } from \"../naite/naite\";\nimport { createSSEFactory } from \"../stream/sse\";\nimport { type SSEConnection } from \"../stream/sse\";\nimport { type ManagerStatus, type RunResult, type TestCaseResult } from \"./dev-vitest-manager\";\nimport { DevVitestManager } from \"./dev-vitest-manager\";\n\nconst SCHEMA_VERSION = 1;\nconst HEARTBEAT_INTERVAL_MS = 30_000;\n\nconst SerializedTraceSchema = z.object({\n  key: z.string(),\n  value: z.unknown(),\n  filePath: z.string(),\n  lineNumber: z.number(),\n  at: z.string(),\n});\n\nconst TestCaseResultSchema: z.ZodType<TestCaseResult> = z.lazy(() =>\n  z.object({\n    id: z.string(),\n    kind: z.enum([\"file\", \"suite\", \"test\"]),\n    name: z.string(),\n    fullName: z.string(),\n    file: z.string(),\n    state: z.enum([\"passed\", \"failed\", \"skipped\", \"todo\", \"running\", \"unknown\"]),\n    durationMs: z.number().nullable(),\n    counts: z.object({\n      total: z.number(),\n      passed: z.number(),\n      failed: z.number(),\n      skipped: z.number(),\n    }),\n    error: z\n      .object({\n        message: z.string(),\n        stack: z.string().optional(),\n      })\n      .nullable(),\n    traces: z.array(SerializedTraceSchema),\n    children: z.array(TestCaseResultSchema),\n  }),\n);\n\nconst TestEventSchema = z.object({\n  snapshot: z.object({\n    schemaVersion: z.number(),\n    serverTime: z.string(),\n    status: z.object({\n      ready: z.boolean(),\n      running: z.boolean(),\n      lastRunAt: z.string().nullable(),\n    }),\n  }),\n  runQueued: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    queuedAt: z.string(),\n    request: z.object({\n      files: z.array(z.string()).optional(),\n      pattern: z.string().optional(),\n    }),\n  }),\n  runStarted: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    startedAt: z.string(),\n  }),\n  runCompleted: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    startedAt: z.string(),\n    finishedAt: z.string(),\n    result: z.record(z.string(), z.unknown()),\n  }),\n  runErrored: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    finishedAt: z.string(),\n    error: z.object({\n      message: z.string(),\n      stack: z.string().optional(),\n    }),\n  }),\n  runNodeProgress: z.object({\n    schemaVersion: z.literal(1),\n    runId: z.string(),\n    startedAt: z.string(),\n    at: z.string(),\n    kind: z.enum([\"file\", \"suite\", \"test\"]),\n    phase: z.enum([\"ready\", \"result\"]),\n    fileId: z.string(),\n    nodeId: z.string(),\n    parentId: z.string().nullable(),\n    node: TestCaseResultSchema,\n  }),\n  heartbeat: z.object({\n    schemaVersion: z.number(),\n    at: z.string(),\n  }),\n});\n\ntype TestEvents = z.infer<typeof TestEventSchema>;\n\nfunction toPathPrefix(basePath: string): string {\n  return basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n}\n\nfunction relativizeTrace(trace: SerializedTrace, prefix: string): SerializedTrace {\n  return { ...trace, filePath: trace.filePath.replace(prefix, \"\") };\n}\n\nfunction relativizeNode(node: TestCaseResult, basePath: string): TestCaseResult {\n  const prefix = toPathPrefix(basePath);\n  return {\n    ...node,\n    name: node.name.replace(prefix, \"\"),\n    file: node.file.replace(prefix, \"\"),\n    traces: node.traces.map((t) => relativizeTrace(t, prefix)),\n    children: node.children.map((c) => relativizeNode(c, prefix)),\n  };\n}\n\nfunction isRunNodeProgressData(data: unknown): data is TestEvents[\"runNodeProgress\"] {\n  if (typeof data !== \"object\" || data === null) return false;\n  const d = data as Record<string, unknown>;\n  return (\n    d.schemaVersion === 1 &&\n    typeof d.runId === \"string\" &&\n    typeof d.startedAt === \"string\" &&\n    typeof d.at === \"string\" &&\n    (d.kind === \"file\" || d.kind === \"suite\" || d.kind === \"test\") &&\n    (d.phase === \"ready\" || d.phase === \"result\") &&\n    typeof d.fileId === \"string\" &&\n    typeof d.nodeId === \"string\" &&\n    (d.parentId === null || typeof d.parentId === \"string\") &&\n    typeof d.node === \"object\" &&\n    d.node !== null\n  );\n}\n\nfunction relativizeResult(result: RunResult, basePath: string): RunResult {\n  const prefix = toPathPrefix(basePath);\n  return {\n    ...result,\n    results: result.results.map((n) => relativizeNode(n, prefix)),\n  };\n}\n\nexport async function registerDevTestRoutes(\n  server: FastifyInstance,\n  config: SonamuDevRunnerConfig,\n): Promise<void> {\n  const prefix = config.routePrefix ?? \"/__test__\";\n\n  const manager = new DevVitestManager();\n  await manager.start(config.vitestConfigPath);\n  Sonamu.devVitestManager = manager;\n\n  const sseAvailable = !!Sonamu.config.server.plugins?.sse;\n\n  if (sseAvailable) {\n    server.get(`${prefix}/events`, (request, reply): void => {\n      const sse: SSEConnection<typeof TestEventSchema> = createSSEFactory(\n        request.socket,\n        reply,\n        TestEventSchema,\n      );\n\n      const status: ManagerStatus = manager.getStatus();\n      sse.publish(\"snapshot\", {\n        schemaVersion: SCHEMA_VERSION,\n        serverTime: new Date().toISOString(),\n        status,\n      });\n\n      const heartbeatTimer = setInterval(() => {\n        sse.publish(\"heartbeat\", {\n          schemaVersion: SCHEMA_VERSION,\n          at: new Date().toISOString(),\n        });\n      }, HEARTBEAT_INTERVAL_MS);\n\n      const basePath = Sonamu.apiRootPath;\n      const listener = (event: string, data: unknown) => {\n        const key = event as keyof TestEvents;\n        if (key === \"runNodeProgress\") {\n          if (!isRunNodeProgressData(data)) return;\n          const relativized = {\n            ...data,\n            node: relativizeNode(data.node, basePath),\n          };\n          sse.publish(key, relativized);\n          return;\n        }\n        sse.publish(key, data as TestEvents[typeof key]);\n      };\n      manager.addEventListener(listener);\n\n      let cleaned = false;\n      const cleanup = () => {\n        if (cleaned) return;\n        cleaned = true;\n        clearInterval(heartbeatTimer);\n        manager.removeEventListener(listener);\n      };\n      request.socket.on(\"close\", cleanup);\n      request.socket.on(\"error\", cleanup);\n    });\n  }\n\n  server.post(`${prefix}/run`, async (request, reply) => {\n    if (!Sonamu.devVitestManager) {\n      reply.status(503);\n      return { ok: false, error: \"DevVitestManager is not initialized\" };\n    }\n\n    const runId = randomUUID();\n    const body = request.body as { files?: string[]; pattern?: string } | null;\n    const runRequest = {\n      files: body?.files,\n      pattern: body?.pattern,\n    };\n\n    manager.emitEvent(\"runQueued\", {\n      schemaVersion: SCHEMA_VERSION,\n      runId,\n      queuedAt: new Date().toISOString(),\n      request: runRequest,\n    });\n\n    try {\n      const startedAt = new Date().toISOString();\n      manager.emitEvent(\"runStarted\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        startedAt,\n      });\n\n      const rawResult: RunResult = await Sonamu.devVitestManager.run(runRequest, runId);\n      const result = relativizeResult(rawResult, Sonamu.apiRootPath);\n\n      const finishedAt = new Date().toISOString();\n      manager.emitEvent(\"runCompleted\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        startedAt,\n        finishedAt,\n        result,\n      });\n\n      return result;\n    } catch (err) {\n      const finishedAt = new Date().toISOString();\n      manager.emitEvent(\"runErrored\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        finishedAt,\n        error: {\n          message: err instanceof Error ? err.message : String(err),\n          stack: err instanceof Error ? err.stack : undefined,\n        },\n      });\n\n      reply.status(500);\n      return { ok: false, error: err instanceof Error ? err.message : String(err) };\n    }\n  });\n\n  server.get(`${prefix}/status`, async () => {\n    const status: ManagerStatus = Sonamu.devVitestManager?.getStatus() ?? {\n      ready: false,\n      running: false,\n      lastRunAt: null,\n    };\n    return { ...status, sseAvailable };\n  });\n\n  server.addHook(\"onClose\", async () => {\n    await Sonamu.devVitestManager?.shutdown();\n    Sonamu.devVitestManager = null;\n  });\n}\n"],"mappings":"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"}

package/dist/testing/dev-vitest-manager.d.ts

@@ -1,4 +1,4 @@
-import type { SerializedTrace } from "../naite/naite";
+import { type SerializedTrace } from "../naite/naite";
 export type TestNodeKind = "file" | "suite" | "test";
 export type TestState = "passed" | "failed" | "skipped" | "todo" | "running" | "unknown";
 export type TestCaseResult = {

package/dist/testing/dev-vitest-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-vitest-manager.d.ts","sourceRoot":"","sources":["../../src/testing/dev-vitest-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dev-vitest-manager.d.ts","sourceRoot":"","sources":["../../src/testing/dev-vitest-manager.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGtD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AACrD,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;AAEzF,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3E,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAClD,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;AASvE,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,cAAc,CAAgC;IACtD,OAAO,CAAC,iBAAiB,CAIT;IAEhB,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAInD,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAItD,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI;IAMvC,KAAK,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiD/C,GAAG,CAAC,IAAI,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAe1F,SAAS,IAAI,aAAa;IAQ1B;;;OAGG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI;IASpC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;YAoBjB,YAAY;YA2BZ,UAAU;IA6CxB,OAAO,CAAC,8BAA8B;IA4GtC,OAAO,CAAC,qBAAqB;IAgB7B,OAAO,CAAC,sBAAsB;IAiB9B,OAAO,CAAC,qBAAqB;IAiB7B,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,cAAc;IAkCtB,OAAO,CAAC,aAAa;IAsBrB,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,cAAc;IAoBtB,OAAO,CAAC,aAAa;CAkCtB"}