Skip to main content

skenion_runtime/
preview_manager.rs

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}