Skip to main content

skenion_runtime/
session.rs

1use std::{
2    collections::{BTreeMap, HashSet},
3    time::{SystemTime, UNIX_EPOCH},
4};
5
6use serde::{Deserialize, Serialize};
7
8use crate::{
9    CanvasNodeView, CanvasViewState, ControlState, DataFlow, DataType, DummyExecutionReport, Edge,
10    EdgeSpecCurrent, ExecutionPlan, GraphDocument, GraphDocumentCurrent,
11    GraphFragmentOutsideEndpointPolicyCurrent, GraphNode, GraphNodeCurrent, GraphPatch,
12    GraphTargetRef, IdConflictPolicy, IdRemapResult, NodeDefinition, NodeDefinitionCurrent,
13    NodeRegistry, PasteGraphFragmentRequest, PasteGraphFragmentResponse, PastePlacement, PatchPath,
14    Port, PortActivation, PortDirection, PortDirectionCurrent, PortRateCurrent, PortRef,
15    PortSpecCurrent, PreviewContext, PreviewControlStateSnapshot, ProjectDocumentCurrent,
16    ProjectRequestCurrent, RuntimeCollaborationChange, RuntimeControlEventRequest,
17    RuntimeControlEventResponse, RuntimeControlReadRequest, RuntimeControlReadResponse,
18    RuntimeControlReadTarget, RuntimeControlStateResponse, RuntimeDiagnostic,
19    RuntimeOperationDiagnostic, RuntimeOperationEnvelope, StringOrStrings, ViewState,
20    build_execution_plan, build_execution_plan_request_current,
21    project_document_validation_diagnostics_current, read_graph_param, read_graph_port,
22    run_dummy_execution, server::registry_from_nodes,
23};
24const UNRESOLVED_OBJECT_NODE_KIND: &str = "core.unresolved-object";
25
26#[derive(Debug, Clone, Serialize)]
27#[serde(rename_all = "camelCase")]
28pub struct RuntimeSessionSnapshot {
29    pub session_revision: u64,
30    pub view_revision: u64,
31    pub control_revision: u64,
32    pub project: Option<ProjectDocumentCurrent>,
33    pub diagnostics: Vec<RuntimeDiagnostic>,
34    pub plan: Option<ExecutionPlan>,
35}
36
37impl RuntimeSessionSnapshot {
38    pub fn loaded(&self) -> bool {
39        self.project.is_some()
40    }
41
42    pub fn graph_id(&self) -> Option<&str> {
43        self.project
44            .as_ref()
45            .map(|project| project.graph.id.as_str())
46    }
47
48    pub fn graph_revision(&self) -> Option<&str> {
49        self.project
50            .as_ref()
51            .map(|project| project.graph.revision.as_str())
52    }
53
54    pub fn view_state(&self) -> Option<&ViewState> {
55        self.project.as_ref().map(|project| &project.view_state)
56    }
57}
58
59#[derive(Debug, Clone, Serialize)]
60#[serde(rename_all = "camelCase")]
61pub struct RuntimeSessionResponse {
62    pub ok: bool,
63    pub snapshot: RuntimeSessionSnapshot,
64    pub diagnostics: Vec<RuntimeDiagnostic>,
65    pub report: Option<DummyExecutionReport>,
66}
67
68#[derive(Debug, Clone, Serialize)]
69#[serde(rename_all = "camelCase")]
70pub struct RuntimePatchResponse {
71    pub ok: bool,
72    pub applied: bool,
73    pub conflict: bool,
74    pub snapshot: RuntimeSessionSnapshot,
75    pub history: RuntimeHistory,
76    pub diagnostics: Vec<RuntimeDiagnostic>,
77}
78
79#[derive(Debug, Clone, Deserialize)]
80#[serde(rename_all = "camelCase")]
81pub struct SessionRunRequest {
82    pub frames: Option<usize>,
83}
84
85#[derive(Debug, Clone, Deserialize, Serialize)]
86#[serde(rename_all = "camelCase")]
87pub struct RuntimeMutationRequest {
88    #[serde(default)]
89    #[serde(skip_serializing_if = "Option::is_none")]
90    pub(crate) graph_patch: Option<GraphPatch>,
91    #[serde(default)]
92    #[serde(skip_serializing_if = "Option::is_none")]
93    pub view_patch: Option<RuntimeViewPatch>,
94    #[serde(skip)]
95    pub actor_id: Option<String>,
96    #[serde(default)]
97    #[serde(skip_serializing_if = "Option::is_none")]
98    pub client_id: Option<String>,
99    #[serde(default)]
100    #[serde(skip_serializing_if = "Option::is_none")]
101    pub description: Option<String>,
102}
103
104impl RuntimeMutationRequest {
105    pub fn view_patch(view_patch: RuntimeViewPatch) -> Self {
106        Self {
107            graph_patch: None,
108            view_patch: Some(view_patch),
109            actor_id: None,
110            client_id: None,
111            description: None,
112        }
113    }
114
115    pub fn with_client_id(mut self, client_id: impl Into<String>) -> Self {
116        self.client_id = Some(client_id.into());
117        self
118    }
119
120    pub fn with_description(mut self, description: impl Into<String>) -> Self {
121        self.description = Some(description.into());
122        self
123    }
124}
125
126#[derive(Debug, Clone, Deserialize, Serialize)]
127#[serde(rename_all = "camelCase")]
128pub struct RuntimeViewPatch {
129    pub base_view_revision: u64,
130    pub ops: Vec<RuntimeViewPatchOperation>,
131}
132
133#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
134#[serde(tag = "op")]
135pub enum RuntimeViewPatchOperation {
136    #[serde(rename = "setNodeView")]
137    SetNodeView {
138        #[serde(rename = "nodeId")]
139        node_id: String,
140        view: CanvasNodeView,
141    },
142    #[serde(rename = "moveNodeView")]
143    MoveNodeView {
144        #[serde(rename = "nodeId")]
145        node_id: String,
146        #[serde(default)]
147        from: Option<CanvasNodeView>,
148        to: CanvasNodeView,
149    },
150}
151
152#[derive(Debug, Clone, Serialize)]
153#[serde(rename_all = "camelCase")]
154pub struct RuntimeHistory {
155    pub schema: &'static str,
156    pub schema_version: &'static str,
157    pub entries: Vec<RuntimeHistoryEntry>,
158    pub can_undo: bool,
159    pub can_redo: bool,
160    pub undo_depth: u64,
161    pub redo_depth: u64,
162}
163
164#[derive(Debug, Clone, Serialize)]
165#[serde(rename_all = "camelCase")]
166pub struct RuntimeHistoryEntry {
167    pub id: String,
168    pub sequence: u64,
169    pub kind: RuntimeHistoryEntryKind,
170    pub mutation: RuntimeMutationRequest,
171    pub inverse_mutation: RuntimeMutationRequest,
172    #[serde(skip_serializing_if = "Option::is_none")]
173    pub subject_event_id: Option<String>,
174    #[serde(skip)]
175    pub actor_id: Option<String>,
176    #[serde(skip_serializing_if = "Option::is_none")]
177    pub client_id: Option<String>,
178    #[serde(skip_serializing_if = "Option::is_none")]
179    pub description: Option<String>,
180    pub created_at: String,
181}
182
183#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
184#[serde(rename_all = "lowercase")]
185pub enum RuntimeHistoryEntryKind {
186    Apply,
187    Undo,
188    Redo,
189}
190
191#[derive(Debug)]
192pub struct RuntimeSession {
193    project: Option<ProjectDocumentCurrent>,
194    nodes_current: Vec<NodeDefinitionCurrent>,
195    graph: Option<GraphDocument>,
196    registry: Option<NodeRegistry>,
197    plan: Option<ExecutionPlan>,
198    view_state: Option<ViewState>,
199    control_state: ControlState,
200    diagnostics: Vec<RuntimeDiagnostic>,
201    revision: u64,
202    view_revision: u64,
203    control_revision: u64,
204    history_entries: Vec<RuntimeHistoryEntry>,
205    undo_stack: Vec<HistoryEntry>,
206    redo_stack: Vec<HistoryEntry>,
207    next_event_sequence: u64,
208}
209
210impl Default for RuntimeSession {
211    fn default() -> Self {
212        Self {
213            project: None,
214            nodes_current: Vec::new(),
215            graph: None,
216            registry: None,
217            plan: None,
218            view_state: None,
219            control_state: ControlState::default(),
220            diagnostics: Vec::new(),
221            revision: 0,
222            view_revision: 0,
223            control_revision: 0,
224            history_entries: Vec::new(),
225            undo_stack: Vec::new(),
226            redo_stack: Vec::new(),
227            next_event_sequence: 1,
228        }
229    }
230}
231
232#[derive(Debug, Clone)]
233enum HistoryEntry {
234    Mutation {
235        event_id: String,
236        actor_id: Option<String>,
237        mutation: RuntimeMutationRequest,
238        inverse_mutation: RuntimeMutationRequest,
239    },
240    ProjectDocument {
241        event_id: String,
242        actor_id: Option<String>,
243        before: Box<ProjectDocumentCurrent>,
244        after: Box<ProjectDocumentCurrent>,
245        before_view_revision: u64,
246        after_view_revision: u64,
247        mutation: RuntimeMutationRequest,
248        inverse_mutation: RuntimeMutationRequest,
249    },
250}
251
252impl HistoryEntry {
253    fn actor_id(&self) -> Option<&str> {
254        match self {
255            Self::Mutation { actor_id, .. } => actor_id.as_deref(),
256            Self::ProjectDocument { actor_id, .. } => actor_id.as_deref(),
257        }
258    }
259}
260
261struct HistoryApplyOutcome {
262    applied: bool,
263    response: RuntimePatchResponse,
264}
265
266impl HistoryApplyOutcome {
267    fn applied(response: RuntimePatchResponse) -> Self {
268        Self {
269            applied: true,
270            response,
271        }
272    }
273
274    fn rejected(response: RuntimePatchResponse) -> Self {
275        Self {
276            applied: false,
277            response,
278        }
279    }
280}
281
282impl RuntimeSession {
283    pub fn snapshot(&self) -> RuntimeSessionSnapshot {
284        RuntimeSessionSnapshot {
285            session_revision: self.revision,
286            view_revision: self.view_revision,
287            control_revision: self.control_revision,
288            project: self.project.clone(),
289            diagnostics: self.diagnostics.clone(),
290            plan: self.plan.clone(),
291        }
292    }
293
294    pub(crate) fn preview_context(&self) -> Result<PreviewContext, Vec<RuntimeDiagnostic>> {
295        let Some(graph) = &self.graph else {
296            return Err(vec![RuntimeDiagnostic::error(
297                "no project loaded in runtime session",
298            )]);
299        };
300        let Some(plan) = &self.plan else {
301            return Err(vec![RuntimeDiagnostic::error(
302                "no execution plan available in runtime session",
303            )]);
304        };
305
306        Ok(PreviewContext {
307            graph_id: graph.id.clone(),
308            graph_revision: graph.revision.clone(),
309            session_revision: self.revision,
310            control_revision: self.control_revision,
311            graph: graph.clone(),
312            plan: plan.clone(),
313            control_state: self.control_state.clone(),
314        })
315    }
316
317    pub fn load_project_current(
318        &mut self,
319        request: ProjectRequestCurrent,
320    ) -> RuntimeSessionResponse {
321        let document = project_document_from_request_current(&request);
322        if let Err(report) = skenion_contracts::validate_project_document_v01(&document) {
323            let diagnostics = project_document_validation_diagnostics_current(&document, &report);
324            return self.response(false, diagnostics, None);
325        }
326
327        let (plan, mut diagnostics) = match build_execution_plan_request_current(&request) {
328            Ok(result) => result,
329            Err(diagnostics) => return self.response(false, diagnostics, None),
330        };
331        diagnostics.extend(unresolved_object_diagnostics_current(&document.graph));
332
333        let graph = lower_graph_for_execution(&document.graph);
334        let lowered_nodes = request
335            .nodes
336            .iter()
337            .map(lower_node_definition_for_execution)
338            .collect::<Vec<_>>();
339        let registry = match registry_from_nodes(lowered_nodes) {
340            Ok(registry) => registry,
341            Err(diagnostics) => return self.response(false, diagnostics, None),
342        };
343        let control_state = ControlState::from_graph(&graph);
344        let view_state = reconcile_view_state_with_graph_current(
345            &document.graph,
346            Some(document.view_state.clone()),
347        );
348        self.project = Some(document);
349        self.nodes_current = request.nodes;
350        self.graph = Some(graph);
351        self.registry = Some(registry);
352        self.plan = Some(plan);
353        self.view_state = Some(view_state);
354        self.control_state = control_state;
355        self.view_revision = 1;
356        self.control_revision = 0;
357        self.diagnostics = diagnostics.clone();
358        self.clear_history();
359        self.revision += 1;
360
361        self.response(true, diagnostics, None)
362    }
363
364    pub fn validate_current(&mut self) -> RuntimeSessionResponse {
365        let diagnostics = match self.current_project_request_current() {
366            Some(request) => match crate::validate_project_request_current(&request) {
367                Ok((mut diagnostics, _)) => {
368                    diagnostics.extend(unresolved_object_diagnostics_current(&request.graph));
369                    diagnostics
370                }
371                Err(diagnostics) => diagnostics,
372            },
373            None => vec![RuntimeDiagnostic::error(
374                "no project loaded in runtime session",
375            )],
376        };
377        let ok = diagnostics
378            .iter()
379            .all(|diagnostic| diagnostic.severity != crate::DiagnosticSeverity::Error);
380        self.diagnostics = diagnostics.clone();
381        self.response(ok, diagnostics, None)
382    }
383
384    pub fn plan_current(&mut self) -> RuntimeSessionResponse {
385        let request = match self.current_project_request_current() {
386            Some(request) => request,
387            None => {
388                let diagnostics = vec![RuntimeDiagnostic::error(
389                    "no project loaded in runtime session",
390                )];
391                self.diagnostics = diagnostics.clone();
392                return self.response(false, diagnostics, None);
393            }
394        };
395
396        match build_execution_plan_request_current(&request) {
397            Ok((plan, mut diagnostics)) => {
398                diagnostics.extend(unresolved_object_diagnostics_current(&request.graph));
399                self.plan = Some(plan);
400                self.diagnostics = diagnostics.clone();
401                self.response(true, diagnostics, None)
402            }
403            Err(diagnostics) => {
404                self.diagnostics = diagnostics.clone();
405                self.plan = None;
406                self.response(false, diagnostics, None)
407            }
408        }
409    }
410
411    pub fn run_current(&mut self, frames: usize) -> RuntimeSessionResponse {
412        if self.loaded_project().is_none() {
413            let diagnostics = vec![RuntimeDiagnostic::error(
414                "no project loaded in runtime session",
415            )];
416            self.diagnostics = diagnostics.clone();
417            return self.response(false, diagnostics, None);
418        }
419
420        if self.plan.is_none() {
421            let response = self.plan_current();
422            if !response.ok {
423                return response;
424            }
425        }
426
427        let report = self
428            .plan
429            .as_ref()
430            .map(|plan| run_dummy_execution(plan, frames));
431        self.response(true, self.diagnostics.clone(), report)
432    }
433
434    pub fn apply_mutation(&mut self, mutation: RuntimeMutationRequest) -> RuntimePatchResponse {
435        self.apply_mutation_with_history(mutation, RuntimeHistoryEntryKind::Apply, None)
436    }
437
438    #[cfg(test)]
439    pub(crate) fn apply_patch(&mut self, patch: GraphPatch) -> RuntimePatchResponse {
440        self.apply_mutation(RuntimeMutationRequest {
441            graph_patch: Some(patch),
442            view_patch: None,
443            actor_id: None,
444            client_id: None,
445            description: None,
446        })
447    }
448
449    pub fn apply_runtime_operation(
450        &mut self,
451        envelope: RuntimeOperationEnvelope,
452    ) -> PasteGraphFragmentResponse {
453        let target = envelope.request.target.clone();
454        if let Err(report) = skenion_contracts::validate_runtime_operation_envelope(&envelope) {
455            return self.reject_paste_response(
456                target,
457                false,
458                operation_diagnostics_from_validation_report(report.to_string()),
459                IdRemapResult {
460                    node_id_map: BTreeMap::new(),
461                    edge_id_map: BTreeMap::new(),
462                    omitted_edge_ids: Vec::new(),
463                },
464            );
465        }
466
467        self.paste_graph_fragment(envelope)
468    }
469
470    pub fn apply_collaboration_change_set_current(
471        &mut self,
472        target: GraphTargetRef,
473        changes: Vec<RuntimeCollaborationChange>,
474        actor_id: Option<String>,
475        client_id: Option<String>,
476        description: Option<String>,
477    ) -> RuntimePatchResponse {
478        let Some(project) = self.project.as_ref().cloned() else {
479            return self.patch_response(
480                false,
481                false,
482                false,
483                vec![RuntimeDiagnostic::structured_error(
484                    "collaboration.target.no-project",
485                    "no project loaded in runtime session",
486                    serde_json::json!({ "target": target }),
487                )],
488            );
489        };
490        let target_revision = match target_graph_revision_current(&project, &target) {
491            Ok(revision) => revision,
492            Err(diagnostic) => {
493                return self.patch_response(
494                    false,
495                    false,
496                    false,
497                    vec![operation_diagnostic_to_runtime_diagnostic(*diagnostic)],
498                );
499            }
500        };
501        if target.base_revision != target_revision {
502            return self.patch_response(
503                false,
504                false,
505                true,
506                vec![RuntimeDiagnostic::structured_error(
507                    "collaboration.revision-conflict",
508                    format!(
509                        "target baseRevision {} does not match target graph revision {}",
510                        target.base_revision, target_revision
511                    ),
512                    serde_json::json!({
513                        "expectedRevision": target.base_revision,
514                        "actualRevision": target_revision,
515                        "target": target,
516                    }),
517                )],
518            );
519        }
520
521        let (next_project, next_view_revision) =
522            match apply_collaboration_changes_to_project_current(
523                project.clone(),
524                self.view_revision,
525                &target,
526                &changes,
527            ) {
528                Ok(result) => result,
529                Err(diagnostics) => {
530                    return self.patch_response(false, false, false, diagnostics);
531                }
532            };
533        self.apply_project_document_update(
534            project,
535            next_project,
536            next_view_revision,
537            RuntimeMutationRequest {
538                graph_patch: None,
539                view_patch: None,
540                actor_id,
541                client_id,
542                description,
543            },
544            None,
545        )
546    }
547
548    pub fn history(&self) -> RuntimeHistory {
549        RuntimeHistory {
550            schema: "skenion.runtime.history",
551            schema_version: "0.1.0",
552            entries: self.history_entries.clone(),
553            can_undo: !self.undo_stack.is_empty(),
554            can_redo: !self.redo_stack.is_empty(),
555            undo_depth: self.undo_stack.len() as u64,
556            redo_depth: self.redo_stack.len() as u64,
557        }
558    }
559
560    pub fn undo(&mut self) -> RuntimePatchResponse {
561        let Some(entry) = self.undo_stack.pop() else {
562            return self.patch_response(
563                false,
564                false,
565                false,
566                vec![RuntimeDiagnostic::error("no patch event available to undo")],
567            );
568        };
569        let outcome = self.apply_history_entry(entry.clone(), HistoryDirection::Undo);
570        if outcome.applied {
571            let response = outcome.response;
572            self.redo_stack.push(entry);
573            self.patch_response(true, true, false, response.diagnostics)
574        } else {
575            let response = outcome.response;
576            self.undo_stack.push(entry);
577            self.patch_response(false, false, response.conflict, response.diagnostics)
578        }
579    }
580
581    pub fn undo_for_actor(&mut self, actor_id: &str) -> RuntimePatchResponse {
582        let Some(index) = self
583            .undo_stack
584            .iter()
585            .rposition(|entry| entry.actor_id() == Some(actor_id))
586        else {
587            return self.patch_response(
588                false,
589                false,
590                false,
591                vec![RuntimeDiagnostic::error(format!(
592                    "no patch event available to undo for actor {actor_id}"
593                ))],
594            );
595        };
596        let entry = self.undo_stack.remove(index);
597        let outcome = self.apply_history_entry(entry.clone(), HistoryDirection::Undo);
598        if outcome.applied {
599            let response = outcome.response;
600            self.redo_stack.push(entry);
601            self.patch_response(true, true, false, response.diagnostics)
602        } else {
603            let response = outcome.response;
604            self.undo_stack.insert(index, entry);
605            self.patch_response(false, false, response.conflict, response.diagnostics)
606        }
607    }
608
609    pub fn redo(&mut self) -> RuntimePatchResponse {
610        let Some(entry) = self.redo_stack.pop() else {
611            return self.patch_response(
612                false,
613                false,
614                false,
615                vec![RuntimeDiagnostic::error("no patch event available to redo")],
616            );
617        };
618        let outcome = self.apply_history_entry(entry.clone(), HistoryDirection::Redo);
619        if outcome.applied {
620            let response = outcome.response;
621            self.undo_stack.push(entry);
622            self.patch_response(true, true, false, response.diagnostics)
623        } else {
624            let response = outcome.response;
625            self.redo_stack.push(entry);
626            self.patch_response(false, false, response.conflict, response.diagnostics)
627        }
628    }
629
630    pub fn redo_for_actor(&mut self, actor_id: &str) -> RuntimePatchResponse {
631        let Some(index) = self
632            .redo_stack
633            .iter()
634            .rposition(|entry| entry.actor_id() == Some(actor_id))
635        else {
636            return self.patch_response(
637                false,
638                false,
639                false,
640                vec![RuntimeDiagnostic::error(format!(
641                    "no patch event available to redo for actor {actor_id}"
642                ))],
643            );
644        };
645        let entry = self.redo_stack.remove(index);
646        let outcome = self.apply_history_entry(entry.clone(), HistoryDirection::Redo);
647        if outcome.applied {
648            let response = outcome.response;
649            self.undo_stack.push(entry);
650            self.patch_response(true, true, false, response.diagnostics)
651        } else {
652            let response = outcome.response;
653            self.redo_stack.insert(index, entry);
654            self.patch_response(false, false, response.conflict, response.diagnostics)
655        }
656    }
657
658    pub fn reject_patch(
659        &self,
660        conflict: bool,
661        diagnostics: Vec<RuntimeDiagnostic>,
662    ) -> RuntimePatchResponse {
663        self.patch_response(false, false, conflict, diagnostics)
664    }
665
666    pub fn clear(&mut self) -> RuntimeSessionResponse {
667        self.project = None;
668        self.nodes_current = Vec::new();
669        self.graph = None;
670        self.registry = None;
671        self.plan = None;
672        self.view_state = None;
673        self.control_state = ControlState::default();
674        self.view_revision = 0;
675        self.control_revision = 0;
676        self.diagnostics = Vec::new();
677        self.clear_history();
678        self.revision += 1;
679        self.response(true, Vec::new(), None)
680    }
681
682    pub fn apply_control_event(
683        &mut self,
684        request: RuntimeControlEventRequest,
685    ) -> RuntimeControlEventResponse {
686        let Some(graph) = self.graph.as_ref() else {
687            return RuntimeControlEventResponse {
688                ok: false,
689                changed: false,
690                control_revision: Some(self.control_revision),
691                emitted: Vec::new(),
692                diagnostics: vec![RuntimeDiagnostic::error(
693                    "no project loaded in runtime session",
694                )],
695            };
696        };
697
698        let before = self.control_state.clone();
699        let response = self.control_state.apply_event(request, graph);
700        if response.ok {
701            let changed = self.control_state != before;
702            if changed {
703                self.control_revision += 1;
704            }
705            self.diagnostics = Vec::new();
706            return response.with_runtime_metadata(changed, self.control_revision);
707        } else {
708            self.diagnostics = response.diagnostics.clone();
709        }
710        response.with_runtime_metadata(false, self.control_revision)
711    }
712
713    pub fn control_state_response(&self) -> RuntimeControlStateResponse {
714        RuntimeControlStateResponse {
715            ok: self.graph.is_some(),
716            control_revision: self.control_revision,
717            values: self.control_state.values.clone(),
718            channels: self.control_state.channels.clone(),
719            diagnostics: if self.graph.is_some() {
720                Vec::new()
721            } else {
722                vec![RuntimeDiagnostic::error(
723                    "no project loaded in runtime session",
724                )]
725            },
726        }
727    }
728
729    pub fn control_revision(&self) -> u64 {
730        self.control_revision
731    }
732
733    pub fn preview_control_state_snapshot(&self) -> Option<PreviewControlStateSnapshot> {
734        self.graph.as_ref()?;
735        Some(PreviewControlStateSnapshot::new(
736            self.revision,
737            self.control_revision,
738            &self.control_state,
739        ))
740    }
741
742    pub fn read_control(&self, request: RuntimeControlReadRequest) -> RuntimeControlReadResponse {
743        let Some(graph) = self.graph.as_ref() else {
744            return RuntimeControlReadResponse::error(
745                request,
746                "no project loaded in runtime session",
747            );
748        };
749        let Some(node) = graph.nodes.iter().find(|node| node.id == request.node_id) else {
750            let node_id = request.node_id.clone();
751            return RuntimeControlReadResponse::error(
752                request,
753                format!("control read node {node_id} does not exist"),
754            );
755        };
756
757        match request.target.clone() {
758            RuntimeControlReadTarget::Param => {
759                let Some(value) = read_graph_param(node, &request.id) else {
760                    let node_id = node.id.clone();
761                    let id = request.id.clone();
762                    return RuntimeControlReadResponse::error(
763                        request,
764                        format!("node {node_id} param {id} does not exist"),
765                    );
766                };
767                RuntimeControlReadResponse::ok(request, value)
768            }
769            RuntimeControlReadTarget::Port => {
770                let Some(value) = read_graph_port(node, &request.id) else {
771                    let node_id = node.id.clone();
772                    let id = request.id.clone();
773                    return RuntimeControlReadResponse::error(
774                        request,
775                        format!("node {node_id} port {id} does not exist"),
776                    );
777                };
778                RuntimeControlReadResponse::ok(request, value)
779            }
780            RuntimeControlReadTarget::State => {
781                if request.id != "value" {
782                    let node_id = node.id.clone();
783                    let id = request.id.clone();
784                    return RuntimeControlReadResponse::error(
785                        request,
786                        format!("node {node_id} state {id} does not exist"),
787                    );
788                }
789                let Some(value) = self.control_state.values.get(&node.id) else {
790                    let node_id = node.id.clone();
791                    return RuntimeControlReadResponse::error(
792                        request,
793                        format!("node {node_id} has no runtime control state"),
794                    );
795                };
796                let value = serde_json::to_value(value)
797                    .expect("runtime control values should serialize to JSON");
798                RuntimeControlReadResponse::ok(request, value)
799            }
800        }
801    }
802
803    pub fn response(
804        &self,
805        ok: bool,
806        diagnostics: Vec<RuntimeDiagnostic>,
807        report: Option<DummyExecutionReport>,
808    ) -> RuntimeSessionResponse {
809        let snapshot = self.snapshot();
810        RuntimeSessionResponse {
811            ok,
812            snapshot,
813            diagnostics,
814            report,
815        }
816    }
817
818    #[cfg(test)]
819    pub(crate) fn graph(&self) -> Option<GraphDocument> {
820        self.graph.clone()
821    }
822
823    pub fn project_document_current(&self) -> Option<ProjectDocumentCurrent> {
824        self.project.clone()
825    }
826
827    pub fn target_revision_current(&self, target: &GraphTargetRef) -> Option<String> {
828        self.project
829            .as_ref()
830            .and_then(|project| target_graph_revision_current(project, target).ok())
831    }
832
833    pub fn view_state(&self) -> Option<ViewState> {
834        self.view_state.clone()
835    }
836
837    fn current_project_request_current(&self) -> Option<ProjectRequestCurrent> {
838        let project = self.project.as_ref()?;
839        Some(ProjectRequestCurrent {
840            document: self.project.clone(),
841            graph: project.graph.clone(),
842            nodes: self.nodes_current.clone(),
843            patch_library: project.patch_library.clone(),
844            view_state: self.view_state.clone(),
845        })
846    }
847
848    fn apply_mutation_with_history(
849        &mut self,
850        mut mutation: RuntimeMutationRequest,
851        kind: RuntimeHistoryEntryKind,
852        subject_event_id: Option<String>,
853    ) -> RuntimePatchResponse {
854        let (graph, registry) = match (self.graph.clone(), self.registry.clone()) {
855            (Some(graph), Some(registry)) => (graph, registry),
856            _ => {
857                return self.patch_response(
858                    false,
859                    false,
860                    false,
861                    vec![RuntimeDiagnostic::error(
862                        "no project loaded in runtime session",
863                    )],
864                );
865            }
866        };
867
868        if mutation.graph_patch.is_none() && mutation.view_patch.is_none() {
869            return self.patch_response(
870                false,
871                false,
872                false,
873                vec![RuntimeDiagnostic::error(
874                    "runtime mutation did not include graphPatch or viewPatch",
875                )],
876            );
877        }
878
879        if mutation.graph_patch.is_some() {
880            return self.patch_response(
881                false,
882                false,
883                false,
884                vec![RuntimeDiagnostic::structured_error(
885                    "project.graph-patch-unsupported",
886                    "active Runtime sessions use current 0.1 ProjectDocument graph targets; graphPatch mutations are unsupported",
887                    serde_json::json!({ "activeSchemaVersion": "0.1.0" }),
888                )],
889            );
890        }
891
892        let next_graph = graph.clone();
893
894        if let Some(view_patch) = &mutation.view_patch
895            && view_patch.base_view_revision != self.view_revision
896        {
897            return self.patch_response(
898                false,
899                false,
900                true,
901                vec![RuntimeDiagnostic::error(format!(
902                    "view patch baseViewRevision {} does not match session view revision {}",
903                    view_patch.base_view_revision, self.view_revision
904                ))],
905            );
906        }
907
908        let previous_view_state = runtime_owned_view_state(
909            reconcile_view_state_with_execution_graph(&graph, self.view_state.clone()),
910        );
911        let mut next_view_state = reconcile_view_state_with_execution_graph(
912            &next_graph,
913            Some(previous_view_state.clone()),
914        );
915        let view_patch = mutation
916            .view_patch
917            .as_ref()
918            .expect("view patch should exist after no-op and active v0.1 graph patch rejection");
919        let (patched_view_state, inverse_patch) =
920            match apply_view_patch_to_view_state(&next_graph, next_view_state, view_patch) {
921                Ok(result) => result,
922                Err(diagnostics) => {
923                    return self.patch_response(false, false, false, diagnostics);
924                }
925            };
926        next_view_state = patched_view_state;
927        let inverse_view_patch = Some(inverse_patch);
928        next_view_state = runtime_owned_view_state(next_view_state);
929        let view_changed = previous_view_state != next_view_state;
930
931        if !view_changed {
932            return self.patch_response(true, false, false, Vec::new());
933        }
934
935        let diagnostics = unresolved_object_diagnostics(&next_graph);
936        let plan =
937            build_execution_plan(&next_graph, &registry).expect("validated project should plan");
938        let control_state = ControlState::from_graph(&next_graph);
939        let mut inverse_mutation = RuntimeMutationRequest {
940            graph_patch: None,
941            view_patch: inverse_view_patch,
942            actor_id: mutation.actor_id.clone(),
943            client_id: mutation.client_id.clone(),
944            description: mutation
945                .description
946                .as_ref()
947                .map(|description| format!("Inverse of {description}")),
948        };
949        normalize_mutation_base_revisions(
950            &mut mutation,
951            graph.revision.clone(),
952            self.view_revision,
953        );
954        normalize_mutation_base_revisions(
955            &mut inverse_mutation,
956            next_graph.revision.clone(),
957            self.view_revision + 1,
958        );
959        let history_entry = self.create_runtime_history_entry(
960            kind,
961            mutation.clone(),
962            inverse_mutation.clone(),
963            subject_event_id,
964        );
965        let history_stack_entry = HistoryEntry::Mutation {
966            event_id: history_entry.id.clone(),
967            actor_id: history_entry.actor_id.clone(),
968            mutation,
969            inverse_mutation,
970        };
971
972        self.graph = Some(next_graph.clone());
973        self.registry = Some(registry);
974        self.plan = Some(plan);
975        self.view_state = Some(next_view_state);
976        if let (Some(project), Some(view_state)) = (self.project.as_mut(), self.view_state.as_ref())
977        {
978            project.view_state = view_state.clone();
979        }
980        if view_changed {
981            self.view_revision += 1;
982        }
983        self.control_state = control_state;
984        self.diagnostics = diagnostics.clone();
985        self.revision += 1;
986        self.history_entries.push(history_entry);
987        if matches!(kind, RuntimeHistoryEntryKind::Apply) {
988            self.undo_stack.push(history_stack_entry);
989            self.redo_stack.clear();
990        }
991
992        self.patch_response(true, true, false, diagnostics)
993    }
994
995    fn paste_graph_fragment(
996        &mut self,
997        envelope: RuntimeOperationEnvelope,
998    ) -> PasteGraphFragmentResponse {
999        let request = envelope.request.clone();
1000        let target = request.target.clone();
1001        let Some(project) = self.project.as_ref().cloned() else {
1002            return self.reject_paste_response(
1003                target,
1004                false,
1005                vec![operation_error(
1006                    "paste.target.no-project",
1007                    "no project loaded in runtime session",
1008                    Some(request.target),
1009                    None,
1010                    None,
1011                    None,
1012                    None,
1013                )],
1014                empty_id_remap(),
1015            );
1016        };
1017
1018        let target_revision = match target_graph_revision_current(&project, &request.target) {
1019            Ok(revision) => revision,
1020            Err(diagnostic) => {
1021                return self.reject_paste_response(
1022                    target,
1023                    false,
1024                    vec![*diagnostic],
1025                    empty_id_remap(),
1026                );
1027            }
1028        };
1029
1030        if request.target.base_revision != target_revision {
1031            return self.reject_paste_response(
1032                target,
1033                true,
1034                vec![operation_error(
1035                    "paste.revision-conflict",
1036                    format!(
1037                        "target baseRevision {} does not match target graph revision {}",
1038                        request.target.base_revision, target_revision
1039                    ),
1040                    Some(request.target.clone()),
1041                    Some(request.target.base_revision.clone()),
1042                    Some(target_revision.clone()),
1043                    None,
1044                    None,
1045                )],
1046                empty_id_remap(),
1047            );
1048        }
1049
1050        let revision_before = target_revision;
1051        let (next_project, next_view_revision, id_remap, revision_after) =
1052            match paste_graph_fragment_into_project_current(
1053                project.clone(),
1054                self.view_revision,
1055                &request,
1056            ) {
1057                Ok(result) => result,
1058                Err((diagnostics, id_remap)) => {
1059                    return self.reject_paste_response(target, false, diagnostics, id_remap);
1060                }
1061            };
1062        let mutation = RuntimeMutationRequest {
1063            graph_patch: None,
1064            view_patch: None,
1065            actor_id: envelope
1066                .attribution
1067                .as_ref()
1068                .and_then(|attribution| attribution.actor_id.clone()),
1069            client_id: envelope
1070                .attribution
1071                .as_ref()
1072                .and_then(|attribution| attribution.client_id.clone()),
1073            description: envelope
1074                .attribution
1075                .as_ref()
1076                .and_then(|attribution| attribution.label.clone())
1077                .or_else(|| Some(format!("Paste graph fragment {}", envelope.id))),
1078        };
1079
1080        let response = self.apply_project_document_update(
1081            project,
1082            next_project,
1083            next_view_revision,
1084            mutation,
1085            None,
1086        );
1087        let history_entry_id = if response.applied {
1088            response
1089                .history
1090                .entries
1091                .last()
1092                .map(|entry| entry.id.clone())
1093        } else {
1094            None
1095        };
1096        let diagnostics = response
1097            .diagnostics
1098            .iter()
1099            .map(|diagnostic| runtime_diagnostic_to_operation_diagnostic(diagnostic, &target))
1100            .collect();
1101
1102        PasteGraphFragmentResponse {
1103            schema: "skenion.runtime.paste-graph-fragment.response".to_owned(),
1104            schema_version: "0.1.0".to_owned(),
1105            ok: response.ok,
1106            applied: response.applied,
1107            conflict: response.conflict,
1108            target,
1109            revision_before,
1110            revision_after: response.applied.then_some(revision_after),
1111            history_entry_id,
1112            id_remap,
1113            diagnostics,
1114        }
1115    }
1116
1117    fn apply_project_document_update(
1118        &mut self,
1119        before: ProjectDocumentCurrent,
1120        after: ProjectDocumentCurrent,
1121        next_view_revision: u64,
1122        mutation: RuntimeMutationRequest,
1123        subject_event_id: Option<String>,
1124    ) -> RuntimePatchResponse {
1125        let before_view_revision = self.view_revision;
1126        let request = ProjectRequestCurrent {
1127            document: Some(after.clone()),
1128            graph: after.graph.clone(),
1129            nodes: self.nodes_current.clone(),
1130            patch_library: after.patch_library.clone(),
1131            view_state: Some(after.view_state.clone()),
1132        };
1133        let (plan, mut diagnostics) = match build_execution_plan_request_current(&request) {
1134            Ok(result) => result,
1135            Err(diagnostics) => return self.patch_response(false, false, false, diagnostics),
1136        };
1137        diagnostics.extend(unresolved_object_diagnostics_current(&after.graph));
1138        let graph = lower_graph_for_execution(&after.graph);
1139        let registry = match registry_from_nodes(
1140            self.nodes_current
1141                .iter()
1142                .map(lower_node_definition_for_execution)
1143                .collect(),
1144        ) {
1145            Ok(registry) => registry,
1146            Err(diagnostics) => return self.patch_response(false, false, false, diagnostics),
1147        };
1148        let inverse_mutation = RuntimeMutationRequest {
1149            graph_patch: None,
1150            view_patch: None,
1151            actor_id: mutation.actor_id.clone(),
1152            client_id: mutation.client_id.clone(),
1153            description: mutation
1154                .description
1155                .as_ref()
1156                .map(|description| format!("Inverse of {description}")),
1157        };
1158        let history_entry = self.create_runtime_history_entry(
1159            RuntimeHistoryEntryKind::Apply,
1160            mutation.clone(),
1161            inverse_mutation.clone(),
1162            subject_event_id,
1163        );
1164        let history_stack_entry = HistoryEntry::ProjectDocument {
1165            event_id: history_entry.id.clone(),
1166            actor_id: history_entry.actor_id.clone(),
1167            before: Box::new(before),
1168            after: Box::new(after.clone()),
1169            before_view_revision,
1170            after_view_revision: next_view_revision,
1171            mutation,
1172            inverse_mutation,
1173        };
1174
1175        self.project = Some(after);
1176        self.graph = Some(graph.clone());
1177        self.registry = Some(registry);
1178        self.plan = Some(plan);
1179        self.view_state = Some(
1180            self.project
1181                .as_ref()
1182                .map(|project| project.view_state.clone())
1183                .unwrap_or_else(|| reconcile_view_state_with_execution_graph(&graph, None)),
1184        );
1185        self.view_revision = next_view_revision;
1186        self.control_state = ControlState::from_graph(&graph);
1187        self.control_revision = 0;
1188        self.diagnostics = diagnostics.clone();
1189        self.revision += 1;
1190        self.history_entries.push(history_entry);
1191        self.undo_stack.push(history_stack_entry);
1192        self.redo_stack.clear();
1193
1194        self.patch_response(true, true, false, diagnostics)
1195    }
1196
1197    fn reject_paste_response(
1198        &self,
1199        target: GraphTargetRef,
1200        conflict: bool,
1201        diagnostics: Vec<RuntimeOperationDiagnostic>,
1202        id_remap: IdRemapResult,
1203    ) -> PasteGraphFragmentResponse {
1204        let revision_before = self
1205            .graph
1206            .as_ref()
1207            .map(|graph| graph.revision.clone())
1208            .unwrap_or_else(|| target.base_revision.clone());
1209        PasteGraphFragmentResponse {
1210            schema: "skenion.runtime.paste-graph-fragment.response".to_owned(),
1211            schema_version: "0.1.0".to_owned(),
1212            ok: false,
1213            applied: false,
1214            conflict,
1215            target,
1216            revision_before,
1217            revision_after: None,
1218            history_entry_id: None,
1219            id_remap,
1220            diagnostics,
1221        }
1222    }
1223
1224    fn patch_response(
1225        &self,
1226        ok: bool,
1227        applied: bool,
1228        conflict: bool,
1229        diagnostics: Vec<RuntimeDiagnostic>,
1230    ) -> RuntimePatchResponse {
1231        let snapshot = self.snapshot();
1232        RuntimePatchResponse {
1233            ok,
1234            applied,
1235            conflict,
1236            snapshot,
1237            history: self.history(),
1238            diagnostics,
1239        }
1240    }
1241
1242    fn loaded_project(&self) -> Option<(&GraphDocument, &NodeRegistry)> {
1243        Some((self.graph.as_ref()?, self.registry.as_ref()?))
1244    }
1245
1246    fn apply_history_entry(
1247        &mut self,
1248        entry: HistoryEntry,
1249        direction: HistoryDirection,
1250    ) -> HistoryApplyOutcome {
1251        match entry {
1252            HistoryEntry::Mutation {
1253                event_id,
1254                mutation,
1255                inverse_mutation,
1256                ..
1257            } => {
1258                let mut mutation_to_apply = match direction {
1259                    HistoryDirection::Undo => inverse_mutation,
1260                    HistoryDirection::Redo => mutation,
1261                };
1262                self.rebase_mutation_to_current_revisions(&mut mutation_to_apply);
1263                let response = self.apply_mutation_with_history(
1264                    mutation_to_apply,
1265                    match direction {
1266                        HistoryDirection::Undo => RuntimeHistoryEntryKind::Undo,
1267                        HistoryDirection::Redo => RuntimeHistoryEntryKind::Redo,
1268                    },
1269                    Some(event_id),
1270                );
1271                if response.applied {
1272                    HistoryApplyOutcome::applied(response)
1273                } else {
1274                    HistoryApplyOutcome::rejected(response)
1275                }
1276            }
1277            HistoryEntry::ProjectDocument {
1278                event_id,
1279                before,
1280                after,
1281                before_view_revision,
1282                after_view_revision,
1283                mutation,
1284                inverse_mutation,
1285                ..
1286            } => {
1287                let (target_project, view_revision, mutation_to_record, inverse_to_record) =
1288                    match direction {
1289                        HistoryDirection::Undo => (
1290                            (*before).clone(),
1291                            before_view_revision,
1292                            inverse_mutation,
1293                            mutation,
1294                        ),
1295                        HistoryDirection::Redo => (
1296                            (*after).clone(),
1297                            after_view_revision,
1298                            mutation,
1299                            inverse_mutation,
1300                        ),
1301                    };
1302                let project = self
1303                    .project
1304                    .as_ref()
1305                    .map(|current| {
1306                        project_document_history_delta(current, &before, &after, direction)
1307                    })
1308                    .unwrap_or(target_project);
1309                let response = self.restore_project_document_state(
1310                    project,
1311                    view_revision,
1312                    match direction {
1313                        HistoryDirection::Undo => RuntimeHistoryEntryKind::Undo,
1314                        HistoryDirection::Redo => RuntimeHistoryEntryKind::Redo,
1315                    },
1316                    mutation_to_record,
1317                    inverse_to_record,
1318                    Some(event_id),
1319                );
1320                if response.applied {
1321                    HistoryApplyOutcome::applied(response)
1322                } else {
1323                    HistoryApplyOutcome::rejected(response)
1324                }
1325            }
1326        }
1327    }
1328
1329    fn restore_project_document_state(
1330        &mut self,
1331        mut project: ProjectDocumentCurrent,
1332        view_revision: u64,
1333        mutation: RuntimeHistoryEntryKind,
1334        mutation_to_record: RuntimeMutationRequest,
1335        inverse_to_record: RuntimeMutationRequest,
1336        subject_event_id: Option<String>,
1337    ) -> RuntimePatchResponse {
1338        if let Some(current) = self.project.as_ref() {
1339            project.graph.revision = next_graph_revision(&current.graph.revision);
1340            project.revision = project.graph.revision.clone();
1341        }
1342        let request = ProjectRequestCurrent {
1343            document: Some(project.clone()),
1344            graph: project.graph.clone(),
1345            nodes: self.nodes_current.clone(),
1346            patch_library: project.patch_library.clone(),
1347            view_state: Some(project.view_state.clone()),
1348        };
1349        let (plan, mut diagnostics) = match build_execution_plan_request_current(&request) {
1350            Ok(result) => result,
1351            Err(diagnostics) => {
1352                return self.patch_response(false, false, false, diagnostics);
1353            }
1354        };
1355        diagnostics.extend(unresolved_object_diagnostics_current(&project.graph));
1356        let graph = lower_graph_for_execution(&project.graph);
1357        let registry = match registry_from_nodes(
1358            self.nodes_current
1359                .iter()
1360                .map(lower_node_definition_for_execution)
1361                .collect(),
1362        ) {
1363            Ok(registry) => registry,
1364            Err(diagnostics) => {
1365                return self.patch_response(false, false, false, diagnostics);
1366            }
1367        };
1368        let history_entry = self.create_runtime_history_entry(
1369            mutation,
1370            mutation_to_record,
1371            inverse_to_record,
1372            subject_event_id,
1373        );
1374
1375        self.project = Some(project);
1376        self.graph = Some(graph.clone());
1377        self.registry = Some(registry);
1378        self.plan = Some(plan);
1379        self.view_state = Some(
1380            self.project
1381                .as_ref()
1382                .map(|project| project.view_state.clone())
1383                .unwrap_or_else(|| reconcile_view_state_with_execution_graph(&graph, None)),
1384        );
1385        self.view_revision = view_revision;
1386        self.control_state = ControlState::from_graph(&graph);
1387        self.control_revision = 0;
1388        self.diagnostics = diagnostics.clone();
1389        self.revision += 1;
1390        self.history_entries.push(history_entry);
1391
1392        self.patch_response(true, true, false, diagnostics)
1393    }
1394
1395    fn create_runtime_history_entry(
1396        &mut self,
1397        kind: RuntimeHistoryEntryKind,
1398        mutation: RuntimeMutationRequest,
1399        inverse_mutation: RuntimeMutationRequest,
1400        subject_event_id: Option<String>,
1401    ) -> RuntimeHistoryEntry {
1402        let sequence = self.next_event_sequence;
1403        self.next_event_sequence += 1;
1404        RuntimeHistoryEntry {
1405            id: format!("runtime_event_{sequence:06}"),
1406            sequence,
1407            kind,
1408            actor_id: mutation.actor_id.clone(),
1409            client_id: mutation.client_id.clone(),
1410            description: mutation.description.clone(),
1411            mutation,
1412            inverse_mutation,
1413            subject_event_id,
1414            created_at: created_at_now(),
1415        }
1416    }
1417
1418    fn rebase_mutation_to_current_revisions(&self, mutation: &mut RuntimeMutationRequest) {
1419        if let (Some(graph), Some(graph_patch)) =
1420            (self.graph.as_ref(), mutation.graph_patch.as_mut())
1421        {
1422            graph_patch.base_revision = graph.revision.clone();
1423        }
1424        if let Some(view_patch) = mutation.view_patch.as_mut() {
1425            view_patch.base_view_revision = self.view_revision;
1426        }
1427    }
1428
1429    fn clear_history(&mut self) {
1430        self.history_entries.clear();
1431        self.undo_stack.clear();
1432        self.redo_stack.clear();
1433        self.next_event_sequence = 1;
1434    }
1435}
1436
1437#[derive(Debug, Clone, Copy)]
1438enum HistoryDirection {
1439    Undo,
1440    Redo,
1441}
1442
1443fn project_document_history_delta(
1444    current: &ProjectDocumentCurrent,
1445    before: &ProjectDocumentCurrent,
1446    after: &ProjectDocumentCurrent,
1447    direction: HistoryDirection,
1448) -> ProjectDocumentCurrent {
1449    let (expected_current, exact_target) = match direction {
1450        HistoryDirection::Undo => (after, before),
1451        HistoryDirection::Redo => (before, after),
1452    };
1453    if current == expected_current {
1454        return exact_target.clone();
1455    }
1456
1457    let mut project = current.clone();
1458    apply_graph_history_delta_current(&mut project.graph, &before.graph, &after.graph, direction);
1459    project.view_state = view_state_history_delta_current(
1460        &project.view_state,
1461        &before.view_state,
1462        &after.view_state,
1463        direction,
1464    );
1465
1466    for patch in &mut project.patch_library {
1467        let Some(before_patch) = before
1468            .patch_library
1469            .iter()
1470            .find(|entry| entry.id == patch.id)
1471        else {
1472            continue;
1473        };
1474        let Some(after_patch) = after
1475            .patch_library
1476            .iter()
1477            .find(|entry| entry.id == patch.id)
1478        else {
1479            continue;
1480        };
1481        if apply_graph_history_delta_current(
1482            &mut patch.graph,
1483            &before_patch.graph,
1484            &after_patch.graph,
1485            direction,
1486        ) {
1487            patch.graph.revision = next_graph_revision(&patch.graph.revision);
1488            patch.revision = patch.graph.revision.clone();
1489        }
1490    }
1491
1492    project
1493}
1494
1495fn apply_graph_history_delta_current(
1496    current: &mut GraphDocumentCurrent,
1497    before: &GraphDocumentCurrent,
1498    after: &GraphDocumentCurrent,
1499    direction: HistoryDirection,
1500) -> bool {
1501    match direction {
1502        HistoryDirection::Undo => undo_graph_history_delta_current(current, before, after),
1503        HistoryDirection::Redo => redo_graph_history_delta_current(current, before, after),
1504    }
1505}
1506
1507fn undo_graph_history_delta_current(
1508    current: &mut GraphDocumentCurrent,
1509    before: &GraphDocumentCurrent,
1510    after: &GraphDocumentCurrent,
1511) -> bool {
1512    let before_node_ids = before
1513        .nodes
1514        .iter()
1515        .map(|node| node.id.as_str())
1516        .collect::<HashSet<_>>();
1517    let added_node_ids = after
1518        .nodes
1519        .iter()
1520        .filter(|node| !before_node_ids.contains(node.id.as_str()))
1521        .map(|node| node.id.clone())
1522        .collect::<HashSet<_>>();
1523    let before_edge_ids = before
1524        .edges
1525        .iter()
1526        .map(|edge| edge.id.as_str())
1527        .collect::<HashSet<_>>();
1528    let added_edge_ids = after
1529        .edges
1530        .iter()
1531        .filter(|edge| !before_edge_ids.contains(edge.id.as_str()))
1532        .map(|edge| edge.id.clone())
1533        .collect::<HashSet<_>>();
1534
1535    let before_nodes = before
1536        .nodes
1537        .iter()
1538        .map(|node| (node.id.as_str(), node))
1539        .collect::<BTreeMap<_, _>>();
1540    let after_nodes = after
1541        .nodes
1542        .iter()
1543        .map(|node| (node.id.as_str(), node))
1544        .collect::<BTreeMap<_, _>>();
1545
1546    let original_nodes_len = current.nodes.len();
1547    current
1548        .nodes
1549        .retain(|node| !added_node_ids.contains(node.id.as_str()));
1550    let mut changed = current.nodes.len() != original_nodes_len;
1551
1552    for node in &mut current.nodes {
1553        let Some(before_node) = before_nodes.get(node.id.as_str()) else {
1554            continue;
1555        };
1556        let Some(after_node) = after_nodes.get(node.id.as_str()) else {
1557            continue;
1558        };
1559        if node == *after_node {
1560            *node = (*before_node).clone();
1561            changed = true;
1562        }
1563    }
1564
1565    let original_edges_len = current.edges.len();
1566    current.edges.retain(|edge| {
1567        !added_edge_ids.contains(edge.id.as_str())
1568            && !added_node_ids.contains(edge.source.node_id.as_str())
1569            && !added_node_ids.contains(edge.target.node_id.as_str())
1570    });
1571    changed |= current.edges.len() != original_edges_len;
1572
1573    changed
1574}
1575
1576fn redo_graph_history_delta_current(
1577    current: &mut GraphDocumentCurrent,
1578    before: &GraphDocumentCurrent,
1579    after: &GraphDocumentCurrent,
1580) -> bool {
1581    let before_node_ids = before
1582        .nodes
1583        .iter()
1584        .map(|node| node.id.as_str())
1585        .collect::<HashSet<_>>();
1586    let current_node_ids = current
1587        .nodes
1588        .iter()
1589        .map(|node| node.id.clone())
1590        .collect::<HashSet<_>>();
1591    let before_nodes = before
1592        .nodes
1593        .iter()
1594        .map(|node| (node.id.as_str(), node))
1595        .collect::<BTreeMap<_, _>>();
1596    let after_nodes = after
1597        .nodes
1598        .iter()
1599        .map(|node| (node.id.as_str(), node))
1600        .collect::<BTreeMap<_, _>>();
1601    let mut changed = false;
1602
1603    for node in &mut current.nodes {
1604        let Some(before_node) = before_nodes.get(node.id.as_str()) else {
1605            continue;
1606        };
1607        let Some(after_node) = after_nodes.get(node.id.as_str()) else {
1608            continue;
1609        };
1610        if node == *before_node {
1611            *node = (*after_node).clone();
1612            changed = true;
1613        }
1614    }
1615    for node in &after.nodes {
1616        if !before_node_ids.contains(node.id.as_str()) && !current_node_ids.contains(&node.id) {
1617            current.nodes.push(node.clone());
1618            changed = true;
1619        }
1620    }
1621
1622    let before_edge_ids = before
1623        .edges
1624        .iter()
1625        .map(|edge| edge.id.as_str())
1626        .collect::<HashSet<_>>();
1627    let current_edge_ids = current
1628        .edges
1629        .iter()
1630        .map(|edge| edge.id.clone())
1631        .collect::<HashSet<_>>();
1632    let current_node_ids = current
1633        .nodes
1634        .iter()
1635        .map(|node| node.id.as_str())
1636        .collect::<HashSet<_>>();
1637    for edge in &after.edges {
1638        if before_edge_ids.contains(edge.id.as_str()) || current_edge_ids.contains(&edge.id) {
1639            continue;
1640        }
1641        if current_node_ids.contains(edge.source.node_id.as_str())
1642            && current_node_ids.contains(edge.target.node_id.as_str())
1643        {
1644            current.edges.push(edge.clone());
1645            changed = true;
1646        }
1647    }
1648
1649    changed
1650}
1651
1652fn view_state_history_delta_current(
1653    current: &ViewState,
1654    before: &ViewState,
1655    after: &ViewState,
1656    direction: HistoryDirection,
1657) -> ViewState {
1658    let mut next = current.clone();
1659    match direction {
1660        HistoryDirection::Undo => {
1661            for node_id in after.canvas.nodes.keys() {
1662                if !before.canvas.nodes.contains_key(node_id) {
1663                    next.canvas.nodes.remove(node_id);
1664                }
1665            }
1666            for (node_id, before_view) in &before.canvas.nodes {
1667                let Some(after_view) = after.canvas.nodes.get(node_id) else {
1668                    continue;
1669                };
1670                if next.canvas.nodes.get(node_id) == Some(after_view) {
1671                    next.canvas
1672                        .nodes
1673                        .insert(node_id.clone(), before_view.clone());
1674                }
1675            }
1676        }
1677        HistoryDirection::Redo => {
1678            for (node_id, after_view) in &after.canvas.nodes {
1679                if !before.canvas.nodes.contains_key(node_id) {
1680                    next.canvas
1681                        .nodes
1682                        .entry(node_id.clone())
1683                        .or_insert_with(|| after_view.clone());
1684                }
1685            }
1686            for (node_id, before_view) in &before.canvas.nodes {
1687                let Some(after_view) = after.canvas.nodes.get(node_id) else {
1688                    continue;
1689                };
1690                if next.canvas.nodes.get(node_id) == Some(before_view) {
1691                    next.canvas
1692                        .nodes
1693                        .insert(node_id.clone(), after_view.clone());
1694                }
1695            }
1696        }
1697    }
1698    next.canvas.viewport = None;
1699    next
1700}
1701
1702fn next_graph_revision(current: &str) -> String {
1703    current
1704        .parse::<u64>()
1705        .map(|revision| (revision + 1).to_string())
1706        .unwrap_or_else(|_| format!("{current}+1"))
1707}
1708
1709fn project_document_from_request_current(
1710    request: &ProjectRequestCurrent,
1711) -> ProjectDocumentCurrent {
1712    if let Some(document) = &request.document {
1713        return document.clone();
1714    }
1715    let graph = request.graph.clone();
1716    let view_state = request
1717        .view_state
1718        .clone()
1719        .unwrap_or_else(|| reconcile_view_state_with_graph_current(&graph, None));
1720    ProjectDocumentCurrent {
1721        schema: "skenion.project".to_owned(),
1722        schema_version: "0.1.0".to_owned(),
1723        id: graph.id.clone(),
1724        revision: graph.revision.clone(),
1725        metadata: None,
1726        graph,
1727        view_state,
1728        patch_library: request.patch_library.clone(),
1729        tutorial: None,
1730        help: None,
1731    }
1732}
1733
1734fn lower_graph_for_execution(graph: &GraphDocumentCurrent) -> GraphDocument {
1735    GraphDocument {
1736        schema: "skenion.graph".to_owned(),
1737        schema_version: "0.1.0".to_owned(),
1738        id: graph.id.clone(),
1739        revision: graph.revision.clone(),
1740        nodes: graph
1741            .nodes
1742            .iter()
1743            .map(|node| lower_graph_node_for_execution(node, &node.id))
1744            .collect(),
1745        edges: graph.edges.iter().map(lower_edge_for_execution).collect(),
1746    }
1747}
1748
1749fn lower_node_definition_for_execution(definition: &NodeDefinitionCurrent) -> NodeDefinition {
1750    NodeDefinition {
1751        schema: "skenion.node.definition".to_owned(),
1752        schema_version: "0.1.0".to_owned(),
1753        id: definition.id.clone(),
1754        version: definition.version.clone(),
1755        display_name: definition.display_name.clone(),
1756        category: definition.category.clone(),
1757        script_api_version: definition.script_api_version.clone(),
1758        bundle_hash: definition.bundle_hash.clone(),
1759        surface: definition
1760            .surface
1761            .as_ref()
1762            .map(|surface| skenion_contracts::NodeSurfaceV01 {
1763                palette: surface.palette.clone(),
1764            }),
1765        ports: definition
1766            .ports
1767            .iter()
1768            .map(lower_port_for_execution)
1769            .collect(),
1770        execution: skenion_contracts::NodeExecutionV01 {
1771            model: lower_execution_model_for_execution(&definition.execution.model),
1772            clock: definition.execution.clock.clone(),
1773        },
1774        state: skenion_contracts::NodeStateV01 {
1775            persistent: definition.state.persistent,
1776        },
1777        permissions: definition.permissions.clone(),
1778        capabilities: definition.capabilities.clone(),
1779    }
1780}
1781
1782fn lower_execution_model_for_execution(
1783    model: &skenion_contracts::ExecutionModelV01,
1784) -> crate::ExecutionModel {
1785    match model {
1786        skenion_contracts::ExecutionModelV01::Event => crate::ExecutionModel::Event,
1787        skenion_contracts::ExecutionModelV01::Value => crate::ExecutionModel::Value,
1788        skenion_contracts::ExecutionModelV01::Frame => crate::ExecutionModel::Frame,
1789        skenion_contracts::ExecutionModelV01::AudioBlock => crate::ExecutionModel::AudioBlock,
1790        skenion_contracts::ExecutionModelV01::VideoFrame => crate::ExecutionModel::VideoFrame,
1791        skenion_contracts::ExecutionModelV01::GpuPass => crate::ExecutionModel::GpuPass,
1792        skenion_contracts::ExecutionModelV01::AsyncResource => crate::ExecutionModel::AsyncResource,
1793        skenion_contracts::ExecutionModelV01::ScriptControl => crate::ExecutionModel::ScriptControl,
1794        skenion_contracts::ExecutionModelV01::NativePlugin => crate::ExecutionModel::NativePlugin,
1795    }
1796}
1797
1798fn reconcile_view_state_with_graph_current(
1799    graph: &GraphDocumentCurrent,
1800    view_state: Option<ViewState>,
1801) -> ViewState {
1802    let mut reconciled = default_view_state_for_graph_current(graph);
1803    let Some(view_state) = view_state else {
1804        return reconciled;
1805    };
1806
1807    for node in &graph.nodes {
1808        if let Some(node_view) = view_state.canvas.nodes.get(&node.id) {
1809            reconciled
1810                .canvas
1811                .nodes
1812                .insert(node.id.clone(), node_view.clone());
1813        }
1814    }
1815    if view_state.canvas.viewport.is_some() {
1816        reconciled.canvas.viewport = view_state.canvas.viewport;
1817    }
1818
1819    reconciled
1820}
1821
1822fn reconcile_view_state_with_execution_graph(
1823    graph: &GraphDocument,
1824    view_state: Option<ViewState>,
1825) -> ViewState {
1826    let mut reconciled = default_view_state_for_execution_graph(graph);
1827    let Some(view_state) = view_state else {
1828        return reconciled;
1829    };
1830
1831    for node in &graph.nodes {
1832        if let Some(node_view) = view_state.canvas.nodes.get(&node.id) {
1833            reconciled
1834                .canvas
1835                .nodes
1836                .insert(node.id.clone(), node_view.clone());
1837        }
1838    }
1839    if view_state.canvas.viewport.is_some() {
1840        reconciled.canvas.viewport = view_state.canvas.viewport;
1841    }
1842
1843    reconciled
1844}
1845
1846fn default_view_state_for_graph_current(graph: &GraphDocumentCurrent) -> ViewState {
1847    ViewState {
1848        schema: "skenion.view-state".to_owned(),
1849        schema_version: "0.1.0".to_owned(),
1850        canvas: CanvasViewState {
1851            nodes: graph
1852                .nodes
1853                .iter()
1854                .enumerate()
1855                .map(|(index, node)| {
1856                    (
1857                        node.id.clone(),
1858                        CanvasNodeView {
1859                            x: 160.0 * (index as f64),
1860                            y: 0.0,
1861                            width: None,
1862                            height: None,
1863                            collapsed: None,
1864                        },
1865                    )
1866                })
1867                .collect(),
1868            viewport: None,
1869        },
1870    }
1871}
1872
1873fn default_view_state_for_execution_graph(graph: &GraphDocument) -> ViewState {
1874    ViewState {
1875        schema: "skenion.view-state".to_owned(),
1876        schema_version: "0.1.0".to_owned(),
1877        canvas: CanvasViewState {
1878            nodes: graph
1879                .nodes
1880                .iter()
1881                .enumerate()
1882                .map(|(index, node)| {
1883                    (
1884                        node.id.clone(),
1885                        CanvasNodeView {
1886                            x: 160.0 * (index as f64),
1887                            y: 0.0,
1888                            width: None,
1889                            height: None,
1890                            collapsed: None,
1891                        },
1892                    )
1893                })
1894                .collect(),
1895            viewport: None,
1896        },
1897    }
1898}
1899
1900fn runtime_owned_view_state(mut view_state: ViewState) -> ViewState {
1901    view_state.canvas.viewport = None;
1902    view_state
1903}
1904
1905fn normalize_mutation_base_revisions(
1906    mutation: &mut RuntimeMutationRequest,
1907    graph_revision: String,
1908    view_revision: u64,
1909) {
1910    if let Some(graph_patch) = mutation.graph_patch.as_mut() {
1911        graph_patch.base_revision = graph_revision;
1912    }
1913    if let Some(view_patch) = mutation.view_patch.as_mut() {
1914        view_patch.base_view_revision = view_revision;
1915    }
1916}
1917
1918fn target_graph_revision_current(
1919    project: &ProjectDocumentCurrent,
1920    target: &GraphTargetRef,
1921) -> Result<String, Box<RuntimeOperationDiagnostic>> {
1922    Ok(target_graph_current(project, target)?.revision.clone())
1923}
1924
1925fn target_graph_current<'a>(
1926    project: &'a ProjectDocumentCurrent,
1927    target: &GraphTargetRef,
1928) -> Result<&'a GraphDocumentCurrent, Box<RuntimeOperationDiagnostic>> {
1929    match &target.path {
1930        PatchPath::Root => Ok(&project.graph),
1931        PatchPath::HelpWorkingCopy {
1932            working_copy_id, ..
1933        } if working_copy_id == &project.graph.id => Ok(&project.graph),
1934        PatchPath::HelpWorkingCopy {
1935            working_copy_id, ..
1936        } => Err(Box::new(operation_error(
1937            "paste.target.missing-help-working-copy",
1938            format!("help working copy {working_copy_id} is not loaded in this runtime session"),
1939            Some(target.clone()),
1940            None,
1941            Some(project.graph.revision.clone()),
1942            None,
1943            None,
1944        ))),
1945        PatchPath::ProjectPatchDefinition { patch_id } => project
1946            .patch_library
1947            .iter()
1948            .find(|patch| patch.id == *patch_id)
1949            .map(|patch| &patch.graph)
1950            .ok_or_else(|| {
1951                Box::new(operation_error(
1952                    "paste.target.missing-project-patch-definition",
1953                    format!(
1954                        "project patch definition {patch_id} is not loaded in this runtime session"
1955                    ),
1956                    Some(target.clone()),
1957                    None,
1958                    Some(project.graph.revision.clone()),
1959                    None,
1960                    None,
1961                ))
1962            }),
1963        PatchPath::PackagePatchDefinition {
1964            package_id,
1965            patch_id,
1966            ..
1967        } => Err(Box::new(operation_error(
1968            "paste.target.immutable-help-source",
1969            format!(
1970                "package/help source patch {package_id}/{patch_id} is immutable; paste into a project patch or help working copy instead"
1971            ),
1972            Some(target.clone()),
1973            None,
1974            Some(project.graph.revision.clone()),
1975            None,
1976            None,
1977        ))),
1978        PatchPath::EmbeddedPatchInstance { node_id, .. } => Err(Box::new(operation_error(
1979            "paste.target.unsupported-embedded-patch-instance",
1980            format!(
1981                "embedded patch instance owned by node {node_id} cannot be mutated by the current runtime session substrate"
1982            ),
1983            Some(target.clone()),
1984            None,
1985            Some(project.graph.revision.clone()),
1986            None,
1987            None,
1988        ))),
1989    }
1990}
1991
1992type PasteProjectResult =
1993    Result<(ProjectDocumentCurrent, u64, IdRemapResult, String), PasteProjectError>;
1994type PasteProjectError = (Vec<RuntimeOperationDiagnostic>, IdRemapResult);
1995
1996fn paste_graph_fragment_into_project_current(
1997    mut project: ProjectDocumentCurrent,
1998    view_revision: u64,
1999    request: &PasteGraphFragmentRequest,
2000) -> PasteProjectResult {
2001    let target_path = request.target.path.clone();
2002    if matches!(
2003        target_path,
2004        PatchPath::PackagePatchDefinition { .. } | PatchPath::EmbeddedPatchInstance { .. }
2005    ) {
2006        return Err((
2007            vec![operation_error(
2008                "paste.target.unsupported",
2009                "paste target cannot be mutated in the active Runtime session",
2010                Some(request.target.clone()),
2011                None,
2012                None,
2013                None,
2014                None,
2015            )],
2016            empty_id_remap(),
2017        ));
2018    }
2019    let (next_graph, id_remap) = {
2020        let graph = match graph_for_path_current(&project, &target_path) {
2021            Some(graph) => graph,
2022            None => {
2023                return Err((
2024                    vec![operation_error(
2025                        "paste.target.missing-graph",
2026                        "paste target graph is not available in the active current 0.1 project",
2027                        Some(request.target.clone()),
2028                        None,
2029                        None,
2030                        None,
2031                        None,
2032                    )],
2033                    empty_id_remap(),
2034                ));
2035            }
2036        };
2037        paste_graph_fragment_into_graph_current(graph, request)?
2038    };
2039    let revision_after = next_graph.revision.clone();
2040    let mut next_view_revision = view_revision;
2041    if matches!(
2042        &target_path,
2043        PatchPath::Root | PatchPath::HelpWorkingCopy { .. }
2044    ) {
2045        let execution_graph = lower_graph_for_execution(&next_graph);
2046        let view_patch = lower_fragment_view_patch(view_revision, request, &id_remap.node_id_map);
2047        let view_state = if let Some(view_patch) = view_patch {
2048            let (view_state, _) = apply_view_patch_to_view_state(
2049                &execution_graph,
2050                reconcile_view_state_with_execution_graph(
2051                    &execution_graph,
2052                    Some(project.view_state.clone()),
2053                ),
2054                &view_patch,
2055            )
2056            .expect("lowered fragment view patch should reference pasted graph nodes");
2057            next_view_revision += 1;
2058            view_state
2059        } else {
2060            reconcile_view_state_with_execution_graph(
2061                &execution_graph,
2062                Some(project.view_state.clone()),
2063            )
2064        };
2065        project.graph = next_graph;
2066        project.revision = project.graph.revision.clone();
2067        project.view_state = view_state;
2068    } else if let PatchPath::ProjectPatchDefinition { patch_id } = &target_path {
2069        let patch = project
2070            .patch_library
2071            .iter_mut()
2072            .find(|patch| patch.id == *patch_id)
2073            .expect("project patch definition lookup was already proven");
2074        patch.graph = next_graph;
2075        patch.revision = patch.graph.revision.clone();
2076    }
2077
2078    Ok((project, next_view_revision, id_remap, revision_after))
2079}
2080
2081fn apply_collaboration_changes_to_project_current(
2082    mut project: ProjectDocumentCurrent,
2083    view_revision: u64,
2084    target: &GraphTargetRef,
2085    changes: &[RuntimeCollaborationChange],
2086) -> Result<(ProjectDocumentCurrent, u64), Vec<RuntimeDiagnostic>> {
2087    if matches!(
2088        &target.path,
2089        PatchPath::PackagePatchDefinition { .. } | PatchPath::EmbeddedPatchInstance { .. }
2090    ) {
2091        return Err(vec![RuntimeDiagnostic::structured_error(
2092            "collaboration.target.unsupported",
2093            "collaboration target cannot be mutated in the active Runtime session",
2094            serde_json::json!({ "target": target }),
2095        )]);
2096    }
2097    let mut graph = graph_for_path_current(&project, &target.path).ok_or_else(|| {
2098        vec![RuntimeDiagnostic::structured_error(
2099            "collaboration.target.missing-graph",
2100            "collaboration target graph is not available in the active current 0.1 project",
2101            serde_json::json!({ "target": target }),
2102        )]
2103    })?;
2104    let mut graph_changed = false;
2105    let mut view_changed = false;
2106    let mut view_state = project.view_state.clone();
2107
2108    for change in changes {
2109        match change {
2110            RuntimeCollaborationChange::NodeAdd { node, view, .. } => {
2111                if graph.nodes.iter().any(|existing| existing.id == node.id) {
2112                    return Err(vec![RuntimeDiagnostic::structured_error(
2113                        "collaboration.node-id-conflict",
2114                        format!("node id {} already exists in target graph", node.id),
2115                        serde_json::json!({ "nodeId": node.id, "target": target }),
2116                    )]);
2117                }
2118                graph.nodes.push((**node).clone());
2119                graph_changed = true;
2120                if let Some(view) = view {
2121                    if target_supports_view_state(&target.path) {
2122                        view_state.canvas.nodes.insert(
2123                            node.id.clone(),
2124                            CanvasNodeView {
2125                                x: view.x,
2126                                y: view.y,
2127                                width: None,
2128                                height: None,
2129                                collapsed: None,
2130                            },
2131                        );
2132                        view_changed = true;
2133                    } else {
2134                        return Err(vec![unsupported_patch_view_change_diagnostic(target)]);
2135                    }
2136                }
2137            }
2138            RuntimeCollaborationChange::NodeMove {
2139                node_id, from, to, ..
2140            } => {
2141                if !target_supports_view_state(&target.path) {
2142                    return Err(vec![unsupported_patch_view_change_diagnostic(target)]);
2143                }
2144                if !graph.nodes.iter().any(|node| node.id == *node_id) {
2145                    return Err(vec![RuntimeDiagnostic::structured_error(
2146                        "collaboration.node-missing",
2147                        format!("node {node_id} does not exist in target graph"),
2148                        serde_json::json!({ "nodeId": node_id, "target": target }),
2149                    )]);
2150                }
2151                let previous =
2152                    view_state
2153                        .canvas
2154                        .nodes
2155                        .get(node_id)
2156                        .cloned()
2157                        .unwrap_or(CanvasNodeView {
2158                            x: 0.0,
2159                            y: 0.0,
2160                            width: None,
2161                            height: None,
2162                            collapsed: None,
2163                        });
2164                if let Some(from) = from
2165                    && (previous.x != from.x || previous.y != from.y)
2166                {
2167                    return Err(vec![RuntimeDiagnostic::structured_error(
2168                        "collaboration.view-conflict",
2169                        format!("node {node_id} view does not match collaboration from position"),
2170                        serde_json::json!({
2171                            "nodeId": node_id,
2172                            "expected": { "x": from.x, "y": from.y },
2173                            "actual": { "x": previous.x, "y": previous.y },
2174                        }),
2175                    )]);
2176                }
2177                view_state.canvas.nodes.insert(
2178                    node_id.clone(),
2179                    CanvasNodeView {
2180                        x: to.x,
2181                        y: to.y,
2182                        width: previous.width,
2183                        height: previous.height,
2184                        collapsed: previous.collapsed,
2185                    },
2186                );
2187                view_changed = true;
2188            }
2189            RuntimeCollaborationChange::NodeDelete { node_id, .. } => {
2190                let original_len = graph.nodes.len();
2191                graph.nodes.retain(|node| node.id != *node_id);
2192                if graph.nodes.len() == original_len {
2193                    return Err(vec![RuntimeDiagnostic::structured_error(
2194                        "collaboration.node-missing",
2195                        format!("node {node_id} does not exist in target graph"),
2196                        serde_json::json!({ "nodeId": node_id, "target": target }),
2197                    )]);
2198                }
2199                graph.edges.retain(|edge| {
2200                    edge.source.node_id != *node_id && edge.target.node_id != *node_id
2201                });
2202                if target_supports_view_state(&target.path) {
2203                    view_state.canvas.nodes.remove(node_id);
2204                    view_changed = true;
2205                }
2206                graph_changed = true;
2207            }
2208            RuntimeCollaborationChange::EdgeConnect { edge, .. } => {
2209                if graph.edges.iter().any(|existing| existing.id == edge.id) {
2210                    return Err(vec![RuntimeDiagnostic::structured_error(
2211                        "collaboration.edge-id-conflict",
2212                        format!("edge id {} already exists in target graph", edge.id),
2213                        serde_json::json!({ "edgeId": edge.id, "target": target }),
2214                    )]);
2215                }
2216                graph.edges.push((**edge).clone());
2217                graph_changed = true;
2218            }
2219            RuntimeCollaborationChange::EdgeDisconnect { edge_id, .. } => {
2220                let original_len = graph.edges.len();
2221                graph.edges.retain(|edge| edge.id != *edge_id);
2222                if graph.edges.len() == original_len {
2223                    return Err(vec![RuntimeDiagnostic::structured_error(
2224                        "collaboration.edge-missing",
2225                        format!("collaboration edge.disconnect cannot resolve edge id {edge_id}"),
2226                        serde_json::json!({ "edgeId": edge_id, "target": target }),
2227                    )]);
2228                }
2229                graph_changed = true;
2230            }
2231        }
2232    }
2233
2234    if graph_changed {
2235        graph.revision = next_graph_revision(&graph.revision);
2236    }
2237    let mut next_view_revision = view_revision;
2238    if matches!(
2239        &target.path,
2240        PatchPath::Root | PatchPath::HelpWorkingCopy { .. }
2241    ) {
2242        let execution_graph = lower_graph_for_execution(&graph);
2243        project.graph = graph;
2244        project.revision = project.graph.revision.clone();
2245        project.view_state = runtime_owned_view_state(reconcile_view_state_with_execution_graph(
2246            &execution_graph,
2247            Some(view_state),
2248        ));
2249        if view_changed {
2250            next_view_revision += 1;
2251        }
2252    } else if let PatchPath::ProjectPatchDefinition { patch_id } = &target.path {
2253        let patch = project
2254            .patch_library
2255            .iter_mut()
2256            .find(|patch| patch.id == *patch_id)
2257            .expect("project patch definition lookup was already proven");
2258        patch.graph = graph;
2259        patch.revision = patch.graph.revision.clone();
2260    }
2261
2262    Ok((project, next_view_revision))
2263}
2264
2265fn target_supports_view_state(path: &PatchPath) -> bool {
2266    matches!(path, PatchPath::Root | PatchPath::HelpWorkingCopy { .. })
2267}
2268
2269fn unsupported_patch_view_change_diagnostic(target: &GraphTargetRef) -> RuntimeDiagnostic {
2270    RuntimeDiagnostic::structured_error(
2271        "collaboration.patch-view-unsupported",
2272        "project patch definition targets do not currently carry editable view state in Runtime",
2273        serde_json::json!({ "target": target }),
2274    )
2275}
2276
2277fn graph_for_path_current(
2278    project: &ProjectDocumentCurrent,
2279    path: &PatchPath,
2280) -> Option<GraphDocumentCurrent> {
2281    match path {
2282        PatchPath::Root => Some(project.graph.clone()),
2283        PatchPath::HelpWorkingCopy {
2284            working_copy_id, ..
2285        } if working_copy_id == &project.graph.id => Some(project.graph.clone()),
2286        PatchPath::ProjectPatchDefinition { patch_id } => project
2287            .patch_library
2288            .iter()
2289            .find(|patch| patch.id == *patch_id)
2290            .map(|patch| patch.graph.clone()),
2291        PatchPath::HelpWorkingCopy { .. }
2292        | PatchPath::PackagePatchDefinition { .. }
2293        | PatchPath::EmbeddedPatchInstance { .. } => None,
2294    }
2295}
2296
2297fn paste_graph_fragment_into_graph_current(
2298    mut graph: GraphDocumentCurrent,
2299    request: &PasteGraphFragmentRequest,
2300) -> Result<(GraphDocumentCurrent, IdRemapResult), (Vec<RuntimeOperationDiagnostic>, IdRemapResult)>
2301{
2302    let outside_policy = request
2303        .options
2304        .as_ref()
2305        .and_then(|options| options.outside_endpoint_policy)
2306        .unwrap_or(GraphFragmentOutsideEndpointPolicyCurrent::Reject);
2307    let id_conflict_policy = request
2308        .options
2309        .as_ref()
2310        .and_then(|options| options.id_conflict_policy)
2311        .unwrap_or(IdConflictPolicy::Remap);
2312
2313    let fragment_analysis =
2314        skenion_contracts::analyze_graph_fragment_v01(&request.fragment, outside_policy);
2315    if !fragment_analysis.ok {
2316        let diagnostics = fragment_analysis
2317            .diagnostics
2318            .iter()
2319            .filter(|diagnostic| diagnostic.severity == "error")
2320            .map(|diagnostic| RuntimeOperationDiagnostic {
2321                severity: diagnostic.severity.clone(),
2322                code: format!("paste.fragment.{}", diagnostic.code),
2323                message: diagnostic.message.clone(),
2324                path: None,
2325                target: Some(request.target.clone()),
2326                expected_revision: None,
2327                actual_revision: Some(graph.revision.clone()),
2328                duplicates: None,
2329                nodes: diagnostic.nodes.clone(),
2330                edges: diagnostic.edges.clone(),
2331            })
2332            .collect();
2333        return Err((
2334            diagnostics,
2335            IdRemapResult {
2336                omitted_edge_ids: fragment_analysis.omitted_edge_ids,
2337                ..empty_id_remap()
2338            },
2339        ));
2340    }
2341
2342    let mut used_node_ids: HashSet<String> =
2343        graph.nodes.iter().map(|node| node.id.clone()).collect();
2344    let mut duplicate_nodes = Vec::new();
2345    let mut node_id_map = BTreeMap::new();
2346    for node in &request.fragment.nodes {
2347        let pasted_id = if used_node_ids.contains(&node.id) {
2348            duplicate_nodes.push(node.id.clone());
2349            match id_conflict_policy {
2350                IdConflictPolicy::Reject => node.id.clone(),
2351                IdConflictPolicy::Remap => next_available_node_id(&node.id, &used_node_ids),
2352            }
2353        } else {
2354            node.id.clone()
2355        };
2356        used_node_ids.insert(pasted_id.clone());
2357        node_id_map.insert(node.id.clone(), pasted_id);
2358    }
2359
2360    if id_conflict_policy == IdConflictPolicy::Reject && !duplicate_nodes.is_empty() {
2361        return Err((
2362            vec![operation_error(
2363                "paste.id-conflict",
2364                "pasted fragment contains node ids that already exist in the target graph",
2365                Some(request.target.clone()),
2366                None,
2367                Some(graph.revision.clone()),
2368                Some(duplicate_nodes),
2369                None,
2370            )],
2371            IdRemapResult {
2372                node_id_map,
2373                omitted_edge_ids: fragment_analysis.omitted_edge_ids,
2374                ..empty_id_remap()
2375            },
2376        ));
2377    }
2378
2379    let omitted_edge_ids: HashSet<String> =
2380        fragment_analysis.omitted_edge_ids.iter().cloned().collect();
2381    let mut used_edge_ids: HashSet<String> =
2382        graph.edges.iter().map(|edge| edge.id.clone()).collect();
2383    let mut edge_id_map = BTreeMap::new();
2384    for node in &request.fragment.nodes {
2385        let pasted_id = node_id_map
2386            .get(&node.id)
2387            .expect("node remap should include every fragment node");
2388        let mut node = node.clone();
2389        node.id = pasted_id.clone();
2390        graph.nodes.push(node);
2391    }
2392
2393    for edge in &request.fragment.edges {
2394        if omitted_edge_ids.contains(&edge.id) {
2395            continue;
2396        }
2397        let pasted_edge_id = if used_edge_ids.contains(&edge.id) {
2398            match id_conflict_policy {
2399                IdConflictPolicy::Reject => {
2400                    return Err((
2401                        vec![operation_error(
2402                            "paste.edge-id-conflict",
2403                            "pasted fragment contains edge ids that already exist in the target graph",
2404                            Some(request.target.clone()),
2405                            None,
2406                            Some(graph.revision.clone()),
2407                            None,
2408                            Some(vec![edge.id.clone()]),
2409                        )],
2410                        IdRemapResult {
2411                            node_id_map,
2412                            edge_id_map,
2413                            omitted_edge_ids: fragment_analysis.omitted_edge_ids,
2414                        },
2415                    ));
2416                }
2417                IdConflictPolicy::Remap => next_available_edge_id(&edge.id, &used_edge_ids),
2418            }
2419        } else {
2420            edge.id.clone()
2421        };
2422        used_edge_ids.insert(pasted_edge_id.clone());
2423        edge_id_map.insert(edge.id.clone(), pasted_edge_id.clone());
2424        graph
2425            .edges
2426            .push(remap_edge_current(edge, &node_id_map, pasted_edge_id));
2427    }
2428
2429    graph.revision = next_graph_revision(&graph.revision);
2430
2431    Ok((
2432        graph,
2433        IdRemapResult {
2434            node_id_map,
2435            edge_id_map,
2436            omitted_edge_ids: fragment_analysis.omitted_edge_ids,
2437        },
2438    ))
2439}
2440
2441fn remap_edge_current(
2442    edge: &EdgeSpecCurrent,
2443    node_id_map: &BTreeMap<String, String>,
2444    edge_id: String,
2445) -> EdgeSpecCurrent {
2446    let mut edge = edge.clone();
2447    edge.id = edge_id;
2448    edge.source.node_id = node_id_map
2449        .get(&edge.source.node_id)
2450        .cloned()
2451        .unwrap_or_else(|| edge.source.node_id.clone());
2452    edge.target.node_id = node_id_map
2453        .get(&edge.target.node_id)
2454        .cloned()
2455        .unwrap_or_else(|| edge.target.node_id.clone());
2456    edge
2457}
2458
2459fn next_available_edge_id(base: &str, used_edge_ids: &HashSet<String>) -> String {
2460    let mut index = 2;
2461    loop {
2462        let candidate = format!("{base}_{index}");
2463        if !used_edge_ids.contains(&candidate) {
2464            return candidate;
2465        }
2466        index += 1;
2467    }
2468}
2469
2470fn empty_id_remap() -> IdRemapResult {
2471    IdRemapResult {
2472        node_id_map: BTreeMap::new(),
2473        edge_id_map: BTreeMap::new(),
2474        omitted_edge_ids: Vec::new(),
2475    }
2476}
2477
2478fn next_available_node_id(base: &str, used_node_ids: &HashSet<String>) -> String {
2479    let mut index = 2;
2480    loop {
2481        let candidate = format!("{base}_{index}");
2482        if !used_node_ids.contains(&candidate) {
2483            return candidate;
2484        }
2485        index += 1;
2486    }
2487}
2488
2489pub(crate) fn lower_graph_node_for_execution(
2490    node: &GraphNodeCurrent,
2491    pasted_id: &str,
2492) -> GraphNode {
2493    GraphNode {
2494        id: pasted_id.to_owned(),
2495        kind: node.kind.clone(),
2496        kind_version: node.kind_version.clone(),
2497        params: node.params.clone(),
2498        ports: node.ports.iter().map(lower_port_for_execution).collect(),
2499    }
2500}
2501
2502fn lower_port_for_execution(port: &PortSpecCurrent) -> Port {
2503    Port {
2504        id: port.id.clone(),
2505        direction: match port.direction {
2506            PortDirectionCurrent::Input => PortDirection::Input,
2507            PortDirectionCurrent::Output => PortDirection::Output,
2508        },
2509        label: port.label.clone(),
2510        data_type: data_type_from_port_spec(port),
2511        required: port.required,
2512        default_value: port.default_value.clone(),
2513        activation: port.trigger_mode.as_ref().map(|trigger| match trigger {
2514            skenion_contracts::TriggerModeV01::Trigger => PortActivation::Trigger,
2515            skenion_contracts::TriggerModeV01::Latched => PortActivation::Latched,
2516            skenion_contracts::TriggerModeV01::Passive => PortActivation::Latched,
2517        }),
2518    }
2519}
2520
2521fn data_type_from_port_spec(port: &PortSpecCurrent) -> DataType {
2522    let data_kind = normalize_port_type(&port.port_type);
2523    let format = match data_kind.as_str() {
2524        "number.float" => Some(StringOrStrings::One("f32".to_owned())),
2525        "gpu.texture2d" => Some(StringOrStrings::One("rgba8unorm".to_owned())),
2526        _ => None,
2527    };
2528    let color_space = (data_kind == "gpu.texture2d").then(|| "srgb".to_owned());
2529    DataType {
2530        flow: match port.rate {
2531            Some(PortRateCurrent::Event) => DataFlow::Event,
2532            Some(PortRateCurrent::Audio) => DataFlow::Signal,
2533            Some(PortRateCurrent::Resource) | Some(PortRateCurrent::Io) => DataFlow::Resource,
2534            Some(PortRateCurrent::Control | PortRateCurrent::Render | PortRateCurrent::Gpu)
2535            | None => {
2536                if port.port_type == "message.any" {
2537                    DataFlow::Event
2538                } else if data_kind == "gpu.texture2d" {
2539                    DataFlow::Resource
2540                } else {
2541                    DataFlow::Value
2542                }
2543            }
2544        },
2545        data_kind,
2546        unit: None,
2547        range: None,
2548        shape: None,
2549        channels: None,
2550        sample_rate: None,
2551        format,
2552        color_space,
2553        frame_rate: None,
2554        alpha_policy: None,
2555        values: None,
2556    }
2557}
2558
2559fn normalize_port_type(port_type: &str) -> String {
2560    match port_type {
2561        "value.number" => "number.float".to_owned(),
2562        other => other
2563            .strip_prefix("value.")
2564            .map(ToOwned::to_owned)
2565            .unwrap_or_else(|| other.to_owned()),
2566    }
2567}
2568
2569fn remap_edge(edge: &EdgeSpecCurrent, node_id_map: &BTreeMap<String, String>) -> Edge {
2570    Edge {
2571        from: PortRef {
2572            node: node_id_map
2573                .get(&edge.source.node_id)
2574                .cloned()
2575                .unwrap_or_else(|| edge.source.node_id.clone()),
2576            port: edge.source.port_id.clone(),
2577        },
2578        to: PortRef {
2579            node: node_id_map
2580                .get(&edge.target.node_id)
2581                .cloned()
2582                .unwrap_or_else(|| edge.target.node_id.clone()),
2583            port: edge.target.port_id.clone(),
2584        },
2585    }
2586}
2587
2588pub(crate) fn lower_edge_for_execution(edge: &EdgeSpecCurrent) -> Edge {
2589    remap_edge(edge, &BTreeMap::new())
2590}
2591
2592fn lower_fragment_view_patch(
2593    view_revision: u64,
2594    request: &PasteGraphFragmentRequest,
2595    node_id_map: &BTreeMap<String, String>,
2596) -> Option<RuntimeViewPatch> {
2597    let fragment_views = request.fragment.view.as_ref()?.nodes.as_ref()?;
2598    let mut ops = Vec::new();
2599    let placement_delta = placement_delta(request, fragment_views);
2600    for (source_node_id, pasted_node_id) in node_id_map {
2601        let Some(view) = fragment_views.get(source_node_id) else {
2602            continue;
2603        };
2604        let mut pasted_view = view.clone();
2605        if let Some((dx, dy)) = placement_delta {
2606            pasted_view.x += dx;
2607            pasted_view.y += dy;
2608        }
2609        ops.push(RuntimeViewPatchOperation::SetNodeView {
2610            node_id: pasted_node_id.clone(),
2611            view: pasted_view,
2612        });
2613    }
2614    (!ops.is_empty()).then_some(RuntimeViewPatch {
2615        base_view_revision: view_revision,
2616        ops,
2617    })
2618}
2619
2620fn placement_delta(
2621    request: &PasteGraphFragmentRequest,
2622    fragment_views: &BTreeMap<String, CanvasNodeView>,
2623) -> Option<(f64, f64)> {
2624    match request.placement.as_ref()? {
2625        PastePlacement::Position { x, y } => {
2626            let min_x = fragment_views
2627                .values()
2628                .map(|view| view.x)
2629                .reduce(f64::min)
2630                .unwrap_or(0.0);
2631            let min_y = fragment_views
2632                .values()
2633                .map(|view| view.y)
2634                .reduce(f64::min)
2635                .unwrap_or(0.0);
2636            Some((x - min_x, y - min_y))
2637        }
2638        PastePlacement::Anchor {
2639            offset_x, offset_y, ..
2640        } => Some((offset_x.unwrap_or_default(), offset_y.unwrap_or_default())),
2641    }
2642}
2643
2644fn operation_error(
2645    code: impl Into<String>,
2646    message: impl Into<String>,
2647    target: Option<GraphTargetRef>,
2648    expected_revision: Option<String>,
2649    actual_revision: Option<String>,
2650    duplicates: Option<Vec<String>>,
2651    edges: Option<Vec<String>>,
2652) -> RuntimeOperationDiagnostic {
2653    RuntimeOperationDiagnostic {
2654        severity: "error".to_owned(),
2655        code: code.into(),
2656        message: message.into(),
2657        path: None,
2658        target,
2659        expected_revision,
2660        actual_revision,
2661        duplicates,
2662        nodes: None,
2663        edges,
2664    }
2665}
2666
2667fn operation_diagnostics_from_validation_report(
2668    message: String,
2669) -> Vec<RuntimeOperationDiagnostic> {
2670    vec![RuntimeOperationDiagnostic {
2671        severity: "error".to_owned(),
2672        code: "paste.operation.invalid-envelope".to_owned(),
2673        message,
2674        path: None,
2675        target: None,
2676        expected_revision: None,
2677        actual_revision: None,
2678        duplicates: None,
2679        nodes: None,
2680        edges: None,
2681    }]
2682}
2683
2684fn runtime_diagnostic_to_operation_diagnostic(
2685    diagnostic: &RuntimeDiagnostic,
2686    target: &GraphTargetRef,
2687) -> RuntimeOperationDiagnostic {
2688    RuntimeOperationDiagnostic {
2689        severity: match diagnostic.severity {
2690            crate::DiagnosticSeverity::Error => "error",
2691            crate::DiagnosticSeverity::Warning => "warning",
2692            crate::DiagnosticSeverity::Info => "info",
2693        }
2694        .to_owned(),
2695        code: diagnostic
2696            .code
2697            .clone()
2698            .unwrap_or_else(|| "paste.lowering.failed".to_owned()),
2699        message: diagnostic.message.clone(),
2700        path: None,
2701        target: Some(target.clone()),
2702        expected_revision: None,
2703        actual_revision: None,
2704        duplicates: None,
2705        nodes: None,
2706        edges: None,
2707    }
2708}
2709
2710fn operation_diagnostic_to_runtime_diagnostic(
2711    diagnostic: RuntimeOperationDiagnostic,
2712) -> RuntimeDiagnostic {
2713    let details = serde_json::json!({
2714        "path": diagnostic.path,
2715        "target": diagnostic.target,
2716        "expectedRevision": diagnostic.expected_revision,
2717        "actualRevision": diagnostic.actual_revision,
2718        "duplicates": diagnostic.duplicates,
2719        "nodes": diagnostic.nodes,
2720        "edges": diagnostic.edges,
2721    });
2722    match diagnostic.severity.as_str() {
2723        "warning" => {
2724            RuntimeDiagnostic::structured_warning(diagnostic.code, diagnostic.message, details)
2725        }
2726        "info" => RuntimeDiagnostic {
2727            severity: crate::DiagnosticSeverity::Info,
2728            message: diagnostic.message,
2729            code: Some(diagnostic.code),
2730            details: Some(details),
2731        },
2732        _ => RuntimeDiagnostic::structured_error(diagnostic.code, diagnostic.message, details),
2733    }
2734}
2735
2736fn apply_view_patch_to_view_state(
2737    graph: &GraphDocument,
2738    mut view_state: ViewState,
2739    patch: &RuntimeViewPatch,
2740) -> Result<(ViewState, RuntimeViewPatch), Vec<RuntimeDiagnostic>> {
2741    let mut inverse_ops = Vec::new();
2742    for op in &patch.ops {
2743        match op {
2744            RuntimeViewPatchOperation::SetNodeView { node_id, view } => {
2745                if !graph.nodes.iter().any(|node| node.id == *node_id) {
2746                    return Err(vec![RuntimeDiagnostic::error(format!(
2747                        "view patch node {node_id} does not exist"
2748                    ))]);
2749                }
2750                let Some(previous) = view_state.canvas.nodes.get(node_id).cloned() else {
2751                    return Err(vec![RuntimeDiagnostic::error(format!(
2752                        "view patch node {node_id} has no view state"
2753                    ))]);
2754                };
2755                view_state
2756                    .canvas
2757                    .nodes
2758                    .insert(node_id.clone(), view.clone());
2759                inverse_ops.insert(
2760                    0,
2761                    RuntimeViewPatchOperation::SetNodeView {
2762                        node_id: node_id.clone(),
2763                        view: previous,
2764                    },
2765                );
2766            }
2767            RuntimeViewPatchOperation::MoveNodeView { node_id, from, to } => {
2768                if !graph.nodes.iter().any(|node| node.id == *node_id) {
2769                    return Err(vec![RuntimeDiagnostic::error(format!(
2770                        "view patch node {node_id} does not exist"
2771                    ))]);
2772                }
2773                let Some(previous) = view_state.canvas.nodes.get(node_id).cloned() else {
2774                    return Err(vec![RuntimeDiagnostic::error(format!(
2775                        "view patch node {node_id} has no view state"
2776                    ))]);
2777                };
2778                if let Some(from) = from
2779                    && from != &previous
2780                {
2781                    return Err(vec![RuntimeDiagnostic::error(format!(
2782                        "view patch node {node_id} from view does not match current view"
2783                    ))]);
2784                }
2785                view_state.canvas.nodes.insert(node_id.clone(), to.clone());
2786                inverse_ops.insert(
2787                    0,
2788                    RuntimeViewPatchOperation::MoveNodeView {
2789                        node_id: node_id.clone(),
2790                        from: Some(to.clone()),
2791                        to: previous,
2792                    },
2793                );
2794            }
2795        }
2796    }
2797
2798    Ok((
2799        runtime_owned_view_state(view_state),
2800        RuntimeViewPatch {
2801            base_view_revision: patch.base_view_revision,
2802            ops: inverse_ops,
2803        },
2804    ))
2805}
2806
2807fn unresolved_object_diagnostics(graph: &GraphDocument) -> Vec<RuntimeDiagnostic> {
2808    graph
2809        .nodes
2810        .iter()
2811        .filter(|node| node.kind == UNRESOLVED_OBJECT_NODE_KIND)
2812        .map(|node| {
2813            let object_text = node
2814                .params
2815                .get("objectText")
2816                .and_then(|value| value.as_str())
2817                .unwrap_or(node.id.as_str());
2818            let diagnostic_message = node
2819                .params
2820                .get("diagnosticMessage")
2821                .and_then(|value| value.as_str())
2822                .unwrap_or("object text could not be resolved");
2823            RuntimeDiagnostic::error(format!(
2824                "unresolved object {object_text}: {diagnostic_message}"
2825            ))
2826        })
2827        .collect()
2828}
2829
2830fn unresolved_object_diagnostics_current(graph: &GraphDocumentCurrent) -> Vec<RuntimeDiagnostic> {
2831    graph
2832        .nodes
2833        .iter()
2834        .filter(|node| node.kind == UNRESOLVED_OBJECT_NODE_KIND)
2835        .map(|node| {
2836            let object_text = node
2837                .params
2838                .get("objectText")
2839                .and_then(|value| value.as_str())
2840                .unwrap_or(node.id.as_str());
2841            let diagnostic_message = node
2842                .params
2843                .get("diagnosticMessage")
2844                .and_then(|value| value.as_str())
2845                .unwrap_or("object text could not be resolved");
2846            RuntimeDiagnostic::error(format!(
2847                "unresolved object {object_text}: {diagnostic_message}"
2848            ))
2849        })
2850        .collect()
2851}
2852
2853fn created_at_now() -> String {
2854    let millis = SystemTime::now()
2855        .duration_since(UNIX_EPOCH)
2856        .map(|duration| duration.as_millis())
2857        .unwrap_or_default();
2858    format!("unix-ms:{millis}")
2859}
2860
2861#[cfg(test)]
2862mod tests {
2863    use std::collections::{BTreeMap, HashSet};
2864
2865    use serde_json::{Value, json};
2866
2867    use crate::{
2868        ControlMessage, ControlValue, Edge, EdgeEndpointCurrent, EdgeSpecCurrent, GraphDocument,
2869        GraphDocumentCurrent, GraphPatch, NodeRegistry, PasteGraphFragmentRequest, PortRef,
2870        PortSpecCurrent, ProjectRequestCurrent, RuntimeCollaborationChange, RuntimeControlEmission,
2871        RuntimeControlEventRequest, RuntimeControlReadRequest, RuntimeControlReadTarget,
2872        RuntimeDiagnostic, RuntimeOperationDiagnostic, RuntimeOperationEnvelope, ViewState,
2873    };
2874
2875    use super::{
2876        HistoryEntry, RuntimeHistoryEntryKind, RuntimeMutationRequest, RuntimePatchResponse,
2877        RuntimeSession, RuntimeViewPatch, RuntimeViewPatchOperation, lower_fragment_view_patch,
2878        lower_port_for_execution, remap_edge, runtime_diagnostic_to_operation_diagnostic,
2879    };
2880
2881    #[test]
2882    fn invalid_registry_load_returns_diagnostics_without_revision_change() {
2883        let mut session = RuntimeSession::default();
2884        let mut request = sample_project_current();
2885        request.nodes[0].schema_version = "9.9.9".to_owned();
2886
2887        let response = session.load_project_current(request);
2888
2889        assert!(!response.ok);
2890        assert!(!response.snapshot.loaded());
2891        assert_eq!(response.snapshot.session_revision, 0);
2892        assert!(!response.diagnostics.is_empty());
2893    }
2894
2895    #[test]
2896    fn validate_and_plan_fail_without_loaded_project() {
2897        let mut session = RuntimeSession::default();
2898
2899        let validation = session.validate_current();
2900        let plan = session.plan_current();
2901        let preview_control = session.preview_control_state_snapshot();
2902
2903        assert!(!validation.ok);
2904        assert!(!plan.ok);
2905        assert!(preview_control.is_none());
2906        assert!(
2907            plan.diagnostics[0]
2908                .message
2909                .contains("no project loaded in runtime session")
2910        );
2911    }
2912
2913    #[test]
2914    fn plan_current_reports_invalid_stored_project() {
2915        let mut session = RuntimeSession {
2916            graph: Some(sample_internal_graph()),
2917            registry: Some(NodeRegistry::new()),
2918            plan: None,
2919            diagnostics: Vec::new(),
2920            revision: 1,
2921            ..RuntimeSession::default()
2922        };
2923
2924        let response = session.plan_current();
2925
2926        assert!(!response.ok);
2927        assert!(response.snapshot.plan.is_none());
2928        assert!(
2929            response.diagnostics[0]
2930                .message
2931                .contains("no project loaded")
2932        );
2933    }
2934
2935    #[test]
2936    fn validate_current_reports_invalid_stored_project() {
2937        let mut session = RuntimeSession {
2938            graph: Some(sample_internal_graph()),
2939            registry: None,
2940            plan: None,
2941            diagnostics: Vec::new(),
2942            revision: 1,
2943            ..RuntimeSession::default()
2944        };
2945
2946        let response = session.validate_current();
2947
2948        assert!(!response.ok);
2949        assert!(
2950            response.diagnostics[0]
2951                .message
2952                .contains("no project loaded")
2953        );
2954    }
2955
2956    #[test]
2957    fn validate_current_reports_registry_validation_errors() {
2958        let mut session = RuntimeSession {
2959            graph: Some(sample_internal_graph()),
2960            registry: Some(NodeRegistry::new()),
2961            plan: None,
2962            diagnostics: Vec::new(),
2963            revision: 1,
2964            ..RuntimeSession::default()
2965        };
2966
2967        let response = session.validate_current();
2968
2969        assert!(!response.ok);
2970        assert!(
2971            response.diagnostics[0]
2972                .message
2973                .contains("no project loaded")
2974        );
2975    }
2976
2977    #[test]
2978    fn run_current_rebuilds_missing_plan() {
2979        let mut session = RuntimeSession::default();
2980        let loaded = load_sample_project(&mut session);
2981        assert!(loaded.ok);
2982        session.plan = None;
2983
2984        let response = session.run_current(2);
2985
2986        assert!(response.ok);
2987        assert!(response.snapshot.plan.is_some());
2988        assert_eq!(response.report.unwrap().frame_count, 2);
2989    }
2990
2991    #[test]
2992    fn run_current_returns_plan_failure_when_rebuild_fails() {
2993        let mut session = RuntimeSession {
2994            graph: Some(sample_internal_graph()),
2995            registry: Some(NodeRegistry::new()),
2996            plan: None,
2997            diagnostics: Vec::new(),
2998            revision: 1,
2999            ..RuntimeSession::default()
3000        };
3001
3002        let response = session.run_current(2);
3003
3004        assert!(!response.ok);
3005        assert!(response.report.is_none());
3006        assert!(
3007            response.diagnostics[0]
3008                .message
3009                .contains("no project loaded")
3010        );
3011    }
3012
3013    #[test]
3014    fn control_event_fails_without_loaded_project() {
3015        let mut session = RuntimeSession::default();
3016
3017        let response =
3018            session.apply_control_event(set_control_request("value_1", "in", f32_value(32.0)));
3019
3020        assert!(!response.ok);
3021        assert!(response.emitted.is_empty());
3022        assert_eq!(session.snapshot().session_revision, 0);
3023        assert!(
3024            response.diagnostics[0]
3025                .message
3026                .contains("no project loaded")
3027        );
3028    }
3029
3030    #[test]
3031    fn control_set_bang_and_in_follow_typed_value_semantics() {
3032        let mut session = RuntimeSession::default();
3033        assert!(load_sample_project(&mut session).ok);
3034
3035        let set =
3036            session.apply_control_event(set_control_request("value_1", "in", f32_value(32.0)));
3037        assert!(set.ok);
3038        assert!(set.changed);
3039        assert!(set.emitted.is_empty());
3040        assert_eq!(session.snapshot().session_revision, 1);
3041        assert_eq!(session.snapshot().control_revision, 1);
3042        assert_eq!(session.control_revision(), 1);
3043        assert_eq!(set.control_revision, Some(1));
3044        assert_eq!(
3045            session.control_state_response().values.get("value_1"),
3046            Some(&ControlValue::float(32.0))
3047        );
3048
3049        let same_set =
3050            session.apply_control_event(set_control_request("value_1", "in", f32_value(32.0)));
3051        assert!(same_set.ok);
3052        assert!(!same_set.changed);
3053        assert_eq!(same_set.control_revision, Some(1));
3054
3055        let bang = session.apply_control_event(bang_control_request("value_1", "in"));
3056        assert!(bang.ok);
3057        assert_eq!(bang.emitted.len(), 1);
3058        assert_eq!(bang.emitted[0].node_id, "value_1");
3059        assert_eq!(bang.emitted[0].port_id, "value");
3060        assert_eq!(
3061            emitted_value(&bang.emitted[0]),
3062            Some(ControlValue::float(32.0))
3063        );
3064        assert!(bang.changed);
3065        assert_eq!(session.snapshot().session_revision, 1);
3066        assert_eq!(session.snapshot().control_revision, 2);
3067        assert_eq!(bang.control_revision, Some(2));
3068
3069        let input = session.apply_control_event(control_request("value_1", "in", f32_value(12.0)));
3070        assert!(input.ok);
3071        assert!(input.changed);
3072        assert_eq!(
3073            emitted_value(&input.emitted[0]),
3074            Some(ControlValue::float(12.0))
3075        );
3076        assert_eq!(
3077            session.control_state_response().values.get("value_1"),
3078            Some(&ControlValue::float(12.0))
3079        );
3080        assert_eq!(
3081            session.control_state_response().values.get("target_1"),
3082            Some(&ControlValue::float(12.0))
3083        );
3084        assert_eq!(session.snapshot().session_revision, 1);
3085        assert_eq!(session.snapshot().control_revision, 3);
3086        assert_eq!(session.control_revision(), 3);
3087        assert_eq!(input.control_revision, Some(3));
3088    }
3089
3090    #[test]
3091    fn control_object_send_name_updates_typed_channel_state() {
3092        let mut session = RuntimeSession::default();
3093        assert!(
3094            session
3095                .load_project_current(object_routing_project_current())
3096                .ok
3097        );
3098
3099        let response =
3100            session.apply_control_event(control_request("value_1", "in", f32_value(1.5)));
3101
3102        assert!(response.ok);
3103        assert_eq!(response.emitted[0].node_id, "value_1");
3104        assert_eq!(response.emitted[0].port_id, "value");
3105        assert_eq!(
3106            emitted_value(&response.emitted[0]),
3107            Some(ControlValue::float(1.5))
3108        );
3109        assert_eq!(
3110            session
3111                .control_state_response()
3112                .channels
3113                .get("number.float:speed"),
3114            Some(&ControlMessage::from_value(ControlValue::float(1.5)))
3115        );
3116    }
3117
3118    #[test]
3119    fn control_read_addresses_params_ports_and_state() {
3120        let mut session = RuntimeSession::default();
3121        let mut project = sample_project_current();
3122        project.graph.nodes[0]
3123            .params
3124            .insert("value".to_owned(), json!(0.0));
3125        assert!(session.load_project_current(project).ok);
3126        assert!(
3127            session
3128                .apply_control_event(set_control_request("value_1", "in", f32_value(32.0)))
3129                .ok
3130        );
3131
3132        let param = session.read_control(control_read(
3133            "value_1",
3134            RuntimeControlReadTarget::Param,
3135            "value",
3136        ));
3137        assert!(param.ok);
3138        assert_eq!(
3139            param.value.unwrap(),
3140            json!({ "type": "json", "value": 0.0 })
3141        );
3142
3143        let port = session.read_control(control_read(
3144            "value_1",
3145            RuntimeControlReadTarget::Port,
3146            "value",
3147        ));
3148        assert!(port.ok);
3149        assert_eq!(port.value.unwrap()["value"]["id"], json!("value"));
3150
3151        let state = session.read_control(control_read(
3152            "value_1",
3153            RuntimeControlReadTarget::State,
3154            "value",
3155        ));
3156        assert!(state.ok);
3157        assert_eq!(
3158            state.value.unwrap(),
3159            json!({ "type": "float", "representation": "f32", "value": 32.0 })
3160        );
3161    }
3162
3163    #[test]
3164    fn invalid_control_read_reports_diagnostics() {
3165        let mut session = RuntimeSession::default();
3166        let missing_session = session.read_control(control_read(
3167            "value_1",
3168            RuntimeControlReadTarget::State,
3169            "value",
3170        ));
3171        assert!(!missing_session.ok);
3172        assert!(
3173            missing_session.diagnostics[0]
3174                .message
3175                .contains("no project loaded")
3176        );
3177
3178        assert!(load_sample_project(&mut session).ok);
3179        let missing_port = session.read_control(control_read(
3180            "value_1",
3181            RuntimeControlReadTarget::Port,
3182            "missing",
3183        ));
3184        assert!(!missing_port.ok);
3185        assert!(
3186            missing_port.diagnostics[0]
3187                .message
3188                .contains("port missing does not exist")
3189        );
3190
3191        let missing_node = session.read_control(control_read(
3192            "missing",
3193            RuntimeControlReadTarget::State,
3194            "value",
3195        ));
3196        assert!(!missing_node.ok);
3197        assert!(
3198            missing_node.diagnostics[0]
3199                .message
3200                .contains("node missing does not exist")
3201        );
3202
3203        let missing_param = session.read_control(control_read(
3204            "value_1",
3205            RuntimeControlReadTarget::Param,
3206            "missing",
3207        ));
3208        assert!(!missing_param.ok);
3209        assert!(
3210            missing_param.diagnostics[0]
3211                .message
3212                .contains("param missing does not exist")
3213        );
3214
3215        let missing_state_id = session.read_control(control_read(
3216            "value_1",
3217            RuntimeControlReadTarget::State,
3218            "other",
3219        ));
3220        assert!(!missing_state_id.ok);
3221        assert!(
3222            missing_state_id.diagnostics[0]
3223                .message
3224                .contains("state other does not exist")
3225        );
3226
3227        assert!(
3228            session
3229                .load_project_current(debug_sink_project_current())
3230                .ok
3231        );
3232        let missing_runtime_state = session.read_control(control_read(
3233            "debug_1",
3234            RuntimeControlReadTarget::State,
3235            "value",
3236        ));
3237        assert!(!missing_runtime_state.ok);
3238        assert!(
3239            missing_runtime_state.diagnostics[0]
3240                .message
3241                .contains("has no runtime control state")
3242        );
3243    }
3244
3245    #[test]
3246    fn invalid_control_event_does_not_mutate_state_or_revision() {
3247        let mut session = RuntimeSession::default();
3248        assert!(load_sample_project(&mut session).ok);
3249        assert!(
3250            session
3251                .apply_control_event(set_control_request("value_1", "in", f32_value(32.0)))
3252                .ok
3253        );
3254        let before = session.snapshot();
3255
3256        let response =
3257            session.apply_control_event(control_request("value_1", "in", ControlValue::bool(true)));
3258
3259        assert!(!response.ok);
3260        assert!(response.emitted.is_empty());
3261        assert_eq!(session.snapshot().session_revision, before.session_revision);
3262        assert_eq!(
3263            session.control_state_response().values.get("value_1"),
3264            Some(&ControlValue::float(32.0))
3265        );
3266    }
3267
3268    #[test]
3269    fn failed_control_propagation_does_not_mutate_state_or_revision() {
3270        let mut session = RuntimeSession::default();
3271        assert!(load_sample_project(&mut session).ok);
3272        session.graph.as_mut().unwrap().edges = vec![Edge {
3273            from: PortRef {
3274                node: "value_1".to_owned(),
3275                port: "value".to_owned(),
3276            },
3277            to: PortRef {
3278                node: "target_1".to_owned(),
3279                port: "missing".to_owned(),
3280            },
3281        }];
3282        let before = session.snapshot();
3283
3284        let response =
3285            session.apply_control_event(control_request("value_1", "in", f32_value(9.0)));
3286
3287        assert!(!response.ok);
3288        assert!(response.diagnostics[0].message.contains("port missing"));
3289        assert_eq!(response.control_revision, Some(before.control_revision));
3290        assert_eq!(session.snapshot().control_revision, before.control_revision);
3291        assert_eq!(
3292            session.control_state_response().values.get("value_1"),
3293            Some(&ControlValue::float(0.0))
3294        );
3295        assert_eq!(
3296            session.control_state_response().values.get("target_1"),
3297            Some(&ControlValue::float(0.0))
3298        );
3299    }
3300
3301    #[test]
3302    fn graph_patch_rebuilds_control_state_from_graph_params() {
3303        let mut session = RuntimeSession::default();
3304        assert!(load_sample_project(&mut session).ok);
3305        assert!(
3306            session
3307                .apply_control_event(set_control_request("value_1", "in", f32_value(32.0)))
3308                .ok
3309        );
3310
3311        let response = session.apply_patch(set_value_patch("1", 0.75));
3312
3313        assert_graph_patch_rejected(&response);
3314        assert_eq!(
3315            session.control_state_response().values.get("value_1"),
3316            Some(&ControlValue::float(32.0))
3317        );
3318    }
3319
3320    #[test]
3321    fn preview_context_requires_loaded_project_and_plan() {
3322        let mut session = RuntimeSession::default();
3323
3324        let missing_project = session.preview_context();
3325        assert!(
3326            missing_project
3327                .unwrap_err()
3328                .first()
3329                .unwrap()
3330                .message
3331                .contains("no project loaded")
3332        );
3333
3334        load_sample_project(&mut session);
3335        let context = session.preview_context().expect("context should exist");
3336        assert_eq!(context.graph_id, "minimal-value");
3337        assert_eq!(context.graph_revision, "1");
3338        assert_eq!(context.session_revision, 1);
3339        assert_eq!(context.plan.graph_id, "minimal-value");
3340        assert_eq!(
3341            context.control_state.value_for_node("value_1"),
3342            Some(&ControlValue::float(0.0))
3343        );
3344
3345        session.plan = None;
3346        let missing_plan = session.preview_context();
3347        assert!(
3348            missing_plan
3349                .unwrap_err()
3350                .first()
3351                .unwrap()
3352                .message
3353                .contains("no execution plan available")
3354        );
3355    }
3356
3357    #[test]
3358    fn graph_and_view_state_accessors_return_loaded_project_copies() {
3359        let mut session = RuntimeSession::default();
3360        let loaded = load_sample_project(&mut session);
3361
3362        assert!(loaded.ok);
3363        assert_eq!(session.graph().unwrap().id, "minimal-value");
3364        assert!(
3365            session
3366                .view_state()
3367                .unwrap()
3368                .canvas
3369                .nodes
3370                .contains_key("value_1")
3371        );
3372    }
3373
3374    #[test]
3375    fn patch_without_loaded_session_returns_error() {
3376        let mut session = RuntimeSession::default();
3377
3378        let response = session.apply_patch(set_value_patch("1", 0.75));
3379
3380        assert!(!response.ok);
3381        assert!(!response.applied);
3382        assert!(!response.conflict);
3383        assert!(response.snapshot.project.is_none());
3384        assert!(!response.snapshot.loaded());
3385        assert!(
3386            response.diagnostics[0]
3387                .message
3388                .contains("no project loaded in runtime session")
3389        );
3390    }
3391
3392    #[test]
3393    fn patch_with_matching_revision_applies_and_rebuilds_plan() {
3394        let mut session = RuntimeSession::default();
3395        let loaded = load_sample_project(&mut session);
3396        assert!(loaded.ok);
3397
3398        let response = session.apply_patch(set_value_patch("1", 0.75));
3399
3400        assert_graph_patch_rejected(&response);
3401        assert_eq!(response.history.entries.len(), 0);
3402        assert_eq!(response.history.undo_depth, 0);
3403        assert_eq!(response.history.redo_depth, 0);
3404        assert_eq!(patch_graph(&response).revision, "1");
3405        assert_eq!(response.snapshot.graph_revision(), Some("1"));
3406        assert_eq!(response.snapshot.session_revision, 1);
3407        assert_eq!(
3408            session.control_state.value_for_node("value_1"),
3409            Some(&ControlValue::float(0.0))
3410        );
3411    }
3412
3413    #[test]
3414    fn unresolved_object_loads_session_with_error_diagnostic() {
3415        let mut session = RuntimeSession::default();
3416
3417        let response = session.load_project_current(unresolved_project_current());
3418
3419        assert!(response.ok);
3420        assert!(response.snapshot.loaded());
3421        assert!(response.diagnostics.iter().any(|diagnostic| {
3422            diagnostic
3423                .message
3424                .contains("unresolved object user.manipulator")
3425        }));
3426        assert_eq!(session.snapshot().diagnostics, response.diagnostics);
3427
3428        let plan = session.plan_current();
3429        assert!(plan.ok);
3430        assert!(plan.diagnostics.iter().any(|diagnostic| {
3431            diagnostic
3432                .message
3433                .contains("unresolved object user.manipulator")
3434        }));
3435    }
3436
3437    #[test]
3438    fn replace_node_with_unresolved_object_applies_with_error_diagnostic() {
3439        let mut session = RuntimeSession::default();
3440        let loaded =
3441            session.load_project_current(sample_project_current_with_unresolved_definition());
3442        assert!(loaded.ok);
3443
3444        let response = session.apply_patch(graph_patch(json!({
3445          "schema": "skenion.graph.patch",
3446          "schemaVersion": "0.1.0",
3447          "id": "replace-target-unresolved",
3448          "baseRevision": "1",
3449          "ops": [
3450            {
3451              "op": "replaceNode",
3452              "nodeId": "target_1",
3453              "node": unresolved_node_json("target_1", "user.manipulator"),
3454              "edgePolicy": "removeInvalidEdges"
3455            }
3456          ]
3457        })));
3458
3459        assert_graph_patch_rejected(&response);
3460        assert!(response.snapshot.loaded());
3461        assert_eq!(patch_graph(&response).revision, "1");
3462    }
3463
3464    #[test]
3465    fn patch_with_wrong_base_revision_conflicts_without_mutating_session() {
3466        let mut session = RuntimeSession::default();
3467        load_sample_project(&mut session);
3468
3469        let response = session.apply_patch(set_value_patch("0", 0.75));
3470        let snapshot = session.snapshot();
3471
3472        assert_graph_patch_rejected(&response);
3473        assert!(latest_history_entry(&response).is_none());
3474        assert!((response.history.entries).is_empty());
3475        assert_eq!(patch_graph(&response).revision, "1");
3476        assert_eq!(snapshot.graph_revision(), Some("1"));
3477        assert_eq!(snapshot.session_revision, 1);
3478    }
3479
3480    #[test]
3481    fn invalid_patch_operations_do_not_mutate_session() {
3482        let mut session = RuntimeSession::default();
3483        load_sample_project(&mut session);
3484
3485        let duplicate = session.apply_patch(duplicate_edge_patch());
3486        let missing = session.apply_patch(missing_node_patch());
3487        let snapshot = session.snapshot();
3488
3489        assert_graph_patch_rejected(&duplicate);
3490        assert!(latest_history_entry(&duplicate).is_none());
3491        assert!((duplicate.history.entries).is_empty());
3492        assert_graph_patch_rejected(&missing);
3493        assert_eq!(snapshot.graph_revision(), Some("1"));
3494        assert_eq!(snapshot.session_revision, 1);
3495    }
3496
3497    #[test]
3498    fn incompatible_patch_result_does_not_mutate_session() {
3499        let mut session = RuntimeSession::default();
3500        load_sample_project(&mut session);
3501
3502        let response = session.apply_patch(incompatible_edge_patch());
3503        let snapshot = session.snapshot();
3504
3505        assert_graph_patch_rejected(&response);
3506        assert_eq!(snapshot.graph_revision(), Some("1"));
3507        assert_eq!(snapshot.session_revision, 1);
3508    }
3509
3510    #[test]
3511    fn registry_invalid_patch_result_does_not_mutate_session() {
3512        let mut session = RuntimeSession::default();
3513        load_sample_project(&mut session);
3514
3515        let response = session.apply_patch(missing_definition_node_patch());
3516        let snapshot = session.snapshot();
3517
3518        assert_graph_patch_rejected(&response);
3519        assert_eq!(snapshot.graph_revision(), Some("1"));
3520        assert_eq!(snapshot.session_revision, 1);
3521    }
3522
3523    #[test]
3524    fn remove_node_patch_removes_incident_edges() {
3525        let mut session = RuntimeSession::default();
3526        load_sample_project(&mut session);
3527
3528        let response = session.apply_patch(graph_patch(json!({
3529          "schema": "skenion.graph.patch",
3530          "schemaVersion": "0.1.0",
3531          "id": "remove-node",
3532          "baseRevision": "1",
3533          "ops": [
3534            { "op": "removeNode", "nodeId": "value_1" }
3535          ]
3536        })));
3537
3538        assert_graph_patch_rejected(&response);
3539        let graph = patch_graph(&response);
3540        assert_eq!(graph.revision, "1");
3541        assert!(graph.nodes.iter().any(|node| node.id == "value_1"));
3542        assert_eq!(graph.edges.len(), 1);
3543    }
3544
3545    #[test]
3546    fn patch_non_numeric_revision_gets_suffix() {
3547        let mut project = sample_project_current();
3548        project.graph.revision = "rev_0001".to_owned();
3549        let mut session = RuntimeSession::default();
3550        session.load_project_current(project);
3551
3552        let response = session.apply_patch(set_value_patch("rev_0001", 0.75));
3553
3554        assert_graph_patch_rejected(&response);
3555        assert_eq!(patch_graph(&response).revision, "rev_0001");
3556    }
3557
3558    #[test]
3559    fn history_starts_empty_and_undo_redo_empty_stack_returns_errors() {
3560        let mut session = RuntimeSession::default();
3561
3562        let history = session.history();
3563        let undo = session.undo();
3564        let redo = session.redo();
3565
3566        assert_eq!(history.schema, "skenion.runtime.history");
3567        assert!(!history.can_undo);
3568        assert!(!history.can_redo);
3569        assert!(!undo.ok);
3570        assert!(!undo.applied);
3571        assert!(latest_history_entry(&undo).is_none());
3572        assert!(undo.diagnostics[0].message.contains("available to undo"));
3573        assert!(!redo.ok);
3574        assert!(!redo.applied);
3575        assert!(latest_history_entry(&redo).is_none());
3576        assert!(redo.diagnostics[0].message.contains("available to redo"));
3577    }
3578
3579    #[test]
3580    fn undo_after_patch_restores_graph_and_records_history_entry() {
3581        let mut session = RuntimeSession::default();
3582        load_sample_project(&mut session);
3583        let applied = session.apply_runtime_operation(paste_operation("1"));
3584        assert!(applied.ok);
3585        let apply_event_id = applied.history_entry_id.clone().unwrap();
3586
3587        let undone = session.undo();
3588
3589        assert!(undone.ok);
3590        assert!(undone.applied);
3591        assert_eq!(patch_graph(&undone).revision, "3");
3592        assert!(
3593            !patch_graph(&undone)
3594                .nodes
3595                .iter()
3596                .any(|node| node.id == "pasted_target")
3597        );
3598        assert_eq!(undone.snapshot.session_revision, 3);
3599        let undo_entry = latest_history_entry(&undone).unwrap();
3600        assert_eq!(undo_entry.kind, RuntimeHistoryEntryKind::Undo);
3601        assert_eq!(
3602            undo_entry.subject_event_id.as_deref(),
3603            Some(apply_event_id.as_str())
3604        );
3605        assert!(undo_entry.mutation.graph_patch.is_none());
3606        assert!(undo_entry.inverse_mutation.graph_patch.is_none());
3607        assert_eq!((undone.history.entries).len(), 2);
3608        assert_eq!(undone.history.undo_depth, 0);
3609        assert_eq!(undone.history.redo_depth, 1);
3610    }
3611
3612    #[test]
3613    fn redo_after_undo_reapplies_graph_and_records_history_entry() {
3614        let mut session = RuntimeSession::default();
3615        load_sample_project(&mut session);
3616        session.apply_runtime_operation(paste_operation("1"));
3617        session.undo();
3618
3619        let redone = session.redo();
3620
3621        assert!(redone.ok);
3622        assert!(redone.applied);
3623        assert_eq!(patch_graph(&redone).revision, "4");
3624        assert!(
3625            patch_graph(&redone)
3626                .nodes
3627                .iter()
3628                .any(|node| node.id == "pasted_target")
3629        );
3630        assert_eq!(redone.snapshot.session_revision, 4);
3631        let redo_entry = latest_history_entry(&redone).unwrap();
3632        assert_eq!(redo_entry.kind, RuntimeHistoryEntryKind::Redo);
3633        assert!(redo_entry.mutation.graph_patch.is_none());
3634        assert!(redo_entry.inverse_mutation.graph_patch.is_none());
3635        assert_eq!((redone.history.entries).len(), 3);
3636        assert_eq!(redone.history.undo_depth, 1);
3637        assert_eq!(redone.history.redo_depth, 0);
3638    }
3639
3640    #[test]
3641    fn view_state_patch_undo_redo_moves_once_from_start_to_end() {
3642        let mut session = RuntimeSession::default();
3643        let loaded = load_sample_project(&mut session);
3644        assert!(loaded.ok);
3645        let mut start = loaded
3646            .snapshot
3647            .view_state()
3648            .cloned()
3649            .expect("loaded view state");
3650        start.canvas.viewport = None;
3651        let mut moved = start.clone();
3652        moved.canvas.nodes.get_mut("value_1").unwrap().x += 240.0;
3653        moved.canvas.nodes.get_mut("value_1").unwrap().y += 120.0;
3654
3655        let applied = session.apply_mutation(RuntimeMutationRequest {
3656            graph_patch: None,
3657            view_patch: Some(RuntimeViewPatch {
3658                base_view_revision: 1,
3659                ops: vec![RuntimeViewPatchOperation::MoveNodeView {
3660                    node_id: "value_1".to_owned(),
3661                    from: Some(start.canvas.nodes["value_1"].clone()),
3662                    to: moved.canvas.nodes["value_1"].clone(),
3663                }],
3664            }),
3665            actor_id: None,
3666            client_id: Some("studio-a".to_owned()),
3667            description: Some("drag value_1".to_owned()),
3668        });
3669
3670        assert!(applied.ok);
3671        assert!(applied.applied);
3672        let apply_entry = latest_history_entry(&applied).unwrap();
3673        assert_eq!(apply_entry.kind, RuntimeHistoryEntryKind::Apply);
3674        assert!(apply_entry.mutation.graph_patch.is_none());
3675        assert!(apply_entry.mutation.view_patch.is_some());
3676        assert_eq!(applied.history.undo_depth, 1);
3677        assert_eq!(applied.snapshot.view_revision, 2);
3678        assert_eq!(patch_view_state(&applied), &moved);
3679
3680        let undone = session.undo();
3681
3682        assert!(undone.ok);
3683        assert!(undone.applied);
3684        let undo_entry = latest_history_entry(&undone).unwrap();
3685        assert_eq!(undo_entry.kind, RuntimeHistoryEntryKind::Undo);
3686        assert!(undo_entry.mutation.graph_patch.is_none());
3687        assert!(undo_entry.mutation.view_patch.is_some());
3688        assert_eq!(undone.history.undo_depth, 0);
3689        assert_eq!(undone.history.redo_depth, 1);
3690        assert_eq!(undone.snapshot.view_revision, 3);
3691        assert_eq!(patch_view_state(&undone), &start);
3692
3693        let redone = session.redo();
3694
3695        assert!(redone.ok);
3696        assert!(redone.applied);
3697        let redo_entry = latest_history_entry(&redone).unwrap();
3698        assert_eq!(redo_entry.kind, RuntimeHistoryEntryKind::Redo);
3699        assert!(redo_entry.mutation.graph_patch.is_none());
3700        assert!(redo_entry.mutation.view_patch.is_some());
3701        assert_eq!(redone.history.undo_depth, 1);
3702        assert_eq!(redone.history.redo_depth, 0);
3703        assert_eq!(redone.snapshot.view_revision, 4);
3704        assert_eq!(patch_view_state(&redone), &moved);
3705    }
3706
3707    #[test]
3708    fn empty_and_conflicting_view_mutations_are_rejected_without_history() {
3709        let mut session = RuntimeSession::default();
3710        assert!(load_sample_project(&mut session).ok);
3711
3712        let empty = session.apply_mutation(RuntimeMutationRequest {
3713            graph_patch: None,
3714            view_patch: None,
3715            actor_id: None,
3716            client_id: None,
3717            description: None,
3718        });
3719        let conflict = session.apply_mutation(RuntimeMutationRequest {
3720            graph_patch: None,
3721            view_patch: Some(RuntimeViewPatch {
3722                base_view_revision: 99,
3723                ops: Vec::new(),
3724            }),
3725            actor_id: None,
3726            client_id: None,
3727            description: None,
3728        });
3729
3730        assert!(!empty.ok);
3731        assert!(!empty.applied);
3732        assert!(empty.diagnostics[0].message.contains("did not include"));
3733        assert!(!conflict.ok);
3734        assert!(conflict.conflict);
3735        assert!(conflict.diagnostics[0].message.contains("baseViewRevision"));
3736        assert_eq!(conflict.history.entries.len(), 0);
3737    }
3738
3739    #[test]
3740    fn view_patch_set_node_view_success_errors_and_noop_paths() {
3741        let mut session = RuntimeSession::default();
3742        let loaded = load_sample_project(&mut session);
3743        assert!(loaded.ok);
3744        let start = loaded
3745            .snapshot
3746            .view_state()
3747            .cloned()
3748            .expect("loaded view state");
3749        let value_view = start.canvas.nodes["value_1"].clone();
3750        let mut moved_view = value_view.clone();
3751        moved_view.x += 80.0;
3752
3753        let set = session.apply_mutation(RuntimeMutationRequest {
3754            graph_patch: None,
3755            view_patch: Some(RuntimeViewPatch {
3756                base_view_revision: 1,
3757                ops: vec![RuntimeViewPatchOperation::SetNodeView {
3758                    node_id: "value_1".to_owned(),
3759                    view: moved_view.clone(),
3760                }],
3761            }),
3762            actor_id: None,
3763            client_id: None,
3764            description: Some("set node view".to_owned()),
3765        });
3766        assert!(set.ok);
3767        assert!(set.applied);
3768        assert_eq!(patch_view_state(&set).canvas.nodes["value_1"], moved_view);
3769
3770        let noop = session.apply_mutation(RuntimeMutationRequest {
3771            graph_patch: None,
3772            view_patch: Some(RuntimeViewPatch {
3773                base_view_revision: 2,
3774                ops: vec![RuntimeViewPatchOperation::SetNodeView {
3775                    node_id: "value_1".to_owned(),
3776                    view: moved_view.clone(),
3777                }],
3778            }),
3779            actor_id: None,
3780            client_id: None,
3781            description: None,
3782        });
3783        assert!(noop.ok);
3784        assert!(!noop.applied);
3785
3786        let missing_node = session.apply_mutation(RuntimeMutationRequest {
3787            graph_patch: None,
3788            view_patch: Some(RuntimeViewPatch {
3789                base_view_revision: 2,
3790                ops: vec![RuntimeViewPatchOperation::SetNodeView {
3791                    node_id: "missing".to_owned(),
3792                    view: value_view.clone(),
3793                }],
3794            }),
3795            actor_id: None,
3796            client_id: None,
3797            description: None,
3798        });
3799        assert!(!missing_node.ok);
3800        assert!(
3801            missing_node.diagnostics[0]
3802                .message
3803                .contains("does not exist")
3804        );
3805    }
3806
3807    #[test]
3808    fn view_patch_helper_reports_missing_view_and_from_mismatch() {
3809        let mut session = RuntimeSession::default();
3810        let loaded = load_sample_project(&mut session);
3811        assert!(loaded.ok);
3812        let graph = session.graph().expect("loaded graph");
3813        let mut view_state = loaded
3814            .snapshot
3815            .view_state()
3816            .cloned()
3817            .expect("loaded view state");
3818        let value_view = view_state.canvas.nodes["value_1"].clone();
3819        let mut moved_view = value_view.clone();
3820        moved_view.y += 80.0;
3821
3822        view_state.canvas.nodes.remove("value_1");
3823        let missing_set_view = super::apply_view_patch_to_view_state(
3824            &graph,
3825            view_state.clone(),
3826            &RuntimeViewPatch {
3827                base_view_revision: 1,
3828                ops: vec![RuntimeViewPatchOperation::SetNodeView {
3829                    node_id: "value_1".to_owned(),
3830                    view: moved_view.clone(),
3831                }],
3832            },
3833        );
3834        let missing_move_view = super::apply_view_patch_to_view_state(
3835            &graph,
3836            view_state,
3837            &RuntimeViewPatch {
3838                base_view_revision: 1,
3839                ops: vec![RuntimeViewPatchOperation::MoveNodeView {
3840                    node_id: "value_1".to_owned(),
3841                    from: None,
3842                    to: moved_view.clone(),
3843                }],
3844            },
3845        );
3846        let missing_move_node = super::apply_view_patch_to_view_state(
3847            &graph,
3848            loaded.snapshot.view_state().cloned().unwrap(),
3849            &RuntimeViewPatch {
3850                base_view_revision: 1,
3851                ops: vec![RuntimeViewPatchOperation::MoveNodeView {
3852                    node_id: "missing".to_owned(),
3853                    from: None,
3854                    to: moved_view.clone(),
3855                }],
3856            },
3857        );
3858
3859        let mut mismatched_from = value_view.clone();
3860        mismatched_from.x += 1.0;
3861        let from_mismatch = super::apply_view_patch_to_view_state(
3862            &graph,
3863            loaded.snapshot.view_state().cloned().unwrap(),
3864            &RuntimeViewPatch {
3865                base_view_revision: 1,
3866                ops: vec![RuntimeViewPatchOperation::MoveNodeView {
3867                    node_id: "value_1".to_owned(),
3868                    from: Some(mismatched_from),
3869                    to: moved_view,
3870                }],
3871            },
3872        );
3873
3874        assert!(
3875            missing_set_view
3876                .unwrap_err()
3877                .first()
3878                .unwrap()
3879                .message
3880                .contains("has no view state")
3881        );
3882        assert!(
3883            missing_move_view
3884                .unwrap_err()
3885                .first()
3886                .unwrap()
3887                .message
3888                .contains("has no view state")
3889        );
3890        assert!(
3891            missing_move_node
3892                .unwrap_err()
3893                .first()
3894                .unwrap()
3895                .message
3896                .contains("does not exist")
3897        );
3898        assert!(
3899            from_mismatch
3900                .unwrap_err()
3901                .first()
3902                .unwrap()
3903                .message
3904                .contains("from view does not match")
3905        );
3906    }
3907
3908    #[test]
3909    fn combined_graph_and_noop_view_mutation_keeps_view_revision_stable() {
3910        let mut session = RuntimeSession::default();
3911        let loaded = load_sample_project(&mut session);
3912        assert!(loaded.ok);
3913        let value_view = loaded.snapshot.view_state().unwrap().canvas.nodes["value_1"].clone();
3914
3915        let response = session.apply_mutation(RuntimeMutationRequest {
3916            graph_patch: Some(set_value_patch("1", 0.5)),
3917            view_patch: Some(RuntimeViewPatch {
3918                base_view_revision: 1,
3919                ops: vec![RuntimeViewPatchOperation::SetNodeView {
3920                    node_id: "value_1".to_owned(),
3921                    view: value_view,
3922                }],
3923            }),
3924            actor_id: None,
3925            client_id: None,
3926            description: Some("set graph without moving view".to_owned()),
3927        });
3928
3929        assert_graph_patch_rejected(&response);
3930        assert_eq!(response.snapshot.graph_revision(), Some("1"));
3931        assert_eq!(response.snapshot.view_revision, 1);
3932        assert!(latest_history_entry(&response).is_none());
3933    }
3934
3935    #[test]
3936    fn new_patch_after_undo_clears_redo_stack() {
3937        let mut session = RuntimeSession::default();
3938        load_sample_project(&mut session);
3939        session.apply_runtime_operation(paste_operation("1"));
3940        let undone = session.undo();
3941        assert_eq!(undone.history.redo_depth, 1);
3942
3943        let applied = session.apply_runtime_operation(paste_operation("3"));
3944
3945        assert!(applied.ok);
3946        assert_eq!(applied.revision_after.as_deref(), Some("4"));
3947        let history = session.history();
3948        assert_eq!(history.entries.len(), 3);
3949        assert_eq!(history.undo_depth, 1);
3950        assert_eq!(history.redo_depth, 0);
3951        assert!(!history.can_redo);
3952    }
3953
3954    #[test]
3955    fn graph_patch_remove_node_patch_is_rejected_without_history() {
3956        let mut session = RuntimeSession::default();
3957        load_sample_project(&mut session);
3958        let removed = session.apply_patch(graph_patch(json!({
3959          "schema": "skenion.graph.patch",
3960          "schemaVersion": "0.1.0",
3961          "id": "remove-node",
3962          "baseRevision": "1",
3963          "ops": [
3964            { "op": "removeNode", "nodeId": "value_1" }
3965          ]
3966        })));
3967
3968        assert_graph_patch_rejected(&removed);
3969        assert!(
3970            patch_graph(&removed)
3971                .nodes
3972                .iter()
3973                .any(|node| node.id == "value_1")
3974        );
3975        assert_eq!(patch_graph(&removed).edges.len(), 1);
3976        assert_eq!(removed.history.undo_depth, 0);
3977    }
3978
3979    #[test]
3980    fn graph_patch_connection_and_delete_patches_are_rejected_without_history() {
3981        let mut project = sample_project_current();
3982        project.graph.edges.clear();
3983        let mut session = RuntimeSession::default();
3984        assert!(session.load_project_current(project).ok);
3985        let connected = session.apply_patch(duplicate_edge_patch());
3986        assert_graph_patch_rejected(&connected);
3987        assert!(patch_graph(&connected).edges.is_empty());
3988        let deleted = session.apply_patch(graph_patch(json!({
3989          "schema": "skenion.graph.patch",
3990          "schemaVersion": "0.1.0",
3991          "id": "delete-target",
3992          "baseRevision": "2",
3993          "ops": [
3994            { "op": "removeNode", "nodeId": "target_1" }
3995          ]
3996        })));
3997        assert_graph_patch_rejected(&deleted);
3998        assert!(patch_graph(&deleted).edges.is_empty());
3999        assert_eq!(deleted.history.undo_depth, 0);
4000    }
4001
4002    #[test]
4003    fn multiple_undo_operations_keep_advancing_revision() {
4004        let mut session = RuntimeSession::default();
4005        load_sample_project(&mut session);
4006        session.apply_runtime_operation(paste_operation("1"));
4007        session.apply_runtime_operation(paste_operation("2"));
4008
4009        let first_undo = session.undo();
4010        let second_undo = session.undo();
4011
4012        assert!(first_undo.ok);
4013        assert_eq!(patch_graph(&first_undo).revision, "4");
4014        assert!(
4015            !patch_graph(&first_undo)
4016                .nodes
4017                .iter()
4018                .any(|node| node.id == "pasted_target_2")
4019        );
4020        assert!(second_undo.ok);
4021        assert_eq!(patch_graph(&second_undo).revision, "5");
4022        assert!(
4023            !patch_graph(&second_undo)
4024                .nodes
4025                .iter()
4026                .any(|node| node.id == "pasted_target")
4027        );
4028        assert_eq!((second_undo.history.entries).len(), 4);
4029        assert_eq!(second_undo.history.redo_depth, 2);
4030    }
4031
4032    #[test]
4033    fn failed_history_operations_do_not_mutate_stacks_or_session() {
4034        let mut no_loaded = RuntimeSession::default();
4035        no_loaded.undo_stack.push(HistoryEntry::Mutation {
4036            event_id: "event_bad".to_owned(),
4037            actor_id: None,
4038            mutation: graph_mutation(set_value_patch("1", 0.75)),
4039            inverse_mutation: graph_mutation(set_value_patch("1", 0.5)),
4040        });
4041        let no_loaded_response = no_loaded.undo();
4042        assert!(!no_loaded_response.ok);
4043        assert_eq!(no_loaded_response.history.undo_depth, 1);
4044        assert!(
4045            no_loaded_response.diagnostics[0]
4046                .message
4047                .contains("no project loaded")
4048        );
4049
4050        let mut invalid_inverse = RuntimeSession::default();
4051        load_sample_project(&mut invalid_inverse);
4052        invalid_inverse.undo_stack.push(HistoryEntry::Mutation {
4053            event_id: "event_bad_inverse".to_owned(),
4054            actor_id: None,
4055            mutation: graph_mutation(set_value_patch("1", 0.75)),
4056            inverse_mutation: graph_mutation(missing_node_patch()),
4057        });
4058        let invalid_inverse_response = invalid_inverse.undo();
4059        assert!(!invalid_inverse_response.ok);
4060        assert_eq!(invalid_inverse_response.history.undo_depth, 1);
4061        assert_eq!(
4062            invalid_inverse_response.snapshot.graph_revision(),
4063            Some("1")
4064        );
4065
4066        let mut invalid_redo = RuntimeSession::default();
4067        load_sample_project(&mut invalid_redo);
4068        invalid_redo.redo_stack.push(HistoryEntry::Mutation {
4069            event_id: "event_bad_redo".to_owned(),
4070            actor_id: None,
4071            mutation: graph_mutation(missing_definition_node_patch()),
4072            inverse_mutation: graph_mutation(set_value_patch("1", 0.5)),
4073        });
4074        let invalid_redo_response = invalid_redo.redo();
4075        assert!(!invalid_redo_response.ok);
4076        assert_eq!(invalid_redo_response.history.redo_depth, 1);
4077        assert_eq!(
4078            invalid_redo_response.diagnostics[0].code.as_deref(),
4079            Some("project.graph-patch-unsupported")
4080        );
4081
4082        let mut no_actor_history = RuntimeSession::default();
4083        load_sample_project(&mut no_actor_history);
4084        let no_actor_undo = no_actor_history.undo_for_actor("participant-a");
4085        let no_actor_redo = no_actor_history.redo_for_actor("participant-a");
4086        assert!(!no_actor_undo.ok);
4087        assert!(no_actor_undo.diagnostics[0].message.contains("actor"));
4088        assert!(!no_actor_redo.ok);
4089        assert!(no_actor_redo.diagnostics[0].message.contains("actor"));
4090
4091        let mut invalid_actor_inverse = RuntimeSession::default();
4092        load_sample_project(&mut invalid_actor_inverse);
4093        invalid_actor_inverse
4094            .undo_stack
4095            .push(HistoryEntry::Mutation {
4096                event_id: "event_bad_actor_inverse".to_owned(),
4097                actor_id: Some("participant-a".to_owned()),
4098                mutation: graph_mutation(set_value_patch("1", 0.75)),
4099                inverse_mutation: graph_mutation(missing_node_patch()),
4100            });
4101        let invalid_actor_inverse_response = invalid_actor_inverse.undo_for_actor("participant-a");
4102        assert!(!invalid_actor_inverse_response.ok);
4103        assert_eq!(invalid_actor_inverse_response.history.undo_depth, 1);
4104
4105        let mut invalid_actor_redo = RuntimeSession::default();
4106        load_sample_project(&mut invalid_actor_redo);
4107        invalid_actor_redo.redo_stack.push(HistoryEntry::Mutation {
4108            event_id: "event_bad_actor_redo".to_owned(),
4109            actor_id: Some("participant-a".to_owned()),
4110            mutation: graph_mutation(missing_definition_node_patch()),
4111            inverse_mutation: graph_mutation(set_value_patch("1", 0.5)),
4112        });
4113        let invalid_actor_redo_response = invalid_actor_redo.redo_for_actor("participant-a");
4114        assert!(!invalid_actor_redo_response.ok);
4115        assert_eq!(invalid_actor_redo_response.history.redo_depth, 1);
4116    }
4117
4118    #[test]
4119    fn reject_patch_uses_current_session_snapshot() {
4120        let mut session = RuntimeSession::default();
4121        load_sample_project(&mut session);
4122
4123        let response = session.reject_patch(
4124            false,
4125            vec![RuntimeDiagnostic::error(
4126                "invalid graph patch: unsupported op",
4127            )],
4128        );
4129
4130        assert!(!response.ok);
4131        assert!(!response.applied);
4132        assert!(latest_history_entry(&response).is_none());
4133        assert_eq!((response.history.entries).len(), 0);
4134        assert_eq!(patch_graph(&response).revision, "1");
4135        assert_eq!(response.snapshot.graph_revision(), Some("1"));
4136        assert!(response.diagnostics[0].message.contains("unsupported op"));
4137    }
4138
4139    #[test]
4140    fn paste_graph_fragment_lowers_to_root_graph_mutation_with_id_remap() {
4141        let mut session = RuntimeSession::default();
4142        load_sample_project(&mut session);
4143
4144        let response = session.apply_runtime_operation(paste_operation("1"));
4145
4146        assert!(response.ok);
4147        assert!(response.applied);
4148        assert!(!response.conflict);
4149        assert_eq!(response.revision_before, "1");
4150        assert_eq!(response.revision_after.as_deref(), Some("2"));
4151        assert_eq!(
4152            response
4153                .id_remap
4154                .node_id_map
4155                .get("value_1")
4156                .map(String::as_str),
4157            Some("value_1_2")
4158        );
4159        assert_eq!(
4160            response
4161                .id_remap
4162                .edge_id_map
4163                .get("edge_value_to_pasted")
4164                .map(String::as_str),
4165            Some("edge_value_to_pasted")
4166        );
4167        let graph = session.graph().expect("graph should remain loaded");
4168        assert!(graph.nodes.iter().any(|node| node.id == "value_1_2"));
4169        assert!(graph.nodes.iter().any(|node| node.id == "pasted_target"));
4170        assert!(graph.edges.iter().any(|edge| {
4171            edge.from.node == "value_1_2"
4172                && edge.from.port == "value"
4173                && edge.to.node == "pasted_target"
4174                && edge.to.port == "cold"
4175        }));
4176        assert_eq!(
4177            response.history_entry_id.as_deref(),
4178            Some("runtime_event_000001")
4179        );
4180    }
4181
4182    #[test]
4183    fn paste_graph_fragment_remaps_past_existing_generated_ids() {
4184        let mut session = RuntimeSession::default();
4185        load_sample_project(&mut session);
4186        let first = session.apply_runtime_operation(paste_operation("1"));
4187        assert!(first.ok);
4188
4189        let second = session.apply_runtime_operation(paste_operation("2"));
4190
4191        assert!(second.ok);
4192        assert_eq!(
4193            second
4194                .id_remap
4195                .node_id_map
4196                .get("value_1")
4197                .map(String::as_str),
4198            Some("value_1_3")
4199        );
4200    }
4201
4202    #[test]
4203    fn paste_graph_fragment_uses_default_descriptions_without_attribution() {
4204        let mut session = RuntimeSession::default();
4205        load_sample_project(&mut session);
4206        let mut operation = paste_operation("1");
4207        operation.attribution = None;
4208
4209        let response = session.apply_runtime_operation(operation);
4210
4211        assert!(response.ok);
4212        let mut history = session.history();
4213        let entry = history.entries.pop().expect("history should exist");
4214        assert_eq!(
4215            entry.description.as_deref(),
4216            Some("Paste graph fragment op-paste")
4217        );
4218        assert!(entry.mutation.graph_patch.is_none());
4219    }
4220
4221    #[test]
4222    fn paste_graph_fragment_reports_no_loaded_project() {
4223        let mut session = RuntimeSession::default();
4224
4225        let response = session.apply_runtime_operation(paste_operation("1"));
4226
4227        assert!(!response.ok);
4228        assert!(!response.applied);
4229        assert_eq!(response.revision_before, "1");
4230        assert_eq!(response.diagnostics[0].code, "paste.target.no-project");
4231    }
4232
4233    #[test]
4234    fn paste_graph_fragment_rejects_invalid_operation_envelope() {
4235        let mut session = RuntimeSession::default();
4236        load_sample_project(&mut session);
4237        let mut operation = paste_operation("1");
4238        operation.kind = "loadProject".to_owned();
4239
4240        let response = session.apply_runtime_operation(operation);
4241
4242        assert!(!response.ok);
4243        assert!(!response.applied);
4244        assert_eq!(
4245            response.diagnostics[0].code,
4246            "paste.operation.invalid-envelope"
4247        );
4248        assert!(
4249            response.diagnostics[0]
4250                .message
4251                .contains("unsupported runtime operation kind")
4252        );
4253    }
4254
4255    #[test]
4256    fn paste_graph_fragment_rejects_id_conflicts_when_requested() {
4257        let mut session = RuntimeSession::default();
4258        load_sample_project(&mut session);
4259        let mut operation = paste_operation("1");
4260        operation.request.options = Some(skenion_contracts::PasteGraphFragmentOptions {
4261            outside_endpoint_policy: None,
4262            id_conflict_policy: Some(skenion_contracts::IdConflictPolicy::Reject),
4263            preserve_relative_positions: None,
4264        });
4265
4266        let response = session.apply_runtime_operation(operation);
4267
4268        assert!(!response.ok);
4269        assert!(!response.applied);
4270        assert_eq!(response.diagnostics[0].code, "paste.id-conflict");
4271        assert_eq!(
4272            response.diagnostics[0].duplicates.as_deref(),
4273            Some(&["value_1".to_owned()][..])
4274        );
4275        assert_eq!(
4276            response
4277                .id_remap
4278                .node_id_map
4279                .get("value_1")
4280                .map(String::as_str),
4281            Some("value_1")
4282        );
4283    }
4284
4285    #[test]
4286    fn paste_graph_fragment_reports_apply_mutation_failures_as_operation_diagnostics() {
4287        let mut session = RuntimeSession::default();
4288        load_sample_project(&mut session);
4289        let mut operation = paste_operation("1");
4290        operation.request.fragment.nodes[1].kind = "missing.kind".to_owned();
4291
4292        let response = session.apply_runtime_operation(operation);
4293
4294        assert!(!response.ok);
4295        assert!(!response.applied);
4296        assert_eq!(response.history_entry_id, None);
4297        assert_eq!(response.revision_after, None);
4298        assert_eq!(response.diagnostics[0].code, "node-definition.missing");
4299        assert!(
4300            response.diagnostics[0]
4301                .message
4302                .contains("missing node definition")
4303        );
4304    }
4305
4306    #[test]
4307    fn paste_operation_validation_reports_fragment_analysis_errors() {
4308        let mut session = RuntimeSession::default();
4309        session.load_project_current(sample_project_current());
4310        let mut operation = paste_operation("1");
4311        operation.request.fragment.nodes[1].ports[1].id = "renamed".to_owned();
4312
4313        let response = session.apply_runtime_operation(operation);
4314
4315        assert!(!response.ok);
4316        assert!(!response.applied);
4317        assert_eq!(
4318            response.diagnostics[0].code,
4319            "paste.operation.invalid-envelope"
4320        );
4321        assert!(
4322            response.diagnostics[0]
4323                .message
4324                .contains("missing-target-port")
4325        );
4326        assert!(response.id_remap.node_id_map.is_empty());
4327    }
4328
4329    #[test]
4330    fn paste_lowering_skips_fragment_view_entries_missing_from_view_map() {
4331        let mut operation = paste_operation("1");
4332        operation
4333            .request
4334            .fragment
4335            .view
4336            .as_mut()
4337            .expect("fragment should include view")
4338            .nodes
4339            .as_mut()
4340            .expect("fragment view should include nodes")
4341            .remove("pasted_target");
4342        let node_id_map = [("pasted_target".to_owned(), "pasted_target".to_owned())]
4343            .into_iter()
4344            .collect();
4345
4346        let patch = lower_fragment_view_patch(1, &operation.request, &node_id_map);
4347
4348        assert!(patch.is_none());
4349    }
4350
4351    #[test]
4352    fn paste_lowering_handles_absent_fragment_view_and_unmapped_edge_endpoints() {
4353        let mut operation = paste_operation("1");
4354        operation.request.fragment.view = None;
4355
4356        let patch = lower_fragment_view_patch(1, &operation.request, &BTreeMap::new());
4357
4358        assert!(patch.is_none());
4359
4360        operation.request.fragment.view =
4361            Some(skenion_contracts::GraphFragmentViewV01 { nodes: None });
4362        let patch = lower_fragment_view_patch(1, &operation.request, &BTreeMap::new());
4363        assert!(patch.is_none());
4364
4365        let edge = EdgeSpecCurrent {
4366            id: "edge".to_owned(),
4367            source: EdgeEndpointCurrent {
4368                node_id: "outside_source".to_owned(),
4369                port_id: "out".to_owned(),
4370            },
4371            target: EdgeEndpointCurrent {
4372                node_id: "outside_target".to_owned(),
4373                port_id: "in".to_owned(),
4374            },
4375            resolved_type: None,
4376            order: None,
4377            enabled: None,
4378            adapter: None,
4379            feedback: None,
4380            style_override: None,
4381            label: None,
4382            description: None,
4383        };
4384
4385        let remapped = remap_edge(&edge, &BTreeMap::new());
4386
4387        assert_eq!(remapped.from.node, "outside_source");
4388        assert_eq!(remapped.to.node, "outside_target");
4389    }
4390
4391    #[test]
4392    fn runtime_diagnostic_conversion_preserves_severity_and_code_defaults() {
4393        let target = skenion_contracts::GraphTargetRef {
4394            path: skenion_contracts::PatchPath::Root,
4395            base_revision: "1".to_owned(),
4396            target_revision: None,
4397        };
4398        let error = RuntimeDiagnostic::error("plain error");
4399        let warning = RuntimeDiagnostic {
4400            severity: crate::DiagnosticSeverity::Warning,
4401            message: "coded warning".to_owned(),
4402            code: Some("runtime.warning".to_owned()),
4403            details: None,
4404        };
4405        let info = RuntimeDiagnostic {
4406            severity: crate::DiagnosticSeverity::Info,
4407            message: "info".to_owned(),
4408            code: Some("runtime.info".to_owned()),
4409            details: None,
4410        };
4411
4412        let converted_error = runtime_diagnostic_to_operation_diagnostic(&error, &target);
4413        let converted_warning = runtime_diagnostic_to_operation_diagnostic(&warning, &target);
4414        let converted_info = runtime_diagnostic_to_operation_diagnostic(&info, &target);
4415
4416        assert_eq!(converted_error.severity, "error");
4417        assert_eq!(converted_error.code, "paste.lowering.failed");
4418        assert_eq!(converted_warning.severity, "warning");
4419        assert_eq!(converted_warning.code, "runtime.warning");
4420        assert_eq!(converted_info.severity, "info");
4421        assert_eq!(converted_info.code, "runtime.info");
4422
4423        let warning =
4424            super::operation_diagnostic_to_runtime_diagnostic(RuntimeOperationDiagnostic {
4425                severity: "warning".to_owned(),
4426                code: "paste.warning".to_owned(),
4427                message: "warning".to_owned(),
4428                path: None,
4429                target: Some(target.clone()),
4430                expected_revision: Some("1".to_owned()),
4431                actual_revision: Some("2".to_owned()),
4432                duplicates: None,
4433                nodes: None,
4434                edges: None,
4435            });
4436        let info = super::operation_diagnostic_to_runtime_diagnostic(RuntimeOperationDiagnostic {
4437            severity: "info".to_owned(),
4438            code: "paste.info".to_owned(),
4439            message: "info".to_owned(),
4440            path: None,
4441            target: Some(target),
4442            expected_revision: None,
4443            actual_revision: None,
4444            duplicates: None,
4445            nodes: None,
4446            edges: None,
4447        });
4448        assert_eq!(warning.severity, crate::DiagnosticSeverity::Warning);
4449        assert_eq!(warning.code.as_deref(), Some("paste.warning"));
4450        assert_eq!(info.severity, crate::DiagnosticSeverity::Info);
4451        assert_eq!(info.code.as_deref(), Some("paste.info"));
4452    }
4453
4454    #[test]
4455    fn current_active_cutover_private_helpers_cover_defensive_paths() {
4456        let root_target = paste_operation("1").request.target;
4457        let change: RuntimeCollaborationChange = serde_json::from_value(json!({
4458          "op": "node.add",
4459          "changeId": "change-add-duplicate-value",
4460          "node": {
4461            "id": "value_1",
4462            "kind": "core.float",
4463            "kindVersion": "0.1.0",
4464            "params": {},
4465            "ports": value_f32_ports_current_json()
4466          }
4467        }))
4468        .expect("collaboration change should parse");
4469
4470        let mut unloaded = RuntimeSession::default();
4471        let no_project = unloaded.apply_collaboration_change_set_current(
4472            root_target.clone(),
4473            vec![change.clone()],
4474            None,
4475            None,
4476            None,
4477        );
4478        assert_eq!(
4479            no_project.diagnostics[0].code.as_deref(),
4480            Some("collaboration.target.no-project")
4481        );
4482
4483        let mut invalid_request = sample_project_current();
4484        let mut invalid_document = super::project_document_from_request_current(&invalid_request);
4485        invalid_document.schema_version = "9.9.9".to_owned();
4486        invalid_request.document = Some(invalid_document);
4487        let invalid_document_response = unloaded.load_project_current(invalid_request);
4488        assert_eq!(
4489            invalid_document_response.diagnostics[0].code.as_deref(),
4490            Some("project.unsupported-schema-version")
4491        );
4492        assert_eq!(
4493            invalid_document_response.diagnostics[0]
4494                .details
4495                .as_ref()
4496                .unwrap()["surface"],
4497            "project"
4498        );
4499        assert_eq!(
4500            invalid_document_response.diagnostics[0]
4501                .details
4502                .as_ref()
4503                .unwrap()["expectedSchemaVersion"],
4504            "0.1.0"
4505        );
4506        assert_eq!(
4507            invalid_document_response.diagnostics[0]
4508                .details
4509                .as_ref()
4510                .unwrap()["receivedSchemaVersion"],
4511            "9.9.9"
4512        );
4513
4514        let mut session = RuntimeSession::default();
4515        assert!(session.load_project_current(sample_project_current()).ok);
4516        assert!(session.project_document_current().is_some());
4517        assert_eq!(
4518            session.target_revision_current(&root_target).as_deref(),
4519            Some("1")
4520        );
4521
4522        let mut stale_target = root_target.clone();
4523        stale_target.base_revision = "0".to_owned();
4524        let stale = session.apply_collaboration_change_set_current(
4525            stale_target,
4526            vec![change.clone()],
4527            None,
4528            None,
4529            None,
4530        );
4531        assert!(stale.conflict);
4532        assert_eq!(
4533            stale.diagnostics[0].code.as_deref(),
4534            Some("collaboration.revision-conflict")
4535        );
4536
4537        let missing_help_target: skenion_contracts::GraphTargetRef =
4538            serde_json::from_value(json!({
4539              "path": { "kind": "help-working-copy", "workingCopyId": "missing-help" },
4540              "baseRevision": "1"
4541            }))
4542            .expect("target should parse");
4543        let missing_target = session.apply_collaboration_change_set_current(
4544            missing_help_target,
4545            vec![change.clone()],
4546            None,
4547            None,
4548            None,
4549        );
4550        assert_eq!(
4551            missing_target.diagnostics[0].code.as_deref(),
4552            Some("paste.target.missing-help-working-copy")
4553        );
4554
4555        let duplicate = session.apply_collaboration_change_set_current(
4556            root_target.clone(),
4557            vec![change],
4558            None,
4559            None,
4560            None,
4561        );
4562        assert_eq!(
4563            duplicate.diagnostics[0].code.as_deref(),
4564            Some("collaboration.node-id-conflict")
4565        );
4566
4567        let unsupported_target: skenion_contracts::GraphTargetRef = serde_json::from_value(json!({
4568          "path": {
4569            "kind": "package-patch-definition",
4570            "packageId": "pkg",
4571            "patchId": "help"
4572          },
4573          "baseRevision": "1"
4574        }))
4575        .expect("target should parse");
4576        let paste_error = super::paste_graph_fragment_into_project_current(
4577            super::project_document_from_request_current(&sample_project_current()),
4578            1,
4579            &PasteGraphFragmentRequest {
4580                target: unsupported_target,
4581                fragment: paste_operation("1").request.fragment,
4582                placement: None,
4583                options: None,
4584            },
4585        )
4586        .expect_err("package patch target should not be mutable");
4587        assert_eq!(paste_error.0[0].code, "paste.target.unsupported");
4588
4589        let unresolved = super::unresolved_object_diagnostics(&GraphDocument {
4590            schema: "skenion.graph".to_owned(),
4591            schema_version: "0.1.0".to_owned(),
4592            id: "unresolved-defaults".to_owned(),
4593            revision: "1".to_owned(),
4594            nodes: vec![
4595                serde_json::from_value(json!({
4596                  "id": "missing_object",
4597                  "kind": "core.unresolved-object",
4598                  "kindVersion": "0.1.0",
4599                  "params": {},
4600                  "ports": []
4601                }))
4602                .expect("node should parse"),
4603            ],
4604            edges: Vec::new(),
4605        });
4606        assert!(
4607            unresolved[0]
4608                .message
4609                .contains("object text could not be resolved")
4610        );
4611    }
4612
4613    #[test]
4614    fn active_current_failure_paths_cover_registry_restore_and_history_rejection() {
4615        let mut duplicate_request = sample_project_current();
4616        duplicate_request
4617            .nodes
4618            .push(duplicate_request.nodes[0].clone());
4619        let mut duplicate_session = RuntimeSession::default();
4620        let duplicate_load = duplicate_session.load_project_current(duplicate_request);
4621        assert!(!duplicate_load.ok);
4622        assert!(
4623            duplicate_load.diagnostics[0]
4624                .message
4625                .contains("duplicate node definition")
4626        );
4627
4628        let mut invalid_request = sample_project_current();
4629        let mut invalid_document = super::project_document_from_request_current(&invalid_request);
4630        invalid_document.graph.nodes[0].kind = "missing.kind".to_owned();
4631        invalid_request.document = Some(invalid_document.clone());
4632        let mut invalid_session = RuntimeSession {
4633            project: Some(invalid_document),
4634            nodes_current: invalid_request.nodes,
4635            revision: 1,
4636            view_revision: 1,
4637            ..RuntimeSession::default()
4638        };
4639
4640        let validation = invalid_session.validate_current();
4641        let plan = invalid_session.plan_current();
4642        assert!(!validation.ok);
4643        assert!(!plan.ok);
4644        assert!(plan.snapshot.plan.is_none());
4645        assert!(
4646            plan.diagnostics[0]
4647                .message
4648                .contains("missing node definition")
4649        );
4650
4651        let mut update_session = RuntimeSession::default();
4652        assert!(
4653            update_session
4654                .load_project_current(sample_project_current())
4655                .ok
4656        );
4657        let before = update_session
4658            .project_document_current()
4659            .expect("project should load");
4660        let mut after = before.clone();
4661        after.graph.revision = "2".to_owned();
4662        after.revision = "2".to_owned();
4663        update_session
4664            .nodes_current
4665            .push(update_session.nodes_current[0].clone());
4666        let update = update_session.apply_project_document_update(
4667            before,
4668            after,
4669            1,
4670            described_runtime_mutation("apply described project document"),
4671            None,
4672        );
4673        assert!(!update.ok);
4674        assert!(
4675            update.diagnostics[0]
4676                .message
4677                .contains("duplicate node definition")
4678        );
4679
4680        let mut restore_plan_session = RuntimeSession::default();
4681        assert!(
4682            restore_plan_session
4683                .load_project_current(sample_project_current())
4684                .ok
4685        );
4686        let mut invalid_restore = restore_plan_session
4687            .project_document_current()
4688            .expect("project should load");
4689        invalid_restore.graph.nodes[0].kind = "missing.kind".to_owned();
4690        let restored = restore_plan_session.restore_project_document_state(
4691            invalid_restore,
4692            1,
4693            RuntimeHistoryEntryKind::Undo,
4694            described_runtime_mutation("restore invalid project"),
4695            empty_runtime_mutation(),
4696            None,
4697        );
4698        assert!(!restored.ok);
4699        assert!(
4700            restored.diagnostics[0]
4701                .message
4702                .contains("missing node definition")
4703        );
4704
4705        let mut restore_registry_session = RuntimeSession::default();
4706        assert!(
4707            restore_registry_session
4708                .load_project_current(sample_project_current())
4709                .ok
4710        );
4711        let restore_project = restore_registry_session
4712            .project_document_current()
4713            .expect("project should load");
4714        restore_registry_session
4715            .nodes_current
4716            .push(restore_registry_session.nodes_current[0].clone());
4717        let restored = restore_registry_session.restore_project_document_state(
4718            restore_project,
4719            1,
4720            RuntimeHistoryEntryKind::Redo,
4721            described_runtime_mutation("restore registry project"),
4722            empty_runtime_mutation(),
4723            None,
4724        );
4725        assert!(!restored.ok);
4726        assert!(
4727            restored.diagnostics[0]
4728                .message
4729                .contains("duplicate node definition")
4730        );
4731
4732        let mut history_session = RuntimeSession::default();
4733        assert!(
4734            history_session
4735                .load_project_current(sample_project_current())
4736                .ok
4737        );
4738        let before = history_session
4739            .project_document_current()
4740            .expect("project should load");
4741        let mut after = before.clone();
4742        after.graph.nodes[0].kind = "missing.kind".to_owned();
4743        let entry = HistoryEntry::ProjectDocument {
4744            event_id: "event".to_owned(),
4745            actor_id: None,
4746            before: Box::new(before),
4747            after: Box::new(after),
4748            before_view_revision: 1,
4749            after_view_revision: 2,
4750            mutation: empty_runtime_mutation(),
4751            inverse_mutation: empty_runtime_mutation(),
4752        };
4753
4754        let outcome = history_session.apply_history_entry(entry, super::HistoryDirection::Redo);
4755        assert!(!outcome.applied);
4756
4757        let mut view_session = RuntimeSession::default();
4758        let loaded = view_session.load_project_current(sample_project_current());
4759        assert!(loaded.ok);
4760        let start = loaded
4761            .snapshot
4762            .view_state()
4763            .expect("current 0.1 load should include view state")
4764            .canvas
4765            .nodes["value_1"]
4766            .clone();
4767        let mut moved = start.clone();
4768        moved.x += 12.0;
4769        let view_patch = view_session.apply_mutation(RuntimeMutationRequest {
4770            graph_patch: None,
4771            view_patch: Some(RuntimeViewPatch {
4772                base_view_revision: 1,
4773                ops: vec![RuntimeViewPatchOperation::MoveNodeView {
4774                    node_id: "value_1".to_owned(),
4775                    from: Some(start),
4776                    to: moved,
4777                }],
4778            }),
4779            actor_id: None,
4780            client_id: None,
4781            description: Some("current 0.1 active view move".to_owned()),
4782        });
4783        assert!(view_patch.ok);
4784        assert!(view_patch.applied);
4785
4786        let mut mutation = graph_mutation(set_value_patch("old", 1.0));
4787        mutation.view_patch = Some(RuntimeViewPatch {
4788            base_view_revision: 1,
4789            ops: Vec::new(),
4790        });
4791        super::normalize_mutation_base_revisions(&mut mutation, "graph-new".to_owned(), 9);
4792        assert_eq!(
4793            mutation
4794                .graph_patch
4795                .as_ref()
4796                .map(|patch| patch.base_revision.as_str()),
4797            Some("graph-new")
4798        );
4799        assert_eq!(
4800            mutation
4801                .view_patch
4802                .as_ref()
4803                .map(|patch| patch.base_view_revision),
4804            Some(9)
4805        );
4806    }
4807
4808    #[test]
4809    fn history_delta_helpers_merge_non_top_project_patch_and_view_edits() {
4810        let mut before = super::project_document_from_request_current(&sample_project_current());
4811        before.patch_library = vec![
4812            patch_definition_current("identity"),
4813            patch_definition_current("before-only"),
4814        ];
4815        before.view_state.canvas.nodes.insert(
4816            "before_only_view".to_owned(),
4817            crate::CanvasNodeView {
4818                x: 11.0,
4819                y: 12.0,
4820                width: None,
4821                height: None,
4822                collapsed: None,
4823            },
4824        );
4825
4826        let mut after = before.clone();
4827        after.graph.nodes.push(graph_node_current("root_added"));
4828        after.graph.revision = "2".to_owned();
4829        after.revision = "2".to_owned();
4830        after.view_state.canvas.nodes.insert(
4831            "root_added".to_owned(),
4832            crate::CanvasNodeView {
4833                x: 400.0,
4834                y: 96.0,
4835                width: None,
4836                height: None,
4837                collapsed: None,
4838            },
4839        );
4840        after.view_state.canvas.nodes.remove("before_only_view");
4841        after
4842            .patch_library
4843            .retain(|patch| patch.id != "before-only");
4844        after.patch_library[0]
4845            .graph
4846            .nodes
4847            .push(graph_node_current("patch_added"));
4848        after.patch_library[0].graph.revision = "2".to_owned();
4849        after.patch_library[0].revision = "2".to_owned();
4850
4851        let mut current = after.clone();
4852        current
4853            .graph
4854            .nodes
4855            .push(graph_node_current("other_actor_root"));
4856        current
4857            .patch_library
4858            .push(patch_definition_current("current-only"));
4859        current
4860            .patch_library
4861            .push(patch_definition_current("before-only"));
4862        current.patch_library[0]
4863            .graph
4864            .nodes
4865            .push(graph_node_current("other_actor_patch"));
4866        current.view_state.canvas.nodes.insert(
4867            "other_actor_root".to_owned(),
4868            crate::CanvasNodeView {
4869                x: 800.0,
4870                y: 96.0,
4871                width: None,
4872                height: None,
4873                collapsed: None,
4874            },
4875        );
4876
4877        let undone = super::project_document_history_delta(
4878            &current,
4879            &before,
4880            &after,
4881            super::HistoryDirection::Undo,
4882        );
4883        assert!(
4884            !undone
4885                .graph
4886                .nodes
4887                .iter()
4888                .any(|node| node.id == "root_added")
4889        );
4890        assert!(
4891            undone
4892                .graph
4893                .nodes
4894                .iter()
4895                .any(|node| node.id == "other_actor_root")
4896        );
4897        assert!(
4898            !undone.patch_library[0]
4899                .graph
4900                .nodes
4901                .iter()
4902                .any(|node| node.id == "patch_added")
4903        );
4904        assert!(
4905            undone.patch_library[0]
4906                .graph
4907                .nodes
4908                .iter()
4909                .any(|node| node.id == "other_actor_patch")
4910        );
4911        assert!(
4912            undone
4913                .view_state
4914                .canvas
4915                .nodes
4916                .contains_key("other_actor_root")
4917        );
4918
4919        let redone = super::project_document_history_delta(
4920            &undone,
4921            &before,
4922            &after,
4923            super::HistoryDirection::Redo,
4924        );
4925        assert!(
4926            redone
4927                .graph
4928                .nodes
4929                .iter()
4930                .any(|node| node.id == "root_added")
4931        );
4932        assert!(
4933            redone
4934                .graph
4935                .nodes
4936                .iter()
4937                .any(|node| node.id == "other_actor_root")
4938        );
4939        assert!(
4940            redone.patch_library[0]
4941                .graph
4942                .nodes
4943                .iter()
4944                .any(|node| node.id == "patch_added")
4945        );
4946
4947        let mut before_graph = before.graph.clone();
4948        before_graph.nodes.push(graph_node_current("before_only"));
4949        let mut after_graph = before_graph.clone();
4950        after_graph.nodes.retain(|node| node.id != "before_only");
4951        let mut current_graph = after_graph.clone();
4952        current_graph.nodes.push(graph_node_current("before_only"));
4953        current_graph
4954            .nodes
4955            .push(graph_node_current("not_in_before"));
4956        assert!(super::undo_graph_history_delta_current(
4957            &mut current_graph.clone(),
4958            &before_graph,
4959            &after_graph
4960        ));
4961        assert!(super::redo_graph_history_delta_current(
4962            &mut current_graph,
4963            &before_graph,
4964            &after_graph
4965        ));
4966
4967        let _ = super::view_state_history_delta_current(
4968            &before.view_state,
4969            &before.view_state,
4970            &after.view_state,
4971            super::HistoryDirection::Undo,
4972        );
4973        let _ = super::view_state_history_delta_current(
4974            &before.view_state,
4975            &before.view_state,
4976            &after.view_state,
4977            super::HistoryDirection::Redo,
4978        );
4979    }
4980
4981    #[test]
4982    fn active_lowering_helpers_cover_surface_ports_models_and_id_sanitizing() {
4983        let definition: crate::NodeDefinitionCurrent = serde_json::from_value(json!({
4984          "schema": "skenion.node.definition",
4985          "schemaVersion": "0.1.0",
4986          "id": "core.matrix",
4987          "version": "0.1.0",
4988          "displayName": "Matrix",
4989          "category": "Test",
4990          "surface": { "palette": "cyan" },
4991          "ports": [
4992            { "id": "signal", "direction": "input", "type": "signal.audio", "rate": "audio" },
4993            { "id": "resource", "direction": "input", "type": "resource.buffer", "rate": "resource" },
4994            { "id": "stream", "direction": "output", "type": "io.midi", "rate": "io" }
4995          ],
4996          "execution": { "model": "audio_block" },
4997          "state": { "persistent": true },
4998          "permissions": [],
4999          "capabilities": []
5000        }))
5001        .expect("current 0.1 definition should parse");
5002
5003        let lowered = super::lower_node_definition_for_execution(&definition);
5004        assert_eq!(
5005            lowered
5006                .surface
5007                .as_ref()
5008                .and_then(|surface| surface.palette.as_deref()),
5009            Some("cyan")
5010        );
5011        assert_eq!(lowered.ports[0].data_type.flow, crate::DataFlow::Signal);
5012        assert_eq!(lowered.ports[1].data_type.flow, crate::DataFlow::Resource);
5013        assert_eq!(lowered.ports[2].data_type.flow, crate::DataFlow::Resource);
5014
5015        let cases = [
5016            (
5017                crate::ExecutionModel::Event,
5018                skenion_contracts::ExecutionModelV01::Event,
5019            ),
5020            (
5021                crate::ExecutionModel::Value,
5022                skenion_contracts::ExecutionModelV01::Value,
5023            ),
5024            (
5025                crate::ExecutionModel::Frame,
5026                skenion_contracts::ExecutionModelV01::Frame,
5027            ),
5028            (
5029                crate::ExecutionModel::AudioBlock,
5030                skenion_contracts::ExecutionModelV01::AudioBlock,
5031            ),
5032            (
5033                crate::ExecutionModel::VideoFrame,
5034                skenion_contracts::ExecutionModelV01::VideoFrame,
5035            ),
5036            (
5037                crate::ExecutionModel::GpuPass,
5038                skenion_contracts::ExecutionModelV01::GpuPass,
5039            ),
5040            (
5041                crate::ExecutionModel::AsyncResource,
5042                skenion_contracts::ExecutionModelV01::AsyncResource,
5043            ),
5044            (
5045                crate::ExecutionModel::ScriptControl,
5046                skenion_contracts::ExecutionModelV01::ScriptControl,
5047            ),
5048            (
5049                crate::ExecutionModel::NativePlugin,
5050                skenion_contracts::ExecutionModelV01::NativePlugin,
5051            ),
5052        ];
5053        for (internal, active) in cases {
5054            assert_eq!(
5055                super::lower_execution_model_for_execution(&active),
5056                internal
5057            );
5058        }
5059    }
5060
5061    #[test]
5062    fn paste_private_helpers_cover_fragment_and_edge_conflict_errors() {
5063        let graph = sample_project_current().graph;
5064        let mut invalid_fragment = paste_operation("1").request;
5065        invalid_fragment.fragment.edges[0].target.node_id = "outside".to_owned();
5066        let invalid =
5067            super::paste_graph_fragment_into_graph_current(graph.clone(), &invalid_fragment)
5068                .expect_err("outside endpoint should fail analysis");
5069        assert_eq!(
5070            invalid.0[0].code,
5071            "paste.fragment.fragment-edge-outside-selection"
5072        );
5073
5074        let mut edge_conflict = paste_operation("1").request;
5075        edge_conflict.options = Some(skenion_contracts::PasteGraphFragmentOptions {
5076            outside_endpoint_policy: None,
5077            id_conflict_policy: Some(skenion_contracts::IdConflictPolicy::Reject),
5078            preserve_relative_positions: None,
5079        });
5080        edge_conflict.fragment.nodes[0].id = "new_value".to_owned();
5081        edge_conflict.fragment.nodes[1].id = "new_target".to_owned();
5082        edge_conflict.fragment.edges[0].id = "edge_value_target".to_owned();
5083        edge_conflict.fragment.edges[0].source.node_id = "new_value".to_owned();
5084        edge_conflict.fragment.edges[0].target.node_id = "new_target".to_owned();
5085        let edge_conflict = super::paste_graph_fragment_into_graph_current(graph, &edge_conflict)
5086            .expect_err("duplicate edge id should fail");
5087        assert_eq!(edge_conflict.0[0].code, "paste.edge-id-conflict");
5088        assert_eq!(edge_conflict.1.edge_id_map.get("edge_value_target"), None);
5089
5090        let mut used_edges = HashSet::new();
5091        used_edges.insert("edge_2".to_owned());
5092        assert_eq!(super::next_available_edge_id("edge", &used_edges), "edge_3");
5093
5094        let mut unsupported = paste_operation("1").request;
5095        unsupported.target.path = skenion_contracts::PatchPath::EmbeddedPatchInstance {
5096            owner_path: vec!["root".to_owned()],
5097            node_id: "subpatch".to_owned(),
5098        };
5099        let unsupported = super::paste_graph_fragment_into_project_current(
5100            super::project_document_from_request_current(&sample_project_current()),
5101            1,
5102            &unsupported,
5103        )
5104        .expect_err("embedded patch target should fail");
5105        assert_eq!(unsupported.0[0].code, "paste.target.unsupported");
5106
5107        let mut missing_graph = paste_operation("1").request;
5108        missing_graph.target.path = skenion_contracts::PatchPath::ProjectPatchDefinition {
5109            patch_id: "missing".to_owned(),
5110        };
5111        let missing_graph = super::paste_graph_fragment_into_project_current(
5112            super::project_document_from_request_current(&sample_project_current()),
5113            1,
5114            &missing_graph,
5115        )
5116        .expect_err("missing project patch should fail");
5117        assert_eq!(missing_graph.0[0].code, "paste.target.missing-graph");
5118
5119        let mut project_with_patch =
5120            super::project_document_from_request_current(&sample_project_current());
5121        project_with_patch
5122            .patch_library
5123            .push(patch_definition_current("identity"));
5124        let mut patch_paste = paste_operation("1").request;
5125        patch_paste.target.path = skenion_contracts::PatchPath::ProjectPatchDefinition {
5126            patch_id: "identity".to_owned(),
5127        };
5128        let (patched_project, _, _, revision_after) =
5129            super::paste_graph_fragment_into_project_current(project_with_patch, 1, &patch_paste)
5130                .expect("project patch paste should apply");
5131        assert_eq!(revision_after, "2");
5132        assert_eq!(patched_project.patch_library[0].revision, "2");
5133
5134        let remapped = super::remap_edge_current(
5135            &EdgeSpecCurrent {
5136                id: "edge".to_owned(),
5137                source: EdgeEndpointCurrent {
5138                    node_id: "outside_source".to_owned(),
5139                    port_id: "out".to_owned(),
5140                },
5141                target: EdgeEndpointCurrent {
5142                    node_id: "outside_target".to_owned(),
5143                    port_id: "in".to_owned(),
5144                },
5145                resolved_type: None,
5146                order: None,
5147                enabled: None,
5148                adapter: None,
5149                feedback: None,
5150                style_override: None,
5151                label: None,
5152                description: None,
5153            },
5154            &BTreeMap::new(),
5155            "edge_2".to_owned(),
5156        );
5157        assert_eq!(remapped.source.node_id, "outside_source");
5158        assert_eq!(remapped.target.node_id, "outside_target");
5159        assert_eq!(super::next_graph_revision("2"), "3");
5160        assert_eq!(super::next_graph_revision("rev"), "rev+1");
5161    }
5162
5163    #[test]
5164    fn collaboration_private_helpers_cover_patch_target_error_matrix() {
5165        let mut project = super::project_document_from_request_current(&sample_project_current());
5166        project
5167            .patch_library
5168            .push(patch_definition_current("identity"));
5169        let root_target = skenion_contracts::GraphTargetRef {
5170            path: skenion_contracts::PatchPath::Root,
5171            base_revision: "1".to_owned(),
5172            target_revision: None,
5173        };
5174        let patch_target = skenion_contracts::GraphTargetRef {
5175            path: skenion_contracts::PatchPath::ProjectPatchDefinition {
5176                patch_id: "identity".to_owned(),
5177            },
5178            base_revision: "1".to_owned(),
5179            target_revision: None,
5180        };
5181
5182        let patch_view_error = super::apply_collaboration_changes_to_project_current(
5183            project.clone(),
5184            1,
5185            &patch_target,
5186            &[collaboration_change(json!({
5187              "op": "node.add",
5188              "changeId": "add-with-view",
5189              "node": value_node_current_json("patch_added"),
5190              "view": { "x": 1.0, "y": 2.0 }
5191            }))],
5192        )
5193        .expect_err("patch definition views are not active Runtime state");
5194        assert_eq!(
5195            patch_view_error[0].code.as_deref(),
5196            Some("collaboration.patch-view-unsupported")
5197        );
5198
5199        let patch_add = super::apply_collaboration_changes_to_project_current(
5200            project.clone(),
5201            1,
5202            &patch_target,
5203            &[collaboration_change(json!({
5204              "op": "node.add",
5205              "changeId": "add-patch-node",
5206              "node": value_node_current_json("patch_added_without_view")
5207            }))],
5208        )
5209        .expect("patch definition node add without view should apply");
5210        assert_eq!(patch_add.0.patch_library[0].revision, "2");
5211
5212        let patch_move_error = super::apply_collaboration_changes_to_project_current(
5213            project.clone(),
5214            1,
5215            &patch_target,
5216            &[collaboration_change(json!({
5217              "op": "node.move",
5218              "changeId": "move-patch-node",
5219              "nodeId": "patch_value",
5220              "to": { "x": 1.0, "y": 2.0 }
5221            }))],
5222        )
5223        .expect_err("patch definition move view should fail");
5224        assert_eq!(
5225            patch_move_error[0].code.as_deref(),
5226            Some("collaboration.patch-view-unsupported")
5227        );
5228
5229        let missing_move = super::apply_collaboration_changes_to_project_current(
5230            project.clone(),
5231            1,
5232            &root_target,
5233            &[collaboration_change(json!({
5234              "op": "node.move",
5235              "changeId": "move-missing",
5236              "nodeId": "missing",
5237              "to": { "x": 1.0, "y": 2.0 }
5238            }))],
5239        )
5240        .expect_err("moving a missing node should fail");
5241        assert_eq!(
5242            missing_move[0].code.as_deref(),
5243            Some("collaboration.node-missing")
5244        );
5245
5246        let view_conflict = super::apply_collaboration_changes_to_project_current(
5247            project.clone(),
5248            1,
5249            &root_target,
5250            &[collaboration_change(json!({
5251              "op": "node.move",
5252              "changeId": "move-conflict",
5253              "nodeId": "value_1",
5254              "from": { "x": -1.0, "y": -1.0 },
5255              "to": { "x": 1.0, "y": 2.0 }
5256            }))],
5257        )
5258        .expect_err("move from mismatch should fail");
5259        assert_eq!(
5260            view_conflict[0].code.as_deref(),
5261            Some("collaboration.view-conflict")
5262        );
5263
5264        let missing_delete = super::apply_collaboration_changes_to_project_current(
5265            project.clone(),
5266            1,
5267            &root_target,
5268            &[collaboration_change(json!({
5269              "op": "node.delete",
5270              "changeId": "delete-missing",
5271              "nodeId": "missing"
5272            }))],
5273        )
5274        .expect_err("deleting a missing node should fail");
5275        assert_eq!(
5276            missing_delete[0].code.as_deref(),
5277            Some("collaboration.node-missing")
5278        );
5279
5280        let duplicate_edge = super::apply_collaboration_changes_to_project_current(
5281            project.clone(),
5282            1,
5283            &root_target,
5284            &[collaboration_change(json!({
5285              "op": "edge.connect",
5286              "changeId": "connect-duplicate",
5287              "edge": {
5288                "id": "edge_value_target",
5289                "source": { "nodeId": "value_1", "portId": "value" },
5290                "target": { "nodeId": "target_1", "portId": "cold" }
5291              }
5292            }))],
5293        )
5294        .expect_err("duplicate edge id should fail");
5295        assert_eq!(
5296            duplicate_edge[0].code.as_deref(),
5297            Some("collaboration.edge-id-conflict")
5298        );
5299
5300        let missing_graph_target = skenion_contracts::GraphTargetRef {
5301            path: skenion_contracts::PatchPath::HelpWorkingCopy {
5302                working_copy_id: "missing-help".to_owned(),
5303                source_package_id: None,
5304                source_patch_id: None,
5305            },
5306            base_revision: "1".to_owned(),
5307            target_revision: None,
5308        };
5309        let missing_graph = super::apply_collaboration_changes_to_project_current(
5310            project.clone(),
5311            1,
5312            &missing_graph_target,
5313            &[],
5314        )
5315        .expect_err("missing help graph should fail");
5316        assert_eq!(
5317            missing_graph[0].code.as_deref(),
5318            Some("collaboration.target.missing-graph")
5319        );
5320
5321        let unsupported_target = skenion_contracts::GraphTargetRef {
5322            path: skenion_contracts::PatchPath::PackagePatchDefinition {
5323                package_id: "pkg".to_owned(),
5324                patch_id: "help".to_owned(),
5325                version: None,
5326            },
5327            base_revision: "1".to_owned(),
5328            target_revision: None,
5329        };
5330        let unsupported = super::apply_collaboration_changes_to_project_current(
5331            project,
5332            1,
5333            &unsupported_target,
5334            &[],
5335        )
5336        .expect_err("package patch target should fail");
5337        assert_eq!(
5338            unsupported[0].code.as_deref(),
5339            Some("collaboration.target.unsupported")
5340        );
5341
5342        let mut unresolved_graph = sample_project_current().graph;
5343        unresolved_graph.nodes.push(
5344            serde_json::from_value(json!({
5345              "id": "unresolved_current",
5346              "kind": "core.unresolved-object",
5347              "kindVersion": "0.1.0",
5348              "params": {},
5349              "ports": []
5350            }))
5351            .expect("unresolved current 0.1 node should parse"),
5352        );
5353        let unresolved = super::unresolved_object_diagnostics_current(&unresolved_graph);
5354        assert!(
5355            unresolved[0]
5356                .message
5357                .contains("object text could not be resolved")
5358        );
5359    }
5360
5361    #[test]
5362    fn paste_graph_fragment_applies_position_and_anchor_placement() {
5363        let mut positioned = RuntimeSession::default();
5364        load_sample_project(&mut positioned);
5365        let mut position_operation = paste_operation("1");
5366        position_operation.request.placement =
5367            Some(skenion_contracts::PastePlacement::Position { x: 300.0, y: 400.0 });
5368
5369        let position_response = positioned.apply_runtime_operation(position_operation);
5370
5371        assert!(position_response.ok);
5372        let position_view = positioned.view_state().expect("view state should exist");
5373        let pasted_value_view = position_view
5374            .canvas
5375            .nodes
5376            .get("value_1_2")
5377            .expect("pasted value view should exist");
5378        let pasted_target_view = position_view
5379            .canvas
5380            .nodes
5381            .get("pasted_target")
5382            .expect("pasted target view should exist");
5383        assert_eq!((pasted_value_view.x, pasted_value_view.y), (300.0, 400.0));
5384        assert_eq!((pasted_target_view.x, pasted_target_view.y), (470.0, 400.0));
5385
5386        let mut anchored = RuntimeSession::default();
5387        load_sample_project(&mut anchored);
5388        let mut anchor_operation = paste_operation("1");
5389        anchor_operation.request.placement = Some(skenion_contracts::PastePlacement::Anchor {
5390            node_id: "value_1".to_owned(),
5391            offset_x: Some(16.0),
5392            offset_y: Some(32.0),
5393        });
5394
5395        let anchor_response = anchored.apply_runtime_operation(anchor_operation);
5396
5397        assert!(anchor_response.ok);
5398        let anchor_view = anchored.view_state().expect("view state should exist");
5399        let pasted_value_view = anchor_view
5400            .canvas
5401            .nodes
5402            .get("value_1_2")
5403            .expect("pasted value view should exist");
5404        assert_eq!((pasted_value_view.x, pasted_value_view.y), (26.0, 52.0));
5405    }
5406
5407    #[test]
5408    fn paste_graph_fragment_reports_base_revision_conflict() {
5409        let mut session = RuntimeSession::default();
5410        load_sample_project(&mut session);
5411
5412        let response = session.apply_runtime_operation(paste_operation("0"));
5413
5414        assert!(!response.ok);
5415        assert!(!response.applied);
5416        assert!(response.conflict);
5417        assert_eq!(response.revision_before, "1");
5418        assert_eq!(response.revision_after, None);
5419        assert_eq!(response.diagnostics[0].code, "paste.revision-conflict");
5420        assert_eq!(session.graph().unwrap().revision, "1");
5421    }
5422
5423    #[test]
5424    fn paste_graph_fragment_rejects_missing_help_working_copy_target() {
5425        let mut session = RuntimeSession::default();
5426        load_sample_project(&mut session);
5427        let mut operation = paste_operation("1");
5428        operation.request.target.path = skenion_contracts::PatchPath::HelpWorkingCopy {
5429            working_copy_id: "missing-help-copy".to_owned(),
5430            source_package_id: Some("skenion.core".to_owned()),
5431            source_patch_id: Some("float-help".to_owned()),
5432        };
5433
5434        let response = session.apply_runtime_operation(operation);
5435
5436        assert!(!response.ok);
5437        assert!(!response.applied);
5438        assert_eq!(
5439            response.diagnostics[0].code,
5440            "paste.target.missing-help-working-copy"
5441        );
5442    }
5443
5444    #[test]
5445    fn paste_graph_fragment_allows_loaded_help_working_copy_target() {
5446        let mut session = RuntimeSession::default();
5447        load_sample_project(&mut session);
5448        let mut operation = paste_operation("1");
5449        operation.request.target.path = skenion_contracts::PatchPath::HelpWorkingCopy {
5450            working_copy_id: "minimal-value".to_owned(),
5451            source_package_id: Some("skenion.core".to_owned()),
5452            source_patch_id: Some("float-help".to_owned()),
5453        };
5454
5455        let response = session.apply_runtime_operation(operation);
5456
5457        assert!(response.ok);
5458        assert!(response.applied);
5459        assert_eq!(response.revision_after.as_deref(), Some("2"));
5460        assert_eq!(
5461            response
5462                .id_remap
5463                .node_id_map
5464                .get("value_1")
5465                .map(String::as_str),
5466            Some("value_1_2")
5467        );
5468    }
5469
5470    #[test]
5471    fn paste_graph_fragment_rejects_project_patch_definition_target() {
5472        let mut session = RuntimeSession::default();
5473        load_sample_project(&mut session);
5474        let mut operation = paste_operation("1");
5475        operation.request.target.path = skenion_contracts::PatchPath::ProjectPatchDefinition {
5476            patch_id: "identity".to_owned(),
5477        };
5478
5479        let response = session.apply_runtime_operation(operation);
5480
5481        assert!(!response.ok);
5482        assert!(!response.applied);
5483        assert_eq!(
5484            response.diagnostics[0].code,
5485            "paste.target.missing-project-patch-definition"
5486        );
5487        assert!(
5488            response.diagnostics[0]
5489                .message
5490                .contains("project patch definition identity is not loaded")
5491        );
5492    }
5493
5494    #[test]
5495    fn paste_graph_fragment_rejects_embedded_patch_instance_target() {
5496        let mut session = RuntimeSession::default();
5497        load_sample_project(&mut session);
5498        let mut operation = paste_operation("1");
5499        operation.request.target.path = skenion_contracts::PatchPath::EmbeddedPatchInstance {
5500            owner_path: vec!["root".to_owned()],
5501            node_id: "subpatch_1".to_owned(),
5502        };
5503
5504        let response = session.apply_runtime_operation(operation);
5505
5506        assert!(!response.ok);
5507        assert!(!response.applied);
5508        assert_eq!(
5509            response.diagnostics[0].code,
5510            "paste.target.unsupported-embedded-patch-instance"
5511        );
5512    }
5513
5514    #[test]
5515    fn paste_graph_fragment_rejects_outside_endpoint_by_default() {
5516        let mut session = RuntimeSession::default();
5517        load_sample_project(&mut session);
5518        let mut operation = paste_operation("1");
5519        operation.request.fragment.edges[0].target.node_id = "outside".to_owned();
5520
5521        let response = session.apply_runtime_operation(operation);
5522
5523        assert!(!response.ok);
5524        assert!(!response.applied);
5525        assert_eq!(
5526            response.diagnostics[0].code,
5527            "paste.operation.invalid-envelope"
5528        );
5529        assert!(
5530            response.diagnostics[0]
5531                .message
5532                .contains("fragment-edge-outside-selection")
5533        );
5534    }
5535
5536    #[test]
5537    fn paste_graph_fragment_omits_outside_endpoint_when_requested() {
5538        let mut session = RuntimeSession::default();
5539        load_sample_project(&mut session);
5540        let mut operation = paste_operation("1");
5541        operation.request.fragment.edges[0].target.node_id = "outside".to_owned();
5542        operation.request.options = Some(skenion_contracts::PasteGraphFragmentOptions {
5543            outside_endpoint_policy: Some(
5544                skenion_contracts::GraphFragmentOutsideEndpointPolicyV01::Omit,
5545            ),
5546            id_conflict_policy: Some(skenion_contracts::IdConflictPolicy::Remap),
5547            preserve_relative_positions: Some(true),
5548        });
5549
5550        let response = session.apply_runtime_operation(operation);
5551
5552        assert!(response.ok);
5553        assert!(response.applied);
5554        assert_eq!(
5555            response.id_remap.omitted_edge_ids,
5556            vec!["edge_value_to_pasted"]
5557        );
5558        let graph = session.graph().unwrap();
5559        assert!(!graph.edges.iter().any(|edge| edge.to.node == "outside"));
5560    }
5561
5562    #[test]
5563    fn paste_graph_fragment_rejects_immutable_help_source_target() {
5564        let mut session = RuntimeSession::default();
5565        load_sample_project(&mut session);
5566        let mut operation = paste_operation("1");
5567        operation.request.target.path = skenion_contracts::PatchPath::PackagePatchDefinition {
5568            package_id: "skenion.core".to_owned(),
5569            patch_id: "float-help".to_owned(),
5570            version: Some("0.37.0".to_owned()),
5571        };
5572
5573        let response = session.apply_runtime_operation(operation);
5574
5575        assert!(!response.ok);
5576        assert!(!response.applied);
5577        assert_eq!(
5578            response.diagnostics[0].code,
5579            "paste.target.immutable-help-source"
5580        );
5581    }
5582
5583    #[test]
5584    fn paste_graph_fragment_converts_current_port_rates_for_lowered_execution_nodes() {
5585        let cases = [
5586            (
5587                json!({ "id": "event", "direction": "input", "type": "message.any", "rate": "event", "triggerMode": "trigger" }),
5588                crate::DataFlow::Event,
5589                "message.any",
5590                Some(crate::PortActivation::Trigger),
5591            ),
5592            (
5593                json!({ "id": "audio", "direction": "output", "type": "signal.audio", "rate": "audio" }),
5594                crate::DataFlow::Signal,
5595                "signal.audio",
5596                None,
5597            ),
5598            (
5599                json!({ "id": "resource", "direction": "input", "type": "resource.buffer", "rate": "resource" }),
5600                crate::DataFlow::Resource,
5601                "resource.buffer",
5602                None,
5603            ),
5604            (
5605                json!({ "id": "io", "direction": "output", "type": "io.midi", "rate": "io" }),
5606                crate::DataFlow::Resource,
5607                "io.midi",
5608                None,
5609            ),
5610            (
5611                json!({ "id": "render", "direction": "input", "type": "value.number", "rate": "render", "triggerMode": "passive" }),
5612                crate::DataFlow::Value,
5613                "number.float",
5614                Some(crate::PortActivation::Latched),
5615            ),
5616            (
5617                json!({ "id": "gpu", "direction": "input", "type": "value.color", "rate": "gpu", "triggerMode": "latched" }),
5618                crate::DataFlow::Value,
5619                "color",
5620                Some(crate::PortActivation::Latched),
5621            ),
5622            (
5623                json!({ "id": "texture", "direction": "output", "type": "gpu.texture2d", "rate": "gpu" }),
5624                crate::DataFlow::Resource,
5625                "gpu.texture2d",
5626                None,
5627            ),
5628            (
5629                json!({ "id": "default", "direction": "input", "type": "message.any" }),
5630                crate::DataFlow::Event,
5631                "message.any",
5632                None,
5633            ),
5634        ];
5635
5636        for (value, expected_flow, expected_kind, expected_activation) in cases {
5637            let port: PortSpecCurrent = serde_json::from_value(value).expect("port should parse");
5638            let lowered = lower_port_for_execution(&port);
5639            assert_eq!(lowered.data_type.flow, expected_flow);
5640            assert_eq!(lowered.data_type.data_kind, expected_kind);
5641            assert_eq!(lowered.activation, expected_activation);
5642        }
5643    }
5644
5645    fn graph_patch(value: Value) -> GraphPatch {
5646        serde_json::from_value(value).expect("patch should parse")
5647    }
5648
5649    fn patch_graph(response: &RuntimePatchResponse) -> &GraphDocumentCurrent {
5650        &response
5651            .snapshot
5652            .project
5653            .as_ref()
5654            .expect("patch response should include project")
5655            .graph
5656    }
5657
5658    fn patch_view_state(response: &RuntimePatchResponse) -> &ViewState {
5659        &response
5660            .snapshot
5661            .project
5662            .as_ref()
5663            .expect("patch response should include project")
5664            .view_state
5665    }
5666
5667    fn assert_graph_patch_rejected(response: &RuntimePatchResponse) {
5668        assert!(!response.ok);
5669        assert!(!response.applied);
5670        assert!(!response.conflict);
5671        assert_eq!(
5672            response.diagnostics[0].code.as_deref(),
5673            Some("project.graph-patch-unsupported")
5674        );
5675    }
5676
5677    fn latest_history_entry(
5678        response: &RuntimePatchResponse,
5679    ) -> Option<&super::RuntimeHistoryEntry> {
5680        response.history.entries.last()
5681    }
5682
5683    fn graph_mutation(patch: GraphPatch) -> RuntimeMutationRequest {
5684        RuntimeMutationRequest {
5685            graph_patch: Some(patch),
5686            view_patch: None,
5687            actor_id: None,
5688            client_id: None,
5689            description: None,
5690        }
5691    }
5692
5693    fn empty_runtime_mutation() -> RuntimeMutationRequest {
5694        RuntimeMutationRequest {
5695            graph_patch: None,
5696            view_patch: None,
5697            actor_id: None,
5698            client_id: None,
5699            description: None,
5700        }
5701    }
5702
5703    fn described_runtime_mutation(description: &str) -> RuntimeMutationRequest {
5704        RuntimeMutationRequest {
5705            graph_patch: None,
5706            view_patch: None,
5707            actor_id: None,
5708            client_id: None,
5709            description: Some(description.to_owned()),
5710        }
5711    }
5712
5713    fn set_value_patch(base_revision: &str, value: f64) -> GraphPatch {
5714        graph_patch(json!({
5715          "schema": "skenion.graph.patch",
5716          "schemaVersion": "0.1.0",
5717          "id": "set-value",
5718          "baseRevision": base_revision,
5719          "ops": [
5720            { "op": "setNodeParam", "nodeId": "value_1", "key": "value", "value": value }
5721          ]
5722        }))
5723    }
5724
5725    fn paste_operation(base_revision: &str) -> RuntimeOperationEnvelope {
5726        serde_json::from_value(json!({
5727          "schema": "skenion.runtime.operation",
5728          "schemaVersion": "0.1.0",
5729          "id": "op-paste",
5730          "kind": "pasteGraphFragment",
5731          "request": {
5732            "target": {
5733              "path": { "kind": "root" },
5734              "baseRevision": base_revision
5735            },
5736            "fragment": paste_fragment_json(),
5737            "options": {
5738              "idConflictPolicy": "remap"
5739            }
5740          },
5741          "attribution": {
5742            "clientId": "studio-test",
5743            "label": "Paste test fragment"
5744          }
5745        }))
5746        .expect("paste operation should parse")
5747    }
5748
5749    fn paste_fragment_json() -> Value {
5750        json!({
5751          "schema": "skenion.graph.fragment",
5752          "schemaVersion": "0.1.0",
5753          "nodes": [
5754            {
5755              "id": "value_1",
5756              "kind": "core.float",
5757              "kindVersion": "0.1.0",
5758              "params": {},
5759              "ports": value_f32_ports_current_json()
5760            },
5761            {
5762              "id": "pasted_target",
5763              "kind": "core.float",
5764              "kindVersion": "0.1.0",
5765              "params": {},
5766              "ports": value_f32_ports_current_json()
5767            }
5768          ],
5769          "edges": [
5770            {
5771              "id": "edge_value_to_pasted",
5772              "source": { "nodeId": "value_1", "portId": "value" },
5773              "target": { "nodeId": "pasted_target", "portId": "cold" }
5774            }
5775          ],
5776          "view": {
5777            "nodes": {
5778              "value_1": { "x": 10.0, "y": 20.0 },
5779              "pasted_target": { "x": 180.0, "y": 20.0 }
5780            }
5781          }
5782        })
5783    }
5784
5785    fn graph_node_current(id: &str) -> crate::GraphNodeCurrent {
5786        serde_json::from_value(value_node_current_json(id))
5787            .expect("current 0.1 graph node should parse")
5788    }
5789
5790    fn value_node_current_json(id: &str) -> Value {
5791        json!({
5792          "id": id,
5793          "kind": "core.float",
5794          "kindVersion": "0.1.0",
5795          "params": {},
5796          "ports": value_f32_ports_current_json()
5797        })
5798    }
5799
5800    fn patch_definition_current(id: &str) -> skenion_contracts::PatchDefinitionV01 {
5801        serde_json::from_value(json!({
5802          "id": id,
5803          "revision": "1",
5804          "graph": {
5805            "schema": "skenion.graph",
5806            "schemaVersion": "0.1.0",
5807            "id": format!("{id}-graph"),
5808            "revision": "1",
5809            "nodes": [value_node_current_json("patch_value")],
5810            "edges": []
5811          }
5812        }))
5813        .expect("patch definition should parse")
5814    }
5815
5816    fn collaboration_change(value: Value) -> RuntimeCollaborationChange {
5817        serde_json::from_value(value).expect("collaboration change should parse")
5818    }
5819
5820    fn f32_value(value: f64) -> ControlValue {
5821        ControlValue::float(value)
5822    }
5823
5824    fn control_request(
5825        node_id: &str,
5826        port_id: &str,
5827        value: ControlValue,
5828    ) -> RuntimeControlEventRequest {
5829        RuntimeControlEventRequest {
5830            node_id: node_id.to_owned(),
5831            port_id: port_id.to_owned(),
5832            message: ControlMessage::from_value(value),
5833        }
5834    }
5835
5836    fn set_control_request(
5837        node_id: &str,
5838        port_id: &str,
5839        value: ControlValue,
5840    ) -> RuntimeControlEventRequest {
5841        RuntimeControlEventRequest {
5842            node_id: node_id.to_owned(),
5843            port_id: port_id.to_owned(),
5844            message: ControlMessage {
5845                selector: "set".to_owned(),
5846                atoms: vec![value],
5847            },
5848        }
5849    }
5850
5851    fn bang_control_request(node_id: &str, port_id: &str) -> RuntimeControlEventRequest {
5852        RuntimeControlEventRequest {
5853            node_id: node_id.to_owned(),
5854            port_id: port_id.to_owned(),
5855            message: ControlMessage::bang(),
5856        }
5857    }
5858
5859    fn emitted_value(emission: &RuntimeControlEmission) -> Option<ControlValue> {
5860        emission.message.first_atom().cloned()
5861    }
5862
5863    fn control_read(
5864        node_id: &str,
5865        target: RuntimeControlReadTarget,
5866        id: &str,
5867    ) -> RuntimeControlReadRequest {
5868        RuntimeControlReadRequest {
5869            node_id: node_id.to_owned(),
5870            target,
5871            id: id.to_owned(),
5872        }
5873    }
5874
5875    fn duplicate_edge_patch() -> GraphPatch {
5876        graph_patch(json!({
5877          "schema": "skenion.graph.patch",
5878          "schemaVersion": "0.1.0",
5879          "id": "duplicate-edge",
5880          "baseRevision": "1",
5881          "ops": [
5882            {
5883              "op": "addEdge",
5884              "edge": {
5885                "from": { "node": "value_1", "port": "value" },
5886                "to": { "node": "target_1", "port": "in" }
5887              }
5888            }
5889          ]
5890        }))
5891    }
5892
5893    fn missing_node_patch() -> GraphPatch {
5894        graph_patch(json!({
5895          "schema": "skenion.graph.patch",
5896          "schemaVersion": "0.1.0",
5897          "id": "missing-node",
5898          "baseRevision": "1",
5899          "ops": [
5900            { "op": "setNodeParam", "nodeId": "missing", "key": "value", "value": 1 }
5901          ]
5902        }))
5903    }
5904
5905    fn incompatible_edge_patch() -> GraphPatch {
5906        graph_patch(json!({
5907          "schema": "skenion.graph.patch",
5908          "schemaVersion": "0.1.0",
5909          "id": "incompatible-edge",
5910          "baseRevision": "1",
5911          "ops": [
5912            {
5913              "op": "addEdge",
5914              "edge": {
5915                "from": { "node": "value_1", "port": "value" },
5916                "to": { "node": "target_1", "port": "value" }
5917              }
5918            }
5919          ]
5920        }))
5921    }
5922
5923    fn missing_definition_node_patch() -> GraphPatch {
5924        graph_patch(json!({
5925          "schema": "skenion.graph.patch",
5926          "schemaVersion": "0.1.0",
5927          "id": "missing-definition-node",
5928          "baseRevision": "1",
5929          "ops": [
5930            {
5931              "op": "addNode",
5932              "node": {
5933                "id": "missing_kind_1",
5934                "kind": "missing.kind",
5935                "kindVersion": "0.1.0",
5936                "params": {},
5937                "ports": []
5938              }
5939            }
5940          ]
5941        }))
5942    }
5943
5944    fn load_sample_project(session: &mut RuntimeSession) -> super::RuntimeSessionResponse {
5945        session.load_project_current(sample_project_current())
5946    }
5947
5948    fn sample_internal_graph() -> GraphDocument {
5949        super::lower_graph_for_execution(&sample_project_current().graph)
5950    }
5951
5952    fn sample_project_current() -> ProjectRequestCurrent {
5953        serde_json::from_value(json!({
5954          "graph": {
5955            "schema": "skenion.graph",
5956            "schemaVersion": "0.1.0",
5957            "id": "minimal-value",
5958            "revision": "1",
5959            "nodes": [
5960              {
5961                "id": "value_1",
5962                "kind": "core.float",
5963                "kindVersion": "0.1.0",
5964                "params": {},
5965                "ports": value_f32_ports_current_json()
5966              },
5967              {
5968                "id": "target_1",
5969                "kind": "core.float",
5970                "kindVersion": "0.1.0",
5971                "params": {},
5972                "ports": value_f32_ports_current_json()
5973              }
5974            ],
5975            "edges": [
5976              {
5977                "id": "edge_value_target",
5978                "source": { "nodeId": "value_1", "portId": "value" },
5979                "target": { "nodeId": "target_1", "portId": "cold" },
5980                "resolvedType": "number.float"
5981              }
5982            ]
5983          },
5984          "nodes": [
5985            {
5986              "schema": "skenion.node.definition",
5987              "schemaVersion": "0.1.0",
5988              "id": "core.float",
5989              "version": "0.1.0",
5990              "displayName": "Float Value",
5991              "category": "Values",
5992              "ports": value_f32_ports_current_json(),
5993              "execution": { "model": "value" },
5994              "state": { "persistent": false },
5995              "permissions": [],
5996              "capabilities": []
5997            }
5998          ],
5999          "viewState": {
6000            "schema": "skenion.view-state",
6001            "schemaVersion": "0.1.0",
6002            "canvas": {
6003              "nodes": {
6004                "value_1": { "x": 96.0, "y": 96.0 },
6005                "target_1": { "x": 260.0, "y": 96.0 }
6006              }
6007            }
6008          }
6009        }))
6010        .expect("current 0.1 sample project should parse")
6011    }
6012
6013    fn sample_project_current_with_unresolved_definition() -> ProjectRequestCurrent {
6014        let mut request = sample_project_current();
6015        request.nodes.push(
6016            serde_json::from_value(unresolved_definition_current_json())
6017                .expect("unresolved current 0.1 definition should parse"),
6018        );
6019        request
6020    }
6021
6022    fn unresolved_project_current() -> ProjectRequestCurrent {
6023        let mut request = sample_project_current();
6024        request.graph.nodes.push(
6025            serde_json::from_value(unresolved_node_json("unresolved_1", "user.manipulator"))
6026                .expect("unresolved current 0.1 node should parse"),
6027        );
6028        request.nodes.push(
6029            serde_json::from_value(unresolved_definition_current_json())
6030                .expect("unresolved current 0.1 definition should parse"),
6031        );
6032        request
6033    }
6034
6035    fn object_routing_project_current() -> ProjectRequestCurrent {
6036        let mut request = sample_project_current();
6037        request.graph.nodes[0]
6038            .params
6039            .insert("sendName".to_owned(), json!("speed"));
6040        request
6041    }
6042
6043    fn debug_sink_project_current() -> ProjectRequestCurrent {
6044        let mut request = sample_project_current();
6045        request.graph.nodes.push(
6046            serde_json::from_value(json!({
6047                "id": "debug_1",
6048                "kind": "debug.sink",
6049                "kindVersion": "0.1.0",
6050                "params": {},
6051                "ports": []
6052            }))
6053            .expect("debug current 0.1 node should parse"),
6054        );
6055        request.nodes.push(
6056            serde_json::from_value(json!({
6057                "schema": "skenion.node.definition",
6058                "schemaVersion": "0.1.0",
6059                "id": "debug.sink",
6060                "version": "0.1.0",
6061                "displayName": "Debug Sink",
6062                "category": "Debug",
6063                "ports": [],
6064                "execution": { "model": "value" },
6065                "state": { "persistent": false },
6066                "permissions": [],
6067                "capabilities": []
6068            }))
6069            .expect("debug current 0.1 definition should parse"),
6070        );
6071        request
6072    }
6073
6074    fn value_f32_ports_current_json() -> Value {
6075        json!([
6076          {
6077            "id": "in",
6078            "direction": "input",
6079            "label": "In",
6080            "type": "message.any",
6081            "rate": "event",
6082            "required": false,
6083            "triggerMode": "trigger"
6084          },
6085          {
6086            "id": "cold",
6087            "direction": "input",
6088            "label": "Cold",
6089            "type": "number.float",
6090            "rate": "control",
6091            "required": false,
6092            "triggerMode": "latched"
6093          },
6094          {
6095            "id": "value",
6096            "direction": "output",
6097            "label": "Value",
6098            "type": "number.float",
6099            "rate": "control"
6100          }
6101        ])
6102    }
6103
6104    fn unresolved_node_json(id: &str, object_text: &str) -> Value {
6105        json!({
6106          "id": id,
6107          "kind": "core.unresolved-object",
6108          "kindVersion": "0.1.0",
6109          "params": {
6110            "objectText": object_text,
6111            "diagnosticMessage": format!("{object_text} is not available in the local runtime registry."),
6112            "requestedKind": object_text
6113          },
6114          "ports": []
6115        })
6116    }
6117
6118    fn unresolved_definition_current_json() -> Value {
6119        json!({
6120          "schema": "skenion.node.definition",
6121          "schemaVersion": "0.1.0",
6122          "id": "core.unresolved-object",
6123          "version": "0.1.0",
6124          "displayName": "Unresolved Object",
6125          "category": "Diagnostics",
6126          "ports": [],
6127          "execution": { "model": "event" },
6128          "state": { "persistent": false },
6129          "permissions": [],
6130          "capabilities": ["diagnostic.unresolved-object.v0.1"]
6131        })
6132    }
6133}