1use std::{
2 path::{Path, PathBuf},
3 time::{Duration, SystemTime, UNIX_EPOCH},
4};
5
6use serde::{Deserialize, Serialize};
7
8use crate::{
9 ControlState, ExecutionPlan, GraphDocument, PreviewDocument, RuntimeDiagnostic,
10 RuntimeSessionSnapshot, RuntimeTelemetrySnapshot,
11 preview_control_state::{
12 PreviewControlStateSnapshot, preview_control_state_path,
13 write_preview_control_state_snapshot,
14 },
15 render::{
16 cleanup_stale_preview_temp_files, remove_preview_temp_file,
17 render_scene_from_preview_document,
18 },
19 telemetry::{
20 PREVIEW_TELEMETRY_SCHEMA, PREVIEW_TELEMETRY_SCHEMA_VERSION, PreviewTelemetryHeartbeat,
21 preview_telemetry_path, read_preview_telemetry, unix_ms_timestamp,
22 write_preview_telemetry_heartbeat,
23 },
24};
25
26pub(crate) trait PreviewHandle: Send {
27 fn pid(&self) -> Option<u32>;
28 fn try_wait(&mut self) -> Result<Option<i32>, String>;
29 fn stop(&mut self) -> Result<Option<i32>, String>;
30}
31
32pub(crate) struct PreviewSpawn {
33 handle: Box<dyn PreviewHandle>,
34 document_path: Option<PathBuf>,
35}
36
37pub(crate) type PreviewSpawner = fn(&PreviewDocument, &Path, &Path) -> Result<PreviewSpawn, String>;
38
39#[derive(Debug, Clone, PartialEq)]
40pub(crate) struct PreviewContext {
41 pub(crate) graph_id: String,
42 pub(crate) graph_revision: String,
43 pub(crate) session_revision: u64,
44 pub(crate) control_revision: u64,
45 pub(crate) graph: GraphDocument,
46 pub(crate) plan: ExecutionPlan,
47 pub(crate) control_state: ControlState,
48}
49
50#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
51#[serde(rename_all = "lowercase")]
52pub enum PreviewState {
53 Stopped,
54 Starting,
55 Running,
56 Exited,
57 Error,
58}
59
60#[derive(Debug, Clone, Deserialize)]
61#[serde(rename_all = "camelCase")]
62pub struct RuntimePreviewStartRequest {
63 #[serde(default)]
64 pub restart: bool,
65}
66
67#[derive(Debug, Clone, Serialize)]
68#[serde(rename_all = "camelCase")]
69pub struct RuntimePreviewStatusResponse {
70 pub ok: bool,
71 pub state: PreviewState,
72 pub pid: Option<u32>,
73 pub graph_id: Option<String>,
74 pub graph_revision: Option<String>,
75 pub session_revision: Option<u64>,
76 pub preview_session_revision: Option<u64>,
77 pub control_revision: Option<u64>,
78 pub preview_control_revision: Option<u64>,
79 pub control_live: bool,
80 pub last_control_update_at: Option<String>,
81 pub stale: bool,
82 pub started_at: Option<String>,
83 pub exited_at: Option<String>,
84 pub exit_code: Option<i32>,
85 pub message: Option<String>,
86 pub diagnostics: Vec<RuntimeDiagnostic>,
87}
88
89#[derive(Clone)]
90struct PreviewStatus {
91 state: PreviewState,
92 pid: Option<u32>,
93 graph_id: Option<String>,
94 graph_revision: Option<String>,
95 preview_session_revision: Option<u64>,
96 preview_control_revision: Option<u64>,
97 last_control_update_at: Option<String>,
98 started_at: Option<String>,
99 exited_at: Option<String>,
100 exit_code: Option<i32>,
101 message: Option<String>,
102 telemetry_path: Option<PathBuf>,
103 control_state_path: Option<PathBuf>,
104 document_path: Option<PathBuf>,
105}
106
107pub struct PreviewManager {
108 status: PreviewStatus,
109 handle: Option<Box<dyn PreviewHandle>>,
110 dry_run: bool,
111 spawner: PreviewSpawner,
112 control_state_path_override: Option<PathBuf>,
113}
114
115impl Default for PreviewManager {
116 fn default() -> Self {
117 Self::from_env()
118 }
119}
120
121impl PreviewManager {
122 pub fn from_env() -> Self {
123 Self::with_spawner(
124 dry_run_enabled(std::env::var("SKENION_PREVIEW_DRY_RUN").ok().as_deref()),
125 crate::visual::spawn_preview_document_handle,
126 )
127 }
128
129 pub fn dry_run() -> Self {
130 Self::with_spawner(true, crate::visual::spawn_preview_document_handle)
131 }
132
133 pub fn status(&mut self, snapshot: RuntimeSessionSnapshot) -> RuntimePreviewStatusResponse {
134 self.poll();
135 self.to_response(true, &snapshot, Vec::new())
136 }
137
138 pub fn telemetry(
139 &mut self,
140 snapshot: RuntimeSessionSnapshot,
141 uptime_ms: u64,
142 ) -> RuntimeTelemetrySnapshot {
143 self.poll();
144 let mut diagnostics = Vec::new();
145 let heartbeat = match self.status.telemetry_path.as_deref() {
146 Some(path) => match read_preview_telemetry(path) {
147 Ok(heartbeat) => heartbeat,
148 Err(error) => {
149 diagnostics.push(RuntimeDiagnostic::warning(format!(
150 "invalid preview telemetry heartbeat: {error}"
151 )));
152 None
153 }
154 },
155 None => None,
156 };
157
158 RuntimeTelemetrySnapshot::from_parts(
159 snapshot.clone(),
160 self.to_response(true, &snapshot, Vec::new()),
161 heartbeat,
162 self.dry_run,
163 uptime_ms,
164 diagnostics,
165 )
166 }
167
168 pub(crate) fn start(
169 &mut self,
170 context: Result<PreviewContext, Vec<RuntimeDiagnostic>>,
171 snapshot: RuntimeSessionSnapshot,
172 restart: bool,
173 ) -> RuntimePreviewStatusResponse {
174 self.poll();
175 if self.is_active() && !restart {
176 return self.to_response(true, &snapshot, Vec::new());
177 }
178 cleanup_stale_preview_files();
179 if restart {
180 let _ = self.stop_current();
181 }
182
183 let context = match context {
184 Ok(context) => context,
185 Err(diagnostics) => return self.to_response(false, &snapshot, diagnostics),
186 };
187
188 let control_state_path = self
189 .control_state_path_override
190 .take()
191 .unwrap_or_else(|| preview_control_state_path(context.session_revision));
192
193 self.status = PreviewStatus {
194 state: PreviewState::Starting,
195 pid: None,
196 graph_id: Some(context.graph_id.clone()),
197 graph_revision: Some(context.graph_revision.clone()),
198 preview_session_revision: Some(context.session_revision),
199 preview_control_revision: Some(context.control_revision),
200 last_control_update_at: None,
201 started_at: Some(now_string()),
202 exited_at: None,
203 exit_code: None,
204 message: None,
205 telemetry_path: Some(preview_telemetry_path(context.session_revision)),
206 control_state_path: Some(control_state_path),
207 document_path: None,
208 };
209
210 let control_snapshot = PreviewControlStateSnapshot::new(
211 context.session_revision,
212 context.control_revision,
213 &context.control_state,
214 );
215 if let Err(error) = self.write_control_snapshot(&control_snapshot) {
216 self.status.state = PreviewState::Error;
217 self.status.message = Some(error.clone());
218 return self.to_response(false, &snapshot, vec![RuntimeDiagnostic::error(error)]);
219 }
220
221 let document = PreviewDocument::with_control_state(
222 context.graph.clone(),
223 context.plan.clone(),
224 context.control_state.clone(),
225 context.session_revision,
226 );
227 let handle = if self.dry_run {
228 record_dry_run_heartbeat(&mut self.status, &document, Some(&control_snapshot));
229 Ok(PreviewSpawn::new(Box::new(DryRunPreviewHandle), None))
230 } else {
231 let telemetry_path = self
232 .status
233 .telemetry_path
234 .as_deref()
235 .expect("preview telemetry path should be prepared before spawning");
236 let control_state_path = self
237 .status
238 .control_state_path
239 .as_deref()
240 .expect("preview control state path should be prepared before spawning");
241 (self.spawner)(&document, telemetry_path, control_state_path)
242 };
243
244 match handle {
245 Ok(spawn) => {
246 self.status.pid = spawn.handle.pid();
247 self.status.document_path = spawn.document_path;
248 self.status.state = PreviewState::Running;
249 self.handle = Some(spawn.handle);
250 self.to_response(true, &snapshot, Vec::new())
251 }
252 Err(error) => {
253 self.status.state = PreviewState::Error;
254 self.status.message = Some(error.clone());
255 self.handle = None;
256 self.to_response(false, &snapshot, vec![RuntimeDiagnostic::error(error)])
257 }
258 }
259 }
260
261 pub(crate) fn restart(
262 &mut self,
263 context: Result<PreviewContext, Vec<RuntimeDiagnostic>>,
264 snapshot: RuntimeSessionSnapshot,
265 ) -> RuntimePreviewStatusResponse {
266 self.start(context, snapshot, true)
267 }
268
269 pub fn stop(&mut self, snapshot: RuntimeSessionSnapshot) -> RuntimePreviewStatusResponse {
270 match self.stop_current() {
271 Ok(()) => self.to_response(true, &snapshot, Vec::new()),
272 Err(error) => self.to_response(false, &snapshot, vec![RuntimeDiagnostic::error(error)]),
273 }
274 }
275
276 pub fn update_control_state(
277 &mut self,
278 snapshot: PreviewControlStateSnapshot,
279 ) -> Result<(), String> {
280 self.poll();
281 if !self.is_active() {
282 return Ok(());
283 }
284 self.write_control_snapshot(&snapshot)?;
285 self.status.preview_control_revision = Some(snapshot.control_revision);
286 self.status.last_control_update_at = Some(snapshot.written_at.clone());
287 if self.dry_run
288 && let Some(telemetry_path) = self.status.telemetry_path.as_deref()
289 && let Ok(Some(mut heartbeat)) = read_preview_telemetry(telemetry_path)
290 {
291 heartbeat.control_revision = Some(snapshot.control_revision);
292 heartbeat.preview_control_revision = Some(snapshot.control_revision);
293 heartbeat.control_live = true;
294 heartbeat.last_control_update_at = Some(snapshot.written_at);
295 let _ = write_preview_telemetry_heartbeat(telemetry_path, &heartbeat);
296 }
297 Ok(())
298 }
299
300 pub fn request_error(
301 &self,
302 snapshot: RuntimeSessionSnapshot,
303 diagnostic: RuntimeDiagnostic,
304 ) -> RuntimePreviewStatusResponse {
305 self.to_response(false, &snapshot, vec![diagnostic])
306 }
307
308 fn is_active(&self) -> bool {
309 matches!(
310 self.status.state,
311 PreviewState::Starting | PreviewState::Running
312 )
313 }
314
315 fn poll(&mut self) {
316 let Some(handle) = self.handle.as_mut() else {
317 return;
318 };
319 match handle.try_wait() {
320 Ok(Some(code)) => {
321 self.status.state = PreviewState::Exited;
322 self.status.pid = None;
323 self.status.exited_at = Some(now_string());
324 self.status.exit_code = Some(code);
325 self.status.message = Some("preview process exited".to_owned());
326 self.handle = None;
327 }
328 Ok(None) => {
329 if self.status.state == PreviewState::Starting {
330 self.status.state = PreviewState::Running;
331 }
332 }
333 Err(error) => {
334 self.status.state = PreviewState::Error;
335 self.status.pid = None;
336 self.status.exited_at = Some(now_string());
337 self.status.message = Some(error);
338 self.handle = None;
339 }
340 }
341 }
342
343 fn stop_current(&mut self) -> Result<(), String> {
344 self.poll();
345 if let Some(mut handle) = self.handle.take() {
346 let exit_code = match handle.stop() {
347 Ok(exit_code) => exit_code,
348 Err(error) => {
349 self.status.state = PreviewState::Error;
350 self.status.pid = None;
351 self.status.exited_at = Some(now_string());
352 self.status.message = Some(error.clone());
353 return Err(error);
354 }
355 };
356 self.status.exit_code = exit_code;
357 self.status.exited_at = Some(now_string());
358 }
359 self.remove_current_temp_files();
360 self.status = PreviewStatus::stopped();
361 Ok(())
362 }
363
364 fn remove_current_temp_files(&mut self) {
365 if let Some(path) = self.status.document_path.as_deref() {
366 let _ = remove_preview_temp_file(path);
367 }
368 if let Some(path) = self.status.telemetry_path.as_deref() {
369 let _ = remove_preview_temp_file(path);
370 }
371 if let Some(path) = self.status.control_state_path.as_deref() {
372 let _ = remove_preview_temp_file(path);
373 }
374 }
375
376 fn write_control_snapshot(
377 &mut self,
378 snapshot: &PreviewControlStateSnapshot,
379 ) -> Result<(), String> {
380 let Some(path) = self.status.control_state_path.as_deref() else {
381 return Ok(());
382 };
383 write_preview_control_state_snapshot(path, snapshot)?;
384 self.status.preview_control_revision = Some(snapshot.control_revision);
385 self.status.last_control_update_at = Some(snapshot.written_at.clone());
386 Ok(())
387 }
388
389 fn to_response(
390 &self,
391 ok: bool,
392 snapshot: &RuntimeSessionSnapshot,
393 diagnostics: Vec<RuntimeDiagnostic>,
394 ) -> RuntimePreviewStatusResponse {
395 let session_revision = snapshot.loaded().then_some(snapshot.session_revision);
396 let control_revision = snapshot.loaded().then_some(snapshot.control_revision);
397 let stale = self.status.state != PreviewState::Stopped
398 && session_revision
399 .zip(self.status.preview_session_revision)
400 .is_some_and(|(session_revision, preview_revision)| {
401 session_revision != preview_revision
402 });
403 let control_live = self.status.state != PreviewState::Stopped
404 && control_revision
405 .zip(self.status.preview_control_revision)
406 .is_some_and(|(control_revision, preview_revision)| {
407 control_revision == preview_revision
408 });
409
410 RuntimePreviewStatusResponse {
411 ok,
412 state: self.status.state.clone(),
413 pid: self.status.pid,
414 graph_id: self.status.graph_id.clone(),
415 graph_revision: self.status.graph_revision.clone(),
416 session_revision,
417 preview_session_revision: self.status.preview_session_revision,
418 control_revision,
419 preview_control_revision: self.status.preview_control_revision,
420 control_live,
421 last_control_update_at: self.status.last_control_update_at.clone(),
422 stale,
423 started_at: self.status.started_at.clone(),
424 exited_at: self.status.exited_at.clone(),
425 exit_code: self.status.exit_code,
426 message: self.status.message.clone(),
427 diagnostics,
428 }
429 }
430
431 #[cfg(test)]
432 fn with_test_spawner(dry_run: bool, spawner: PreviewSpawner) -> Self {
433 Self::with_spawner(dry_run, spawner)
434 }
435
436 fn with_spawner(dry_run: bool, spawner: PreviewSpawner) -> Self {
437 Self {
438 status: PreviewStatus::stopped(),
439 handle: None,
440 dry_run,
441 spawner,
442 control_state_path_override: None,
443 }
444 }
445
446 #[cfg(test)]
447 fn with_control_state_path_override(mut self, path: PathBuf) -> Self {
448 self.control_state_path_override = Some(path);
449 self
450 }
451
452 #[cfg(test)]
453 pub(crate) fn set_control_state_path_for_test(&mut self, path: PathBuf) {
454 self.status.control_state_path = Some(path);
455 }
456}
457
458impl PreviewStatus {
459 fn stopped() -> Self {
460 Self {
461 state: PreviewState::Stopped,
462 pid: None,
463 graph_id: None,
464 graph_revision: None,
465 preview_session_revision: None,
466 preview_control_revision: None,
467 last_control_update_at: None,
468 started_at: None,
469 exited_at: None,
470 exit_code: None,
471 message: None,
472 telemetry_path: None,
473 control_state_path: None,
474 document_path: None,
475 }
476 }
477}
478
479impl PreviewSpawn {
480 pub(crate) fn new(handle: Box<dyn PreviewHandle>, document_path: Option<PathBuf>) -> Self {
481 Self {
482 handle,
483 document_path,
484 }
485 }
486}
487
488struct DryRunPreviewHandle;
489
490impl PreviewHandle for DryRunPreviewHandle {
491 fn pid(&self) -> Option<u32> {
492 None
493 }
494
495 fn try_wait(&mut self) -> Result<Option<i32>, String> {
496 Ok(None)
497 }
498
499 fn stop(&mut self) -> Result<Option<i32>, String> {
500 Ok(Some(0))
501 }
502}
503
504fn dry_run_enabled(value: Option<&str>) -> bool {
505 value.is_some_and(|value| matches!(value, "1" | "true" | "TRUE" | "yes" | "YES"))
506}
507
508fn now_string() -> String {
509 let millis = SystemTime::now()
510 .duration_since(UNIX_EPOCH)
511 .map(|duration| duration.as_millis())
512 .unwrap_or_default();
513 format!("unix-ms:{millis}")
514}
515
516fn cleanup_stale_preview_files() {
517 let _ = cleanup_stale_preview_temp_files(Duration::from_secs(24 * 60 * 60));
518}
519
520fn dry_run_heartbeat(
521 document: &PreviewDocument,
522 control_snapshot: Option<&PreviewControlStateSnapshot>,
523) -> PreviewTelemetryHeartbeat {
524 let scene = render_scene_from_preview_document(document);
525 let (renderer, source_node_id, last_error, diagnostics, generated_source_available) =
526 match scene {
527 Ok(scene) => (
528 scene.renderer_label().to_owned(),
529 scene.source_node_id(),
530 None,
531 Vec::new(),
532 matches!(scene, crate::RenderScene::FullscreenShader(_)),
533 ),
534 Err(error) => (
535 "clear-color".to_owned(),
536 None,
537 Some(error.to_string()),
538 error.shader_diagnostics(),
539 false,
540 ),
541 };
542
543 PreviewTelemetryHeartbeat {
544 schema: PREVIEW_TELEMETRY_SCHEMA.to_owned(),
545 schema_version: PREVIEW_TELEMETRY_SCHEMA_VERSION.to_owned(),
546 timestamp: unix_ms_timestamp(),
547 pid: std::process::id(),
548 graph_id: document.graph.id.clone(),
549 graph_revision: document.graph.revision.clone(),
550 session_revision: document.session_revision,
551 renderer,
552 backend: "dry-run".to_owned(),
553 frames_rendered: 0,
554 approx_fps: None,
555 last_frame_ms: None,
556 last_error,
557 source_node_id,
558 diagnostics,
559 generated_source_available,
560 control_revision: control_snapshot.map(|snapshot| snapshot.control_revision),
561 preview_control_revision: control_snapshot.map(|snapshot| snapshot.control_revision),
562 control_live: control_snapshot.is_some(),
563 last_control_update_at: control_snapshot.map(|snapshot| snapshot.written_at.clone()),
564 }
565}
566
567fn record_dry_run_heartbeat(
568 status: &mut PreviewStatus,
569 document: &PreviewDocument,
570 control_snapshot: Option<&PreviewControlStateSnapshot>,
571) {
572 let telemetry_path = status
573 .telemetry_path
574 .as_deref()
575 .expect("preview telemetry path should be prepared before dry-run start");
576 let heartbeat = dry_run_heartbeat(document, control_snapshot);
577 if let Err(error) = write_preview_telemetry_heartbeat(telemetry_path, &heartbeat) {
578 status.message = Some(format!(
579 "failed to write dry-run preview telemetry: {error}"
580 ));
581 }
582}
583
584#[cfg(test)]
585mod tests {
586 use serde_json::json;
587
588 use super::*;
589 use crate::{
590 ExecutionGroup, ExecutionModel, GraphDocument, GraphNode, PREVIEW_TELEMETRY_SCHEMA,
591 PREVIEW_TELEMETRY_SCHEMA_VERSION, PlanEdge, PlanNode, Port, PreviewTelemetryHeartbeat,
592 ProjectDocumentCurrent, RuntimeSessionSnapshot, preview_manager::PreviewHandle,
593 read_preview_control_state_snapshot, telemetry::write_preview_telemetry_heartbeat,
594 };
595
596 #[test]
597 fn dry_run_detection_accepts_explicit_truthy_values() {
598 assert!(dry_run_enabled(Some("1")));
599 assert!(dry_run_enabled(Some("true")));
600 assert!(dry_run_enabled(Some("TRUE")));
601 assert!(dry_run_enabled(Some("yes")));
602 assert!(dry_run_enabled(Some("YES")));
603 assert!(!dry_run_enabled(Some("0")));
604 assert!(!dry_run_enabled(Some("false")));
605 assert!(!dry_run_enabled(None));
606 }
607
608 #[test]
609 fn status_starts_stopped_without_loaded_session() {
610 let mut manager = PreviewManager::dry_run();
611 let response = manager.status(empty_snapshot());
612
613 assert!(response.ok);
614 assert_eq!(response.state, PreviewState::Stopped);
615 assert_eq!(response.session_revision, None);
616 assert!(!response.stale);
617 }
618
619 #[test]
620 fn default_manager_reports_stopped_without_starting_process() {
621 let mut manager = PreviewManager::default();
622 let response = manager.status(empty_snapshot());
623
624 assert!(response.ok);
625 assert_eq!(response.state, PreviewState::Stopped);
626 }
627
628 #[test]
629 fn dry_run_start_runs_without_pid_and_reports_preview_context() {
630 let mut manager = PreviewManager::dry_run();
631 let response = manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
632
633 assert!(response.ok);
634 assert_eq!(response.state, PreviewState::Running);
635 assert_eq!(response.pid, None);
636 assert_eq!(response.graph_id.as_deref(), Some("minimal-value"));
637 assert_eq!(response.graph_revision.as_deref(), Some("1"));
638 assert_eq!(response.session_revision, Some(1));
639 assert_eq!(response.preview_session_revision, Some(1));
640 assert_eq!(response.control_revision, Some(0));
641 assert_eq!(response.preview_control_revision, Some(0));
642 assert!(response.control_live);
643 assert!(response.started_at.unwrap().starts_with("unix-ms:"));
644 assert!(!response.stale);
645 let control_path = manager
646 .status
647 .control_state_path
648 .clone()
649 .expect("control snapshot path should be stored");
650 let snapshot = read_preview_control_state_snapshot(&control_path)
651 .expect("control snapshot should read")
652 .expect("control snapshot should exist");
653 assert_eq!(snapshot.session_revision, 1);
654 assert_eq!(snapshot.control_revision, 0);
655 }
656
657 #[test]
658 fn dry_run_telemetry_reports_active_render_with_synthetic_heartbeat() {
659 let mut manager = PreviewManager::dry_run();
660 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
661
662 let telemetry = manager.telemetry(loaded_snapshot(1, "1"), 120);
663
664 assert!(telemetry.ok);
665 assert_eq!(telemetry.preview.state, PreviewState::Running);
666 assert!(telemetry.render.active);
667 assert_eq!(telemetry.render.backend.as_deref(), Some("dry-run"));
668 assert_eq!(telemetry.render.renderer.as_deref(), Some("clear-color"));
669 assert_eq!(telemetry.render.control_revision, Some(0));
670 assert_eq!(telemetry.render.preview_control_revision, Some(0));
671 assert!(telemetry.render.control_live);
672 assert_eq!(telemetry.process.uptime_ms, 120);
673 }
674
675 #[test]
676 fn control_snapshot_update_refreshes_running_dry_run_preview() {
677 let mut manager = PreviewManager::dry_run();
678 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
679 let mut control_state = ControlState::default();
680 control_state.channels.insert(
681 "number.float:speed".to_owned(),
682 crate::ControlMessage::from_value(crate::ControlValue::float(0.8)),
683 );
684 let snapshot = PreviewControlStateSnapshot::new(1, 3, &control_state);
685
686 manager
687 .update_control_state(snapshot.clone())
688 .expect("control snapshot should update");
689 let control_path = manager
690 .status
691 .control_state_path
692 .clone()
693 .expect("control snapshot path should exist");
694 let decoded = read_preview_control_state_snapshot(&control_path)
695 .expect("control snapshot should read")
696 .expect("control snapshot should exist");
697 let telemetry = manager.telemetry(loaded_snapshot(1, "1"), 0);
698
699 assert_eq!(decoded.control_revision, 3);
700 assert_eq!(decoded.channels, snapshot.channels);
701 assert_eq!(telemetry.render.preview_control_revision, Some(3));
702 assert!(telemetry.render.control_live);
703 }
704
705 #[test]
706 fn control_snapshot_update_noops_without_snapshot_path() {
707 let mut manager = PreviewManager::dry_run();
708 let snapshot = PreviewControlStateSnapshot::new(1, 3, &ControlState::default());
709
710 manager
711 .write_control_snapshot(&snapshot)
712 .expect("missing snapshot path should be accepted");
713 }
714
715 #[test]
716 fn start_reports_initial_control_snapshot_write_failure() {
717 let blocker = std::env::temp_dir().join(format!(
718 "skenion-control-snapshot-blocker-{}-{}",
719 std::process::id(),
720 std::time::SystemTime::now()
721 .duration_since(std::time::UNIX_EPOCH)
722 .unwrap()
723 .as_nanos()
724 ));
725 std::fs::write(&blocker, b"blocker").expect("blocker should write");
726 let mut manager = PreviewManager::dry_run()
727 .with_control_state_path_override(blocker.join("control-state.json"));
728
729 let response = manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
730
731 assert!(!response.ok);
732 assert_eq!(response.state, PreviewState::Error);
733 assert!(response.diagnostics[0].severity == crate::DiagnosticSeverity::Error);
734 assert_eq!(
735 response.message,
736 Some(response.diagnostics[0].message.clone())
737 );
738 std::fs::remove_file(blocker).expect("blocker should remove");
739 }
740
741 #[test]
742 fn dry_run_heartbeat_write_failure_is_reported_on_status() {
743 let blocker = std::env::temp_dir().join(format!(
744 "skenion-dry-run-heartbeat-blocker-{}-{}",
745 std::process::id(),
746 std::time::SystemTime::now()
747 .duration_since(std::time::UNIX_EPOCH)
748 .unwrap()
749 .as_nanos()
750 ));
751 std::fs::write(&blocker, b"blocker").expect("blocker should write");
752 let mut status = PreviewStatus {
753 state: PreviewState::Starting,
754 pid: None,
755 graph_id: Some("minimal-value".to_owned()),
756 graph_revision: Some("1".to_owned()),
757 preview_session_revision: Some(1),
758 preview_control_revision: Some(0),
759 last_control_update_at: None,
760 started_at: None,
761 exited_at: None,
762 exit_code: None,
763 message: None,
764 telemetry_path: Some(blocker.join("telemetry.json")),
765 control_state_path: None,
766 document_path: None,
767 };
768 let document = PreviewDocument::new(graph("1"), plan("1"), 1);
769
770 record_dry_run_heartbeat(&mut status, &document, None);
771
772 assert!(
773 status
774 .message
775 .as_deref()
776 .unwrap()
777 .contains("failed to write dry-run preview telemetry")
778 );
779 std::fs::remove_file(blocker).expect("blocker should remove");
780 }
781
782 #[test]
783 fn dry_run_heartbeat_reports_fullscreen_shader_renderer() {
784 let document = PreviewDocument::new(shader_graph("7"), shader_plan("7"), 7);
785
786 let heartbeat = dry_run_heartbeat(&document, None);
787
788 assert_eq!(heartbeat.backend, "dry-run");
789 assert_eq!(heartbeat.renderer, "fullscreen-shader");
790 assert_eq!(heartbeat.source_node_id.as_deref(), Some("shader_1"));
791 assert_eq!(heartbeat.graph_revision, "7");
792 assert!(heartbeat.generated_source_available);
793 assert!(heartbeat.diagnostics.is_empty());
794 }
795
796 #[test]
797 fn dry_run_heartbeat_reports_scene_errors() {
798 let mut graph = shader_graph("8");
799 graph.nodes[0]
800 .params
801 .insert("language".to_owned(), json!("glsl"));
802 let document = PreviewDocument::new(graph, shader_plan("8"), 8);
803
804 let heartbeat = dry_run_heartbeat(&document, None);
805
806 assert_eq!(heartbeat.renderer, "clear-color");
807 assert_eq!(heartbeat.backend, "dry-run");
808 assert!(
809 heartbeat
810 .last_error
811 .as_deref()
812 .unwrap()
813 .contains("unsupported language glsl")
814 );
815 assert_eq!(
816 heartbeat.diagnostics[0].phase,
817 crate::ShaderDiagnosticPhase::SourceSync
818 );
819 assert!(!heartbeat.generated_source_available);
820 }
821
822 #[test]
823 fn start_without_context_returns_diagnostics() {
824 let mut manager = PreviewManager::dry_run();
825 let response = manager.start(
826 Err(vec![RuntimeDiagnostic::error("no project loaded")]),
827 empty_snapshot(),
828 false,
829 );
830
831 assert!(!response.ok);
832 assert_eq!(response.state, PreviewState::Stopped);
833 assert!(
834 response.diagnostics[0]
835 .message
836 .contains("no project loaded")
837 );
838 }
839
840 #[test]
841 fn second_start_without_restart_keeps_current_preview() {
842 let mut manager = PreviewManager::dry_run();
843 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
844
845 let response = manager.start(Ok(context(2)), loaded_snapshot(2, "2"), false);
846
847 assert!(response.ok);
848 assert_eq!(response.state, PreviewState::Running);
849 assert_eq!(response.graph_revision.as_deref(), Some("1"));
850 assert_eq!(response.preview_session_revision, Some(1));
851 assert!(response.stale);
852 }
853
854 #[test]
855 fn telemetry_marks_preview_stale_after_session_revision_changes() {
856 let mut manager = PreviewManager::dry_run();
857 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
858
859 let telemetry = manager.telemetry(loaded_snapshot(2, "2"), 0);
860
861 assert_eq!(telemetry.session.session_revision, 2);
862 assert_eq!(telemetry.preview.preview_session_revision, Some(1));
863 assert!(telemetry.preview.stale);
864 }
865
866 #[test]
867 fn restart_replaces_preview_context() {
868 let mut manager = PreviewManager::dry_run();
869 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
870
871 let response = manager.restart(Ok(context(2)), loaded_snapshot(2, "2"));
872
873 assert!(response.ok);
874 assert_eq!(response.state, PreviewState::Running);
875 assert_eq!(response.graph_revision.as_deref(), Some("2"));
876 assert_eq!(response.preview_session_revision, Some(2));
877 assert!(!response.stale);
878 }
879
880 #[test]
881 fn stop_clears_preview_state() {
882 let mut manager = PreviewManager::dry_run();
883 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
884
885 let response = manager.stop(loaded_snapshot(1, "1"));
886
887 assert!(response.ok);
888 assert_eq!(response.state, PreviewState::Stopped);
889 assert_eq!(response.graph_id, None);
890 assert_eq!(response.preview_session_revision, None);
891 assert!(!response.stale);
892 }
893
894 #[test]
895 fn fake_spawn_reports_pid_and_can_exit_on_status_poll() {
896 let mut manager = PreviewManager::with_test_spawner(false, spawn_exiting_handle);
897 let started = manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
898 assert_eq!(started.state, PreviewState::Running);
899 assert_eq!(started.pid, Some(42));
900
901 let exited = manager.status(loaded_snapshot(1, "1"));
902 assert_eq!(exited.state, PreviewState::Exited);
903 assert_eq!(exited.pid, None);
904 assert_eq!(exited.exit_code, Some(0));
905 assert_eq!(exited.message.as_deref(), Some("preview process exited"));
906 }
907
908 #[test]
909 fn telemetry_reads_native_heartbeat_file() {
910 let mut manager = PreviewManager::with_test_spawner(false, spawn_heartbeat_handle);
911 manager.start(Ok(context(41)), loaded_snapshot(41, "1"), false);
912
913 let telemetry = manager.telemetry(loaded_snapshot(41, "1"), 0);
914
915 assert_eq!(telemetry.render.backend.as_deref(), Some("wgpu"));
916 assert_eq!(telemetry.render.renderer.as_deref(), Some("clear-color"));
917 assert_eq!(telemetry.render.frames_rendered, 3);
918 assert_eq!(telemetry.render.source_node_id.as_deref(), Some("clear_1"));
919 }
920
921 #[test]
922 fn telemetry_reports_invalid_heartbeat_as_warning() {
923 let mut manager = PreviewManager::with_test_spawner(false, spawn_invalid_heartbeat_handle);
924 manager.start(Ok(context(42)), loaded_snapshot(42, "1"), false);
925
926 let telemetry = manager.telemetry(loaded_snapshot(42, "1"), 0);
927
928 assert!(telemetry.ok);
929 assert_eq!(
930 telemetry.diagnostics[0].severity,
931 crate::DiagnosticSeverity::Warning
932 );
933 assert!(
934 telemetry.diagnostics[0]
935 .message
936 .contains("invalid preview telemetry heartbeat")
937 );
938 assert_eq!(telemetry.render.frames_rendered, 0);
939 }
940
941 #[test]
942 fn starting_state_is_promoted_to_running_when_handle_is_alive() {
943 let mut manager = PreviewManager::with_test_spawner(false, spawn_running_handle);
944 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
945 manager.status.state = PreviewState::Starting;
946
947 let response = manager.status(loaded_snapshot(1, "1"));
948
949 assert_eq!(response.state, PreviewState::Running);
950 }
951
952 #[test]
953 fn fake_spawn_failure_reports_error_state() {
954 let mut manager = PreviewManager::with_test_spawner(false, spawn_failure);
955 let response = manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
956
957 assert!(!response.ok);
958 assert_eq!(response.state, PreviewState::Error);
959 assert_eq!(response.message.as_deref(), Some("spawn failed"));
960 assert_eq!(response.diagnostics[0].message, "spawn failed");
961 }
962
963 #[test]
964 fn handle_poll_error_reports_error_state() {
965 let mut manager = PreviewManager::with_test_spawner(false, spawn_erroring_handle);
966 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
967
968 let response = manager.status(loaded_snapshot(1, "1"));
969
970 assert_eq!(response.state, PreviewState::Error);
971 assert_eq!(response.message.as_deref(), Some("poll failed"));
972 }
973
974 #[test]
975 fn stop_failure_returns_diagnostic() {
976 let mut manager = PreviewManager::with_test_spawner(false, spawn_unstoppable_handle);
977 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
978
979 let response = manager.stop(loaded_snapshot(1, "1"));
980
981 assert!(!response.ok);
982 assert_eq!(response.state, PreviewState::Error);
983 assert_eq!(response.diagnostics[0].message, "stop failed");
984 }
985
986 #[test]
987 fn fake_handle_stop_success_returns_stopped_state() {
988 let mut manager = PreviewManager::with_test_spawner(false, spawn_running_handle);
989 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
990
991 let response = manager.stop(loaded_snapshot(1, "1"));
992
993 assert!(response.ok);
994 assert_eq!(response.state, PreviewState::Stopped);
995 }
996
997 #[test]
998 fn stop_removes_current_preview_document_and_telemetry_files() {
999 let mut manager = PreviewManager::with_test_spawner(false, spawn_temp_file_handle);
1000 manager.start(Ok(context(1)), loaded_snapshot(1, "1"), false);
1001 let document_path = manager
1002 .status
1003 .document_path
1004 .clone()
1005 .expect("document path should be stored");
1006 let telemetry_path = manager
1007 .status
1008 .telemetry_path
1009 .clone()
1010 .expect("telemetry path should be stored");
1011 let control_state_path = manager
1012 .status
1013 .control_state_path
1014 .clone()
1015 .expect("control state path should be stored");
1016 assert!(document_path.exists());
1017 assert!(telemetry_path.exists());
1018 assert!(control_state_path.exists());
1019
1020 let response = manager.stop(loaded_snapshot(1, "1"));
1021
1022 assert!(response.ok);
1023 assert!(!document_path.exists());
1024 assert!(!telemetry_path.exists());
1025 assert!(!control_state_path.exists());
1026 }
1027
1028 #[test]
1029 fn start_request_defaults_restart_to_false() {
1030 let request: RuntimePreviewStartRequest =
1031 serde_json::from_value(json!({})).expect("request should deserialize");
1032
1033 assert!(!request.restart);
1034 }
1035
1036 fn spawn_exiting_handle(
1037 document: &PreviewDocument,
1038 telemetry_path: &Path,
1039 control_state_path: &Path,
1040 ) -> Result<PreviewSpawn, String> {
1041 assert_eq!(document.plan.graph_id, "minimal-value");
1042 assert_eq!(document.graph.id, "minimal-value");
1043 assert_eq!(document.session_revision, 1);
1044 assert!(
1045 telemetry_path
1046 .file_name()
1047 .unwrap()
1048 .to_string_lossy()
1049 .contains("telemetry")
1050 );
1051 assert!(
1052 control_state_path
1053 .file_name()
1054 .unwrap()
1055 .to_string_lossy()
1056 .contains("control-state")
1057 );
1058 Ok(spawn(FakePreviewHandle::new(Some(0), None, None)))
1059 }
1060
1061 fn spawn_running_handle(
1062 _document: &PreviewDocument,
1063 _telemetry_path: &Path,
1064 _control_state_path: &Path,
1065 ) -> Result<PreviewSpawn, String> {
1066 Ok(spawn(FakePreviewHandle::new(None, None, None)))
1067 }
1068
1069 fn spawn_erroring_handle(
1070 _document: &PreviewDocument,
1071 _telemetry_path: &Path,
1072 _control_state_path: &Path,
1073 ) -> Result<PreviewSpawn, String> {
1074 Ok(spawn(FakePreviewHandle::new(
1075 None,
1076 Some("poll failed"),
1077 None,
1078 )))
1079 }
1080
1081 fn spawn_unstoppable_handle(
1082 _document: &PreviewDocument,
1083 _telemetry_path: &Path,
1084 _control_state_path: &Path,
1085 ) -> Result<PreviewSpawn, String> {
1086 Ok(spawn(FakePreviewHandle::new(
1087 None,
1088 None,
1089 Some("stop failed"),
1090 )))
1091 }
1092
1093 fn spawn_failure(
1094 _document: &PreviewDocument,
1095 _telemetry_path: &Path,
1096 _control_state_path: &Path,
1097 ) -> Result<PreviewSpawn, String> {
1098 Err("spawn failed".to_owned())
1099 }
1100
1101 fn spawn_heartbeat_handle(
1102 document: &PreviewDocument,
1103 telemetry_path: &Path,
1104 _control_state_path: &Path,
1105 ) -> Result<PreviewSpawn, String> {
1106 write_preview_telemetry_heartbeat(
1107 telemetry_path,
1108 &PreviewTelemetryHeartbeat {
1109 schema: PREVIEW_TELEMETRY_SCHEMA.to_owned(),
1110 schema_version: PREVIEW_TELEMETRY_SCHEMA_VERSION.to_owned(),
1111 timestamp: "unix-ms:1".to_owned(),
1112 pid: 42,
1113 graph_id: document.graph.id.clone(),
1114 graph_revision: document.graph.revision.clone(),
1115 session_revision: document.session_revision,
1116 renderer: "clear-color".to_owned(),
1117 backend: "wgpu".to_owned(),
1118 frames_rendered: 3,
1119 approx_fps: Some(60.0),
1120 last_frame_ms: Some(16.7),
1121 last_error: None,
1122 source_node_id: Some("clear_1".to_owned()),
1123 diagnostics: Vec::new(),
1124 generated_source_available: false,
1125 control_revision: Some(0),
1126 preview_control_revision: Some(0),
1127 control_live: true,
1128 last_control_update_at: Some("unix-ms:1".to_owned()),
1129 },
1130 )
1131 .expect("test heartbeat should write");
1132 Ok(spawn(FakePreviewHandle::new(None, None, None)))
1133 }
1134
1135 fn spawn_invalid_heartbeat_handle(
1136 _document: &PreviewDocument,
1137 telemetry_path: &Path,
1138 _control_state_path: &Path,
1139 ) -> Result<PreviewSpawn, String> {
1140 if let Some(parent) = telemetry_path.parent() {
1141 std::fs::create_dir_all(parent).expect("invalid heartbeat parent should create");
1142 }
1143 std::fs::write(telemetry_path, b"{").expect("invalid heartbeat should write");
1144 Ok(spawn(FakePreviewHandle::new(None, None, None)))
1145 }
1146
1147 fn spawn_temp_file_handle(
1148 document: &PreviewDocument,
1149 telemetry_path: &Path,
1150 control_state_path: &Path,
1151 ) -> Result<PreviewSpawn, String> {
1152 if let Some(parent) = telemetry_path.parent() {
1153 std::fs::create_dir_all(parent).expect("preview temp parent should create");
1154 }
1155 std::fs::write(telemetry_path, b"{}").expect("telemetry temp file should write");
1156 std::fs::write(control_state_path, b"{}").expect("control state temp file should write");
1157 let document_path = telemetry_path
1158 .parent()
1159 .expect("telemetry path should have parent")
1160 .join(format!(
1161 "preview-document-test-{}.json",
1162 document.session_revision
1163 ));
1164 std::fs::write(&document_path, b"{}").expect("document temp file should write");
1165 Ok(PreviewSpawn::new(
1166 Box::new(FakePreviewHandle::new(None, None, None)),
1167 Some(document_path),
1168 ))
1169 }
1170
1171 fn spawn(handle: FakePreviewHandle) -> PreviewSpawn {
1172 PreviewSpawn::new(Box::new(handle), None)
1173 }
1174
1175 struct FakePreviewHandle {
1176 exit_code: Option<i32>,
1177 poll_error: Option<&'static str>,
1178 stop_error: Option<&'static str>,
1179 }
1180
1181 impl FakePreviewHandle {
1182 fn new(
1183 exit_code: Option<i32>,
1184 poll_error: Option<&'static str>,
1185 stop_error: Option<&'static str>,
1186 ) -> Self {
1187 Self {
1188 exit_code,
1189 poll_error,
1190 stop_error,
1191 }
1192 }
1193 }
1194
1195 impl PreviewHandle for FakePreviewHandle {
1196 fn pid(&self) -> Option<u32> {
1197 Some(42)
1198 }
1199
1200 fn try_wait(&mut self) -> Result<Option<i32>, String> {
1201 match self.poll_error {
1202 Some(error) => Err(error.to_owned()),
1203 None => Ok(self.exit_code),
1204 }
1205 }
1206
1207 fn stop(&mut self) -> Result<Option<i32>, String> {
1208 match self.stop_error {
1209 Some(error) => Err(error.to_owned()),
1210 None => Ok(Some(0)),
1211 }
1212 }
1213 }
1214
1215 fn context(session_revision: u64) -> PreviewContext {
1216 let graph = graph(&session_revision.to_string());
1217 let control_state = ControlState::from_graph(&graph);
1218 PreviewContext {
1219 graph_id: "minimal-value".to_owned(),
1220 graph_revision: session_revision.to_string(),
1221 session_revision,
1222 control_revision: 0,
1223 graph,
1224 plan: plan(&session_revision.to_string()),
1225 control_state,
1226 }
1227 }
1228
1229 fn graph(graph_revision: &str) -> GraphDocument {
1230 GraphDocument {
1231 schema: "skenion.graph".to_owned(),
1232 schema_version: "0.1.0".to_owned(),
1233 id: "minimal-value".to_owned(),
1234 revision: graph_revision.to_owned(),
1235 nodes: vec![GraphNode {
1236 id: "value_1".to_owned(),
1237 kind: "core.float".to_owned(),
1238 kind_version: "0.1.0".to_owned(),
1239 params: serde_json::Map::new(),
1240 ports: Vec::new(),
1241 }],
1242 edges: Vec::new(),
1243 }
1244 }
1245
1246 fn plan(graph_revision: &str) -> ExecutionPlan {
1247 ExecutionPlan {
1248 graph_id: "minimal-value".to_owned(),
1249 graph_revision: graph_revision.to_owned(),
1250 nodes: vec![PlanNode {
1251 node_id: "value_1".to_owned(),
1252 kind: "core.float".to_owned(),
1253 kind_version: "0.1.0".to_owned(),
1254 execution_model: ExecutionModel::Value,
1255 order: 0,
1256 }],
1257 edges: vec![PlanEdge {
1258 from_node: "value_1".to_owned(),
1259 from_port: "out".to_owned(),
1260 to_node: "target_1".to_owned(),
1261 to_port: "in".to_owned(),
1262 metadata: None,
1263 }],
1264 groups: vec![ExecutionGroup {
1265 execution_model: ExecutionModel::Value,
1266 node_ids: vec!["value_1".to_owned()],
1267 }],
1268 }
1269 }
1270
1271 fn shader_graph(graph_revision: &str) -> GraphDocument {
1272 let mut params = serde_json::Map::new();
1273 params.insert("language".to_owned(), json!("wgsl"));
1274 params.insert("source".to_owned(), json!(shader_source()));
1275 GraphDocument {
1276 schema: "skenion.graph".to_owned(),
1277 schema_version: "0.1.0".to_owned(),
1278 id: "fullscreen-shader".to_owned(),
1279 revision: graph_revision.to_owned(),
1280 nodes: vec![GraphNode {
1281 id: "shader_1".to_owned(),
1282 kind: "render.fullscreen-shader".to_owned(),
1283 kind_version: "0.1.0".to_owned(),
1284 params,
1285 ports: shader_ports(shader_source()),
1286 }],
1287 edges: Vec::new(),
1288 }
1289 }
1290
1291 fn shader_plan(graph_revision: &str) -> ExecutionPlan {
1292 ExecutionPlan {
1293 graph_id: "fullscreen-shader".to_owned(),
1294 graph_revision: graph_revision.to_owned(),
1295 nodes: vec![PlanNode {
1296 node_id: "shader_1".to_owned(),
1297 kind: "render.fullscreen-shader".to_owned(),
1298 kind_version: "0.1.0".to_owned(),
1299 execution_model: ExecutionModel::GpuPass,
1300 order: 0,
1301 }],
1302 edges: Vec::new(),
1303 groups: vec![ExecutionGroup {
1304 execution_model: ExecutionModel::GpuPass,
1305 node_ids: vec!["shader_1".to_owned()],
1306 }],
1307 }
1308 }
1309
1310 fn shader_source() -> &'static str {
1311 r#"// @skenion.uniform speed number.float default=0.5
1312@fragment
1313fn fs_main() -> @location(0) vec4<f32> {
1314 return vec4<f32>(skenion.speed, 0.2, 1.0 - skenion.speed, 1.0);
1315}"#
1316 }
1317
1318 fn shader_ports(source: &str) -> Vec<Port> {
1319 let analysis = crate::analyze_shader_interface_v01(source);
1320 crate::shader_interface_to_ports_v01(&analysis.shader_interface)
1321 }
1322
1323 fn loaded_snapshot(session_revision: u64, graph_revision: &str) -> RuntimeSessionSnapshot {
1324 let graph = graph(graph_revision);
1325 RuntimeSessionSnapshot {
1326 session_revision,
1327 view_revision: 0,
1328 control_revision: 0,
1329 project: Some(project_document(&graph)),
1330 diagnostics: Vec::new(),
1331 plan: Some(plan(graph_revision)),
1332 }
1333 }
1334
1335 fn project_document(graph: &GraphDocument) -> ProjectDocumentCurrent {
1336 serde_json::from_value(json!({
1337 "schema": "skenion.project",
1338 "schemaVersion": "0.1.0",
1339 "id": format!("{}-project", graph.id),
1340 "revision": graph.revision.clone(),
1341 "graph": {
1342 "schema": "skenion.graph",
1343 "schemaVersion": "0.1.0",
1344 "id": graph.id.clone(),
1345 "revision": graph.revision.clone(),
1346 "nodes": graph.nodes.iter().map(|node| json!({
1347 "id": node.id.clone(),
1348 "kind": node.kind.clone(),
1349 "kindVersion": node.kind_version.clone(),
1350 "params": node.params.clone(),
1351 "ports": []
1352 })).collect::<Vec<_>>(),
1353 "edges": []
1354 },
1355 "viewState": default_view_state(graph),
1356 "patchLibrary": []
1357 }))
1358 .expect("runtime test project document should parse")
1359 }
1360
1361 fn default_view_state(graph: &GraphDocument) -> serde_json::Value {
1362 json!({
1363 "schema": "skenion.view-state",
1364 "schemaVersion": "0.1.0",
1365 "canvas": {
1366 "nodes": graph.nodes.iter().enumerate().map(|(index, node)| {
1367 (
1368 node.id.clone(),
1369 json!({
1370 "x": 160.0 * (index as f64),
1371 "y": 0.0
1372 }),
1373 )
1374 }).collect::<serde_json::Map<_, _>>()
1375 }
1376 })
1377 }
1378
1379 fn empty_snapshot() -> RuntimeSessionSnapshot {
1380 RuntimeSessionSnapshot {
1381 project: None,
1382 session_revision: 0,
1383 view_revision: 0,
1384 control_revision: 0,
1385 diagnostics: Vec::new(),
1386 plan: None,
1387 }
1388 }
1389}