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, ®istry).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(¤t.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 ¤t,
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}