1use std::{
2 collections::BTreeMap,
3 convert::Infallible,
4 fs,
5 hash::{Hash, Hasher},
6 path::PathBuf,
7 sync::{Arc, RwLock},
8 time::{Duration, Instant, SystemTime, UNIX_EPOCH},
9};
10
11use axum::{
12 Json, Router,
13 body::Bytes,
14 extract::{DefaultBodyLimit, Multipart, Path, Query, State},
15 http::{HeaderMap, HeaderValue, Method, StatusCode, header::CONTENT_TYPE},
16 response::{
17 IntoResponse, Response,
18 sse::{Event, KeepAlive, Sse},
19 },
20 routing::{get, post},
21};
22use serde::{Deserialize, Serialize};
23use skenion_contracts::{
24 RuntimeCollaborationAck, RuntimeCollaborationCausalMetadata, RuntimeCollaborationChange,
25 RuntimeCollaborationConflict, RuntimeCollaborationNack, RuntimeCollaborationNackReason,
26 RuntimeCollaborationOperationBatch, RuntimeCollaborationOperationBatchResult,
27 RuntimeCollaborationOperationDiagnostic, RuntimeCollaborationOperationEnvelope,
28 RuntimeCollaborationOperationPayload, RuntimeCollaborationOperationResult,
29 RuntimeCollaborationOperationStatus, RuntimeCollaborationPresenceEnvelope,
30 RuntimeCollaborationRebase, RuntimeCollaborationRebaseStrategy,
31 RuntimeCollaborationSelectionEnvelope, RuntimeCollaborationServerClock,
32 RuntimeCollaborationUndoRedoAction, RuntimeSessionInfoResponse,
33 validate_runtime_collaboration_operation_batch,
34 validate_runtime_collaboration_operation_batch_result,
35 validate_runtime_collaboration_operation_envelope,
36 validate_runtime_collaboration_operation_result,
37 validate_runtime_collaboration_presence_envelope,
38 validate_runtime_collaboration_selection_envelope,
39};
40use tokio_stream::{
41 Stream, StreamExt,
42 wrappers::{BroadcastStream, IntervalStream, errors::BroadcastStreamRecvError},
43};
44use tower_http::cors::{AllowOrigin, CorsLayer};
45
46use crate::{
47 CURRENT_SCHEMA_VERSION, DummyExecutionReport, ExecutionPlan, GeneratedShaderResponse,
48 NodeDefinition, NodeDefinitionCurrent, NodeRegistry, PreviewDocument, ProjectDocumentCurrent,
49 ProjectRequestCurrent, RunProjectRequestCurrent, RuntimeControlEventRequest,
50 RuntimeControlEventResponse, RuntimeControlReadRequest, RuntimeControlReadResponse,
51 RuntimeControlStateResponse, RuntimeExtensionListResponse, RuntimeExtensionManager,
52 RuntimeIoDeviceListResponse, RuntimeIoDeviceManager, RuntimeLogSnapshotResponse,
53 RuntimeLogStore, RuntimeMutationRequest, RuntimeOperationEnvelope, RuntimePatchResponse,
54 RuntimePreviewStartRequest, RuntimeTelemetrySnapshot, SessionRunRequest, ShaderDiagnostic,
55 ShaderDiagnosticPhase, ShaderDiagnosticSource, build_execution_plan_request_current,
56 build_execution_plan_run_request_current, collaboration_broadcast_event_after_high_water,
57 collaboration_event, generated_shader_response_from_preview_document,
58 project_document_payload_schema_diagnostics, project_document_validation_diagnostics_current,
59 run_dummy_execution,
60 runtime_time::created_at_now,
61 schema_version_diagnostic,
62 session_registry::{
63 RuntimeSessionEventKind, RuntimeSessionRecord, RuntimeSessionRegistry, SessionEventsQuery,
64 capture_session_replay, event_cursor_from_headers, publish_session_event,
65 session_broadcast_event_after_high_water, session_event, session_snapshot_event,
66 },
67 sidecar::{
68 RuntimeEndpointConfig, RuntimeSidecarHealthResponse, RuntimeSidecarShutdownResponse,
69 RuntimeSidecarStartupResponse, runtime_connection_profile, sidecar_health_response,
70 sidecar_shutdown_response, sidecar_startup_response,
71 },
72 validate_project_request_current,
73};
74
75pub const RUNTIME_API_VERSION: &str = "0.1.0";
76pub const DEFAULT_HOST: &str = "127.0.0.1";
77pub const DEFAULT_PORT: u16 = 3761;
78const MAX_ASSET_UPLOAD_BYTES: usize = 512 * 1024 * 1024;
79
80#[derive(Debug, Clone, Deserialize, Serialize)]
81pub struct HealthResponse {
82 pub ok: bool,
83 pub service: &'static str,
84 pub version: &'static str,
85 pub api_version: &'static str,
86}
87
88#[derive(Debug, Clone, Serialize)]
89#[serde(rename_all = "camelCase")]
90pub struct RuntimeInfoResponse {
91 pub name: &'static str,
92 pub version: &'static str,
93 pub api_version: &'static str,
94 pub capabilities: Vec<&'static str>,
95}
96
97#[derive(Debug, Clone, Serialize)]
98#[serde(rename_all = "camelCase")]
99pub struct RuntimeApiResponse {
100 pub ok: bool,
101 pub diagnostics: Vec<RuntimeDiagnostic>,
102 pub plan: Option<ExecutionPlan>,
103 pub report: Option<DummyExecutionReport>,
104}
105
106#[derive(Debug, Clone, Serialize)]
107#[serde(untagged)]
108enum CollaborationOperationResponse {
109 Batch(Box<RuntimeCollaborationOperationBatchResult>),
110 Single(Box<RuntimeCollaborationOperationResult>),
111 Paste(Box<crate::PasteGraphFragmentResponse>),
112}
113
114#[derive(Debug)]
115struct LoweredCollaborationChangeSet {
116 target: crate::GraphTargetRef,
117 changes: Vec<RuntimeCollaborationChange>,
118 actor_id: Option<String>,
119 client_id: Option<String>,
120 description: Option<String>,
121 transformed_payload: RuntimeCollaborationOperationPayload,
122}
123
124#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
125#[serde(rename_all = "camelCase")]
126pub struct RuntimeDiagnostic {
127 pub severity: DiagnosticSeverity,
128 pub message: String,
129 #[serde(default, skip_serializing_if = "Option::is_none")]
130 pub code: Option<String>,
131 #[serde(default, skip_serializing_if = "Option::is_none")]
132 pub details: Option<serde_json::Value>,
133}
134
135#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
136#[serde(rename_all = "lowercase")]
137pub enum DiagnosticSeverity {
138 Error,
139 Warning,
140 Info,
141}
142
143#[derive(Clone)]
144pub struct RuntimeServerState {
145 pub sessions: RuntimeSessionRegistry,
146 pub assets: Arc<RwLock<RuntimeAssetStore>>,
147 pub io_devices: Arc<RuntimeIoDeviceManager>,
148 pub extensions: Arc<RuntimeExtensionManager>,
149 pub logs: Arc<RuntimeLogStore>,
150 pub endpoint: RuntimeEndpointConfig,
151 pub started_at_wall_clock: String,
152 pub started_at: Instant,
153}
154
155impl Default for RuntimeServerState {
156 fn default() -> Self {
157 Self::with_endpoint(DEFAULT_HOST.to_owned(), DEFAULT_PORT)
158 }
159}
160
161impl RuntimeServerState {
162 pub fn with_endpoint(host: String, port: u16) -> Self {
163 let logs = Arc::new(RuntimeLogStore::default());
164 Self {
165 sessions: RuntimeSessionRegistry::default(),
166 assets: Arc::new(RwLock::new(RuntimeAssetStore::default())),
167 io_devices: Arc::new(RuntimeIoDeviceManager::new()),
168 extensions: Arc::new(RuntimeExtensionManager::from_env()),
169 logs,
170 endpoint: RuntimeEndpointConfig::new(host, port),
171 started_at_wall_clock: created_at_now(),
172 started_at: Instant::now(),
173 }
174 }
175
176 pub fn sidecar_startup_response(&self) -> RuntimeSidecarStartupResponse {
177 sidecar_startup_response(
178 &self.endpoint,
179 self.sessions.default_session_id(),
180 &self.started_at_wall_clock,
181 )
182 }
183
184 pub fn sidecar_health_response(&self) -> RuntimeSidecarHealthResponse {
185 sidecar_health_response(&self.endpoint, &self.started_at_wall_clock)
186 }
187}
188
189#[derive(Debug, Clone, Default)]
190pub struct RuntimeAssetStore {
191 assets: BTreeMap<String, RuntimeAsset>,
192}
193
194#[derive(Debug, Clone, Serialize)]
195#[serde(rename_all = "camelCase")]
196pub struct RuntimeAsset {
197 pub id: String,
198 pub name: String,
199 pub mime_type: String,
200 pub kind: String,
201 pub size_bytes: u64,
202 pub runtime_uri: String,
203}
204
205#[derive(Debug, Clone, Serialize)]
206#[serde(rename_all = "camelCase")]
207pub struct RuntimeAssetImportResponse {
208 pub ok: bool,
209 pub asset: Option<RuntimeAsset>,
210 pub diagnostics: Vec<RuntimeDiagnostic>,
211}
212
213#[derive(Debug, Clone, Serialize)]
214#[serde(rename_all = "camelCase")]
215pub struct RuntimeAssetListResponse {
216 pub ok: bool,
217 pub assets: Vec<RuntimeAsset>,
218 pub diagnostics: Vec<RuntimeDiagnostic>,
219}
220
221#[derive(Debug, Clone, Serialize)]
222#[serde(rename_all = "camelCase")]
223pub struct RuntimeAssetGetResponse {
224 pub ok: bool,
225 pub asset: Option<RuntimeAsset>,
226 pub diagnostics: Vec<RuntimeDiagnostic>,
227}
228
229pub fn runtime_router() -> Router {
230 runtime_router_with_state(RuntimeServerState::default())
231}
232
233pub fn runtime_router_with_state(state: RuntimeServerState) -> Router {
234 Router::new()
235 .route("/health", get(health))
236 .route("/v0/runtime/info", get(runtime_info))
237 .route("/v0/sidecar/startup", get(sidecar_startup))
238 .route("/v0/sidecar/health", get(sidecar_health))
239 .route("/v0/sidecar/shutdown", post(sidecar_shutdown))
240 .route("/v0/extensions", get(runtime_extensions))
241 .route("/v0/runtime/logs", get(runtime_logs))
242 .route("/v0/runtime/logs/stream", get(runtime_logs_stream))
243 .route("/v0/io/devices", get(io_devices))
244 .route("/v0/validate", post(validate_project_endpoint))
245 .route("/v0/plan", post(plan_project_endpoint))
246 .route("/v0/run", post(run_project_endpoint))
247 .route(
248 "/v0/sessions/{session_id}",
249 get(session_snapshot_by_id).delete(clear_session_by_id),
250 )
251 .route("/v0/sessions/{session_id}/info", get(session_info_by_id))
252 .route(
253 "/v0/sessions/{session_id}/events/stream",
254 get(session_events_stream_by_id),
255 )
256 .route("/v0/sessions/{session_id}/load", post(load_session_by_id))
257 .route(
258 "/v0/sessions/{session_id}/validate",
259 post(validate_session_by_id),
260 )
261 .route("/v0/sessions/{session_id}/plan", post(plan_session_by_id))
262 .route("/v0/sessions/{session_id}/run", post(run_session_by_id))
263 .route(
264 "/v0/sessions/{session_id}/mutate",
265 post(mutate_session_by_id),
266 )
267 .route(
268 "/v0/sessions/{session_id}/operation",
269 post(apply_session_operation_by_id),
270 )
271 .route(
272 "/v0/sessions/{session_id}/operations",
273 post(apply_session_collaboration_operations_by_id),
274 )
275 .route(
276 "/v0/sessions/{session_id}/collaboration/presence",
277 post(update_session_collaboration_presence_by_id),
278 )
279 .route(
280 "/v0/sessions/{session_id}/collaboration/selection",
281 post(update_session_collaboration_selection_by_id),
282 )
283 .route(
284 "/v0/sessions/{session_id}/collaboration/events/stream",
285 get(session_collaboration_events_stream_by_id),
286 )
287 .route(
288 "/v0/sessions/{session_id}/history",
289 get(session_history_by_id),
290 )
291 .route("/v0/sessions/{session_id}/undo", post(undo_session_by_id))
292 .route("/v0/sessions/{session_id}/redo", post(redo_session_by_id))
293 .route(
294 "/v0/sessions/{session_id}/control/event",
295 post(control_event_by_id),
296 )
297 .route(
298 "/v0/sessions/{session_id}/control/state",
299 get(control_state_by_id),
300 )
301 .route(
302 "/v0/sessions/{session_id}/control/read",
303 post(control_read_by_id),
304 )
305 .route(
306 "/v0/sessions/{session_id}/preview",
307 get(preview_status_by_id),
308 )
309 .route(
310 "/v0/sessions/{session_id}/preview/start",
311 post(start_preview_by_id),
312 )
313 .route(
314 "/v0/sessions/{session_id}/preview/stop",
315 post(stop_preview_by_id),
316 )
317 .route(
318 "/v0/sessions/{session_id}/preview/restart",
319 post(restart_preview_by_id),
320 )
321 .route(
322 "/v0/sessions/{session_id}/render/generated-shader",
323 get(generated_shader_by_id),
324 )
325 .route(
326 "/v0/sessions/{session_id}/telemetry",
327 get(session_telemetry_by_id),
328 )
329 .route(
330 "/v0/sessions/{session_id}/telemetry/stream",
331 get(session_telemetry_stream_by_id),
332 )
333 .route(
334 "/v0/assets/import",
335 post(import_asset).layer(DefaultBodyLimit::max(MAX_ASSET_UPLOAD_BYTES)),
336 )
337 .route("/v0/assets", get(list_assets))
338 .route("/v0/assets/{asset_id}", get(get_asset))
339 .with_state(state)
340 .layer(cors_layer())
341}
342
343async fn health() -> Json<HealthResponse> {
344 Json(HealthResponse {
345 ok: true,
346 service: "skenion-runtime",
347 version: env!("CARGO_PKG_VERSION"),
348 api_version: RUNTIME_API_VERSION,
349 })
350}
351
352async fn runtime_info() -> Json<RuntimeInfoResponse> {
353 Json(RuntimeInfoResponse {
354 name: "skenion-runtime",
355 version: env!("CARGO_PKG_VERSION"),
356 api_version: RUNTIME_API_VERSION,
357 capabilities: vec![
358 "project.validate",
359 "project.validate.v0.1",
360 "project.plan",
361 "project.plan.v0.1",
362 "dummy.run",
363 "session.load",
364 "session.load.v0.1",
365 "session.project",
366 "session.project.v0.1",
367 "session.events.stream",
368 "session.validate",
369 "session.plan",
370 "session.run",
371 "session.mutate",
372 "session.operation",
373 "session.collaboration.operations",
374 "session.collaboration.operationBatch",
375 "session.collaboration.events.stream",
376 "session.collaboration.presence",
377 "session.collaboration.selection",
378 "session.collaboration.idempotency",
379 "session.collaboration.rebase.crdtMerge",
380 "session.history",
381 "session.undo",
382 "session.redo",
383 "session.clear",
384 "session.addressing",
385 "session.info",
386 "session.events.replay",
387 "session.control.event",
388 "session.control.state",
389 "session.control.read",
390 "session.control.channels",
391 "session.control.messages",
392 "session.preview.controlState",
393 "session.preview.status",
394 "session.preview.start",
395 "session.preview.stop",
396 "session.preview.restart",
397 "session.render.generatedShader",
398 "assets.import",
399 "assets.list",
400 "assets.get",
401 "session.telemetry",
402 "session.telemetry.stream",
403 "runtime.logs",
404 "runtime.logs.stream",
405 "runtime.extensions",
406 "runtime.profile.localManaged",
407 "runtime.profile.localShared",
408 "runtime.profile.remote",
409 "runtime.sidecar.startup",
410 "runtime.sidecar.health",
411 "runtime.sidecar.shutdown",
412 "io.devices",
413 ],
414 })
415}
416
417async fn sidecar_startup(
418 State(state): State<RuntimeServerState>,
419) -> Json<RuntimeSidecarStartupResponse> {
420 Json(state.sidecar_startup_response())
421}
422
423async fn sidecar_health(
424 State(state): State<RuntimeServerState>,
425) -> Json<RuntimeSidecarHealthResponse> {
426 Json(state.sidecar_health_response())
427}
428
429async fn sidecar_shutdown(
430 State(state): State<RuntimeServerState>,
431 body: Bytes,
432) -> Json<RuntimeSidecarShutdownResponse> {
433 let response = sidecar_shutdown_response(&body);
434 state.logs.record_runtime_diagnostics(&response.diagnostics);
435 Json(response)
436}
437
438async fn runtime_extensions(
439 State(state): State<RuntimeServerState>,
440) -> Json<RuntimeExtensionListResponse> {
441 Json(state.extensions.list_extensions())
442}
443
444async fn runtime_logs(State(state): State<RuntimeServerState>) -> Json<RuntimeLogSnapshotResponse> {
445 Json(state.logs.snapshot())
446}
447
448async fn runtime_logs_stream(
449 State(state): State<RuntimeServerState>,
450) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
451 let receiver = state.logs.subscribe();
452 let replay = tokio_stream::iter(
453 state
454 .logs
455 .snapshot()
456 .events
457 .into_iter()
458 .map(runtime_log_event),
459 );
460 let live = BroadcastStream::new(receiver).map(runtime_log_broadcast_event);
461 Sse::new(replay.chain(live)).keep_alive(KeepAlive::default())
462}
463
464fn runtime_log_broadcast_event(
465 result: Result<crate::RuntimeLogEvent, BroadcastStreamRecvError>,
466) -> Result<Event, Infallible> {
467 match result {
468 Ok(event) => runtime_log_event(event),
469 Err(_) => Ok(Event::default()
470 .event("log-gap")
471 .data("runtime log stream receiver lagged")),
472 }
473}
474
475fn runtime_log_event(event: crate::RuntimeLogEvent) -> Result<Event, Infallible> {
476 Ok(Event::default()
477 .event("log")
478 .json_data(event)
479 .expect("runtime log event should serialize"))
480}
481
482async fn session_events_stream_by_id(
483 State(state): State<RuntimeServerState>,
484 Path(session_id): Path<String>,
485 Query(query): Query<SessionEventsQuery>,
486 headers: HeaderMap,
487) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
488 session_events_stream_for(state.sessions.get_or_create(&session_id), query, headers)
489}
490
491fn session_events_stream_for(
492 record: RuntimeSessionRecord,
493 query: SessionEventsQuery,
494 headers: HeaderMap,
495) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
496 let after = query.after.or_else(|| event_cursor_from_headers(&headers));
497 let receiver = record.events.subscribe();
498 let snapshot = {
499 let session = record
500 .session
501 .read()
502 .expect("runtime session lock should not be poisoned");
503 session_snapshot_event(&record, &session)
504 };
505 let replay = capture_session_replay(&record, after, snapshot);
506 let high_water_sequence = replay.high_water_sequence;
507 let replay = tokio_stream::iter(replay.events.into_iter().map(session_event));
508 let live_record = record.clone();
509 let live = BroadcastStream::new(receiver).filter_map(move |result| {
510 session_broadcast_event_after_high_water(result, live_record.clone(), high_water_sequence)
511 });
512 Sse::new(replay.chain(live)).keep_alive(KeepAlive::default())
513}
514
515async fn session_collaboration_events_stream_by_id(
516 State(state): State<RuntimeServerState>,
517 Path(session_id): Path<String>,
518 Query(query): Query<SessionEventsQuery>,
519 headers: HeaderMap,
520) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
521 session_collaboration_events_stream_for(
522 state.sessions.get_or_create(&session_id),
523 query,
524 headers,
525 )
526}
527
528fn session_collaboration_events_stream_for(
529 record: RuntimeSessionRecord,
530 query: SessionEventsQuery,
531 headers: HeaderMap,
532) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
533 let after = query.after.or_else(|| event_cursor_from_headers(&headers));
534 let replay = record.collaboration.capture_replay(after);
535 let high_water_sequence = replay.high_water_sequence;
536 let replay = tokio_stream::iter(replay.events.into_iter().map(collaboration_event));
537 let live_record = record.clone();
538 let live =
539 BroadcastStream::new(record.collaboration.events.subscribe()).filter_map(move |result| {
540 collaboration_broadcast_event_after_high_water(
541 result,
542 &live_record.collaboration,
543 &live_record.id,
544 high_water_sequence,
545 )
546 });
547 Sse::new(replay.chain(live)).keep_alive(KeepAlive::default())
548}
549
550fn runtime_api_json(
551 state: &RuntimeServerState,
552 response: RuntimeApiResponse,
553) -> Json<RuntimeApiResponse> {
554 state.logs.record_runtime_diagnostics(&response.diagnostics);
555 Json(response)
556}
557
558fn session_json(
559 state: &RuntimeServerState,
560 response: crate::RuntimeSessionResponse,
561) -> Json<crate::RuntimeSessionResponse> {
562 state.logs.record_runtime_diagnostics(&response.diagnostics);
563 Json(response)
564}
565
566fn patch_json(
567 state: &RuntimeServerState,
568 response: crate::RuntimePatchResponse,
569) -> Json<crate::RuntimePatchResponse> {
570 state.logs.record_runtime_diagnostics(&response.diagnostics);
571 Json(response)
572}
573
574fn paste_operation_json(
575 response: crate::PasteGraphFragmentResponse,
576) -> Json<crate::PasteGraphFragmentResponse> {
577 Json(response)
578}
579
580fn control_event_json(
581 state: &RuntimeServerState,
582 response: RuntimeControlEventResponse,
583) -> Json<RuntimeControlEventResponse> {
584 state.logs.record_runtime_diagnostics(&response.diagnostics);
585 Json(response)
586}
587
588fn control_read_json(
589 state: &RuntimeServerState,
590 response: RuntimeControlReadResponse,
591) -> Json<RuntimeControlReadResponse> {
592 state.logs.record_runtime_diagnostics(&response.diagnostics);
593 Json(response)
594}
595
596fn preview_status_json(
597 state: &RuntimeServerState,
598 response: crate::RuntimePreviewStatusResponse,
599) -> Json<crate::RuntimePreviewStatusResponse> {
600 state.logs.record_runtime_diagnostics(&response.diagnostics);
601 Json(response)
602}
603
604fn asset_import_json(
605 state: &RuntimeServerState,
606 response: RuntimeAssetImportResponse,
607) -> Json<RuntimeAssetImportResponse> {
608 state.logs.record_runtime_diagnostics(&response.diagnostics);
609 Json(response)
610}
611
612fn asset_get_json(
613 state: &RuntimeServerState,
614 response: RuntimeAssetGetResponse,
615) -> Json<RuntimeAssetGetResponse> {
616 state.logs.record_runtime_diagnostics(&response.diagnostics);
617 Json(response)
618}
619
620fn generated_shader_json(
621 state: &RuntimeServerState,
622 response: GeneratedShaderResponse,
623) -> Json<GeneratedShaderResponse> {
624 state.logs.record_shader_diagnostics(&response.diagnostics);
625 Json(response)
626}
627
628async fn io_devices(State(state): State<RuntimeServerState>) -> Json<RuntimeIoDeviceListResponse> {
629 let response = state.io_devices.list_devices();
630 state.logs.record_io_diagnostics(&response.diagnostics);
631 Json(response)
632}
633
634async fn validate_project_endpoint(
635 State(state): State<RuntimeServerState>,
636 Json(value): Json<serde_json::Value>,
637) -> Json<RuntimeApiResponse> {
638 let response = match decode_project_payload(value) {
639 Ok(ProjectPayload::Current(request)) => match validate_project_request_current(&request) {
640 Ok((diagnostics, _)) => RuntimeApiResponse {
641 ok: true,
642 diagnostics,
643 plan: None,
644 report: None,
645 },
646 Err(diagnostics) => RuntimeApiResponse::diagnostics(diagnostics),
647 },
648 Err(diagnostics) => RuntimeApiResponse::diagnostics(diagnostics),
649 };
650 runtime_api_json(&state, response)
651}
652
653async fn plan_project_endpoint(
654 State(state): State<RuntimeServerState>,
655 Json(value): Json<serde_json::Value>,
656) -> Json<RuntimeApiResponse> {
657 match decode_project_payload(value) {
658 Ok(ProjectPayload::Current(request)) => {
659 match build_execution_plan_request_current(&request) {
660 Ok((plan, diagnostics)) => runtime_api_json(
661 &state,
662 RuntimeApiResponse {
663 ok: true,
664 diagnostics,
665 plan: Some(plan),
666 report: None,
667 },
668 ),
669 Err(diagnostics) => {
670 runtime_api_json(&state, RuntimeApiResponse::diagnostics(diagnostics))
671 }
672 }
673 }
674 Err(diagnostics) => runtime_api_json(&state, RuntimeApiResponse::diagnostics(diagnostics)),
675 }
676}
677
678async fn run_project_endpoint(
679 State(state): State<RuntimeServerState>,
680 Json(value): Json<serde_json::Value>,
681) -> Json<RuntimeApiResponse> {
682 match decode_run_project_payload(value) {
683 Ok(RunProjectPayload::Current(request)) => {
684 match build_execution_plan_run_request_current(&request) {
685 Ok((plan, diagnostics)) => {
686 let report = run_dummy_execution(&plan, request.frames.unwrap_or(1));
687 runtime_api_json(
688 &state,
689 RuntimeApiResponse {
690 ok: true,
691 diagnostics,
692 plan: Some(plan),
693 report: Some(report),
694 },
695 )
696 }
697 Err(diagnostics) => {
698 runtime_api_json(&state, RuntimeApiResponse::diagnostics(diagnostics))
699 }
700 }
701 }
702 Err(diagnostics) => runtime_api_json(&state, RuntimeApiResponse::diagnostics(diagnostics)),
703 }
704}
705
706async fn session_snapshot_by_id(
707 State(state): State<RuntimeServerState>,
708 Path(session_id): Path<String>,
709) -> Json<crate::RuntimeSessionResponse> {
710 session_snapshot_for(state.sessions.get_or_create(&session_id))
711}
712
713fn session_snapshot_for(record: RuntimeSessionRecord) -> Json<crate::RuntimeSessionResponse> {
714 let session = record
715 .session
716 .read()
717 .expect("runtime session lock should not be poisoned");
718 Json(session.response(true, session.snapshot().diagnostics, None))
719}
720
721async fn session_info_by_id(
722 State(state): State<RuntimeServerState>,
723 Path(session_id): Path<String>,
724) -> Json<RuntimeSessionInfoResponse> {
725 Json(session_info_for(
726 &state,
727 state.sessions.get_or_create(&session_id),
728 ))
729}
730
731fn session_info_for(
732 state: &RuntimeServerState,
733 record: RuntimeSessionRecord,
734) -> RuntimeSessionInfoResponse {
735 let profile = runtime_connection_profile(&state.endpoint, &state.started_at_wall_clock);
736 record.info_response(profile)
737}
738
739async fn load_session_by_id(
740 State(state): State<RuntimeServerState>,
741 Path(session_id): Path<String>,
742 Json(value): Json<serde_json::Value>,
743) -> Json<crate::RuntimeSessionResponse> {
744 load_session_for(&state, state.sessions.get_or_create(&session_id), value)
745}
746
747fn load_session_for(
748 state: &RuntimeServerState,
749 record: RuntimeSessionRecord,
750 value: serde_json::Value,
751) -> Json<crate::RuntimeSessionResponse> {
752 let _coordination_guard = record.collaboration.operation_guard();
753 let mut session = record
754 .session
755 .write()
756 .expect("runtime session lock should not be poisoned");
757 let request = match decode_project_payload(value) {
758 Ok(ProjectPayload::Current(request)) => request,
759 Err(diagnostics) => {
760 let response = session.response(false, diagnostics, None);
761 return session_json(state, response);
762 }
763 };
764 let response = session.load_project_current(*request);
765 if response.ok && response.snapshot.loaded() {
766 publish_session_event(
767 &record,
768 RuntimeSessionEventKind::Load,
769 &session,
770 response.diagnostics.clone(),
771 );
772 }
773 session_json(state, response)
774}
775
776async fn validate_session_by_id(
777 State(state): State<RuntimeServerState>,
778 Path(session_id): Path<String>,
779) -> Json<crate::RuntimeSessionResponse> {
780 validate_session_for(&state, state.sessions.get_or_create(&session_id))
781}
782
783fn validate_session_for(
784 state: &RuntimeServerState,
785 record: RuntimeSessionRecord,
786) -> Json<crate::RuntimeSessionResponse> {
787 let mut session = record
788 .session
789 .write()
790 .expect("runtime session lock should not be poisoned");
791 let response = session.validate_current();
792 session_json(state, response)
793}
794
795async fn plan_session_by_id(
796 State(state): State<RuntimeServerState>,
797 Path(session_id): Path<String>,
798) -> Json<crate::RuntimeSessionResponse> {
799 plan_session_for(&state, state.sessions.get_or_create(&session_id))
800}
801
802fn plan_session_for(
803 state: &RuntimeServerState,
804 record: RuntimeSessionRecord,
805) -> Json<crate::RuntimeSessionResponse> {
806 let mut session = record
807 .session
808 .write()
809 .expect("runtime session lock should not be poisoned");
810 let response = session.plan_current();
811 session_json(state, response)
812}
813
814async fn run_session_by_id(
815 State(state): State<RuntimeServerState>,
816 Path(session_id): Path<String>,
817 Json(request): Json<SessionRunRequest>,
818) -> Json<crate::RuntimeSessionResponse> {
819 run_session_for(&state, state.sessions.get_or_create(&session_id), request)
820}
821
822fn run_session_for(
823 state: &RuntimeServerState,
824 record: RuntimeSessionRecord,
825 request: SessionRunRequest,
826) -> Json<crate::RuntimeSessionResponse> {
827 let mut session = record
828 .session
829 .write()
830 .expect("runtime session lock should not be poisoned");
831 let response = session.run_current(request.frames.unwrap_or(1));
832 session_json(state, response)
833}
834
835async fn mutate_session_by_id(
836 State(state): State<RuntimeServerState>,
837 Path(session_id): Path<String>,
838 Json(value): Json<serde_json::Value>,
839) -> Json<crate::RuntimePatchResponse> {
840 mutate_session_for(&state, state.sessions.get_or_create(&session_id), value)
841}
842
843fn mutate_session_for(
844 state: &RuntimeServerState,
845 record: RuntimeSessionRecord,
846 value: serde_json::Value,
847) -> Json<crate::RuntimePatchResponse> {
848 let _coordination_guard = record.collaboration.operation_guard();
849 let mut session = record
850 .session
851 .write()
852 .expect("runtime session lock should not be poisoned");
853 let mutation = match serde_json::from_value::<RuntimeMutationRequest>(value) {
854 Ok(mutation) => mutation,
855 Err(error) => {
856 let response = session.reject_patch(
857 false,
858 vec![RuntimeDiagnostic::error(format!(
859 "invalid runtime mutation: {error}"
860 ))],
861 );
862 return patch_json(state, response);
863 }
864 };
865
866 let response = session.apply_mutation(mutation);
867 if response.ok && response.applied {
868 publish_session_event(
869 &record,
870 RuntimeSessionEventKind::Mutate,
871 &session,
872 response.diagnostics.clone(),
873 );
874 }
875 patch_json(state, response)
876}
877
878async fn apply_session_operation_by_id(
879 State(state): State<RuntimeServerState>,
880 Path(session_id): Path<String>,
881 Json(value): Json<serde_json::Value>,
882) -> Json<crate::PasteGraphFragmentResponse> {
883 apply_session_operation_for(&state, state.sessions.get_or_create(&session_id), value)
884}
885
886fn apply_session_operation_for(
887 _state: &RuntimeServerState,
888 record: RuntimeSessionRecord,
889 value: serde_json::Value,
890) -> Json<crate::PasteGraphFragmentResponse> {
891 let _coordination_guard = record.collaboration.operation_guard();
892 let mut session = record
893 .session
894 .write()
895 .expect("runtime session lock should not be poisoned");
896 let operation = match serde_json::from_value::<RuntimeOperationEnvelope>(value) {
897 Ok(operation) => operation,
898 Err(error) => {
899 let revision_before = session
900 .snapshot()
901 .graph_revision()
902 .map(ToOwned::to_owned)
903 .unwrap_or_else(|| "0".to_owned());
904 return paste_operation_json(crate::PasteGraphFragmentResponse {
905 schema: "skenion.runtime.paste-graph-fragment.response".to_owned(),
906 schema_version: "0.1.0".to_owned(),
907 ok: false,
908 applied: false,
909 conflict: false,
910 target: crate::GraphTargetRef {
911 path: crate::PatchPath::Root,
912 base_revision: revision_before.clone(),
913 target_revision: None,
914 },
915 revision_before,
916 revision_after: None,
917 history_entry_id: None,
918 id_remap: crate::IdRemapResult {
919 node_id_map: BTreeMap::new(),
920 edge_id_map: BTreeMap::new(),
921 omitted_edge_ids: Vec::new(),
922 },
923 diagnostics: vec![crate::RuntimeOperationDiagnostic {
924 severity: "error".to_owned(),
925 code: "paste.operation.invalid-json".to_owned(),
926 message: format!("invalid runtime operation: {error}"),
927 path: None,
928 target: None,
929 expected_revision: None,
930 actual_revision: None,
931 duplicates: None,
932 nodes: None,
933 edges: None,
934 }],
935 });
936 }
937 };
938
939 let response = session.apply_runtime_operation(operation);
940 if response.ok && response.applied {
941 publish_session_event(
942 &record,
943 RuntimeSessionEventKind::Mutate,
944 &session,
945 Vec::new(),
946 );
947 }
948 paste_operation_json(response)
949}
950
951async fn apply_session_collaboration_operations_by_id(
952 State(state): State<RuntimeServerState>,
953 Path(session_id): Path<String>,
954 Json(value): Json<serde_json::Value>,
955) -> Json<CollaborationOperationResponse> {
956 apply_session_collaboration_operations_for(
957 &state,
958 state.sessions.get_or_create(&session_id),
959 value,
960 )
961}
962
963fn apply_session_collaboration_operations_for(
964 _state: &RuntimeServerState,
965 record: RuntimeSessionRecord,
966 value: serde_json::Value,
967) -> Json<CollaborationOperationResponse> {
968 let response = match value.get("schema").and_then(serde_json::Value::as_str) {
969 Some("skenion.runtime.operation") => {
970 match serde_json::from_value::<RuntimeOperationEnvelope>(value) {
971 Ok(operation) => {
972 let _coordination_guard = record.collaboration.operation_guard();
973 let mut session = record
974 .session
975 .write()
976 .expect("runtime session lock should not be poisoned");
977 let response = session.apply_runtime_operation(operation);
978 if response.ok && response.applied {
979 publish_session_event(
980 &record,
981 RuntimeSessionEventKind::Mutate,
982 &session,
983 Vec::new(),
984 );
985 }
986 CollaborationOperationResponse::Paste(Box::new(response))
987 }
988 Err(error) => CollaborationOperationResponse::Paste(Box::new(
989 invalid_paste_operation_response(
990 &record,
991 format!("invalid runtime operation: {error}"),
992 ),
993 )),
994 }
995 }
996 Some("skenion.runtime.collaboration.operation-batch") => {
997 match serde_json::from_value::<RuntimeCollaborationOperationBatch>(value) {
998 Ok(batch) => CollaborationOperationResponse::Batch(Box::new(
999 apply_collaboration_operation_batch(&record, batch),
1000 )),
1001 Err(error) => CollaborationOperationResponse::Batch(Box::new(
1002 invalid_collaboration_batch_result(
1003 &record.id,
1004 format!("invalid collaboration batch: {error}"),
1005 ),
1006 )),
1007 }
1008 }
1009 _ => match serde_json::from_value::<RuntimeCollaborationOperationEnvelope>(value) {
1010 Ok(operation) => CollaborationOperationResponse::Single(Box::new(
1011 apply_collaboration_operation(&record, operation),
1012 )),
1013 Err(error) => CollaborationOperationResponse::Single(Box::new(
1014 invalid_collaboration_operation_result(
1015 &record,
1016 "invalid-operation",
1017 "unknown",
1018 "invalid-operation",
1019 RuntimeCollaborationCausalMetadata {
1020 base_revision: current_session_graph_revision(&record),
1021 base_sequence: 0,
1022 vector: BTreeMap::from([("runtime".to_owned(), 0)]),
1023 observed_operation_ids: None,
1024 },
1025 format!("invalid collaboration operation: {error}"),
1026 ),
1027 )),
1028 },
1029 };
1030 Json(response)
1031}
1032
1033async fn update_session_collaboration_presence_by_id(
1034 State(state): State<RuntimeServerState>,
1035 Path(session_id): Path<String>,
1036 Json(presence): Json<RuntimeCollaborationPresenceEnvelope>,
1037) -> Response {
1038 update_session_collaboration_presence_for(state.sessions.get_or_create(&session_id), presence)
1039}
1040
1041fn update_session_collaboration_presence_for(
1042 record: RuntimeSessionRecord,
1043 mut presence: RuntimeCollaborationPresenceEnvelope,
1044) -> Response {
1045 let _coordination_guard = record.collaboration.operation_guard();
1046 presence.session_id = record.id.clone();
1047 if let Err(report) = validate_runtime_collaboration_presence_envelope(&presence) {
1048 return invalid_collaboration_metadata_response(
1049 "collaboration.invalid-presence",
1050 format!("invalid collaboration presence: {report}"),
1051 );
1052 }
1053 let sequence = record.collaboration.reserve_sequence();
1054 record
1055 .collaboration
1056 .publish_presence(sequence, presence.clone());
1057 Json(presence).into_response()
1058}
1059
1060async fn update_session_collaboration_selection_by_id(
1061 State(state): State<RuntimeServerState>,
1062 Path(session_id): Path<String>,
1063 Json(selection): Json<RuntimeCollaborationSelectionEnvelope>,
1064) -> Response {
1065 update_session_collaboration_selection_for(state.sessions.get_or_create(&session_id), selection)
1066}
1067
1068fn update_session_collaboration_selection_for(
1069 record: RuntimeSessionRecord,
1070 mut selection: RuntimeCollaborationSelectionEnvelope,
1071) -> Response {
1072 let _coordination_guard = record.collaboration.operation_guard();
1073 selection.session_id = record.id.clone();
1074 if let Err(report) = validate_runtime_collaboration_selection_envelope(&selection) {
1075 return invalid_collaboration_metadata_response(
1076 "collaboration.invalid-selection",
1077 format!("invalid collaboration selection: {report}"),
1078 );
1079 }
1080 let sequence = record.collaboration.reserve_sequence();
1081 record
1082 .collaboration
1083 .publish_selection(sequence, selection.clone());
1084 Json(selection).into_response()
1085}
1086
1087fn invalid_collaboration_metadata_response(code: &str, message: String) -> Response {
1088 (
1089 StatusCode::BAD_REQUEST,
1090 Json(serde_json::json!({
1091 "ok": false,
1092 "diagnostics": [{
1093 "severity": "error",
1094 "code": code,
1095 "message": message
1096 }]
1097 })),
1098 )
1099 .into_response()
1100}
1101
1102fn apply_collaboration_operation_batch(
1103 record: &RuntimeSessionRecord,
1104 batch: RuntimeCollaborationOperationBatch,
1105) -> RuntimeCollaborationOperationBatchResult {
1106 if let Err(report) = validate_runtime_collaboration_operation_batch(&batch) {
1107 return invalid_collaboration_batch_result(
1108 &record.id,
1109 format!("invalid collaboration batch: {report}"),
1110 );
1111 }
1112 if batch.session_id != record.id {
1113 return invalid_collaboration_batch_result(
1114 &record.id,
1115 format!(
1116 "collaboration batch sessionId {} does not match Runtime session {}",
1117 batch.session_id, record.id
1118 ),
1119 );
1120 }
1121
1122 let results = batch
1123 .operations
1124 .into_iter()
1125 .map(|operation| apply_collaboration_operation(record, operation))
1126 .collect();
1127 let result = RuntimeCollaborationOperationBatchResult {
1128 schema: "skenion.runtime.collaboration.operation-batch-result".to_owned(),
1129 schema_version: "0.1.0".to_owned(),
1130 session_id: record.id.clone(),
1131 results,
1132 diagnostics: Vec::new(),
1133 created_at: created_at_now(),
1134 };
1135 validate_runtime_collaboration_operation_batch_result(&result)
1136 .expect("runtime collaboration batch result should validate");
1137 result
1138}
1139
1140fn apply_collaboration_operation(
1141 record: &RuntimeSessionRecord,
1142 operation: RuntimeCollaborationOperationEnvelope,
1143) -> RuntimeCollaborationOperationResult {
1144 let _operation_guard = record.collaboration.operation_guard();
1145 if let Err(report) = validate_runtime_collaboration_operation_envelope(&operation) {
1146 return publish_collaboration_operation_result(
1147 record,
1148 invalid_collaboration_operation_result(
1149 record,
1150 &operation.operation_id,
1151 &operation.participant_id,
1152 &operation.idempotency_key,
1153 operation.causal.clone(),
1154 format!("invalid collaboration operation: {report}"),
1155 ),
1156 );
1157 }
1158 if operation.session_id != record.id {
1159 return publish_collaboration_operation_result(
1160 record,
1161 invalid_collaboration_operation_result(
1162 record,
1163 &operation.operation_id,
1164 &operation.participant_id,
1165 &operation.idempotency_key,
1166 operation.causal.clone(),
1167 format!(
1168 "collaboration operation sessionId {} does not match Runtime session {}",
1169 operation.session_id, record.id
1170 ),
1171 ),
1172 );
1173 }
1174 if record
1175 .collaboration
1176 .has_idempotency_key(&operation.idempotency_key)
1177 {
1178 return publish_collaboration_operation_result(
1179 record,
1180 duplicate_collaboration_operation_result(record, &operation),
1181 );
1182 }
1183
1184 let payload_target = collaboration_payload_target(&operation.payload);
1185 let current_revision = current_session_target_revision(record, payload_target);
1186 let payload_requires_rebase = collaboration_payload_base_revision(&operation.payload)
1187 .is_some_and(|base_revision| base_revision != current_revision);
1188 let requires_rebase =
1189 operation.causal.base_revision != current_revision || payload_requires_rebase;
1190 let transformed_payload =
1191 transform_collaboration_payload_to_revision(&operation.payload, ¤t_revision);
1192 let rebase = requires_rebase.then(|| {
1193 collaboration_rebase(
1194 record,
1195 &operation,
1196 current_revision.clone(),
1197 RuntimeCollaborationRebaseStrategy::CrdtMerge,
1198 Some(transformed_payload.clone()),
1199 Vec::new(),
1200 )
1201 });
1202
1203 match &transformed_payload {
1204 RuntimeCollaborationOperationPayload::PasteGraphFragment {
1205 request,
1206 description,
1207 ..
1208 } => {
1209 let runtime_operation = RuntimeOperationEnvelope {
1210 schema: "skenion.runtime.operation".to_owned(),
1211 schema_version: "0.1.0".to_owned(),
1212 id: operation.operation_id.clone(),
1213 kind: "pasteGraphFragment".to_owned(),
1214 request: (**request).clone(),
1215 attribution: Some(crate::RuntimeOperationAttribution {
1216 actor_id: Some(operation.participant_id.clone()),
1217 client_id: operation.correlation_id.clone(),
1218 label: description.clone(),
1219 }),
1220 correlation_id: operation.correlation_id.clone(),
1221 created_at: Some(operation.submitted_at.clone()),
1222 };
1223 apply_collaboration_paste_operation(record, operation, runtime_operation, rebase)
1224 }
1225 RuntimeCollaborationOperationPayload::ChangeSet {
1226 target,
1227 changes,
1228 description,
1229 ..
1230 } => {
1231 let lowered = LoweredCollaborationChangeSet {
1232 target: target.clone(),
1233 changes: changes.clone(),
1234 actor_id: Some(operation.participant_id.clone()),
1235 client_id: operation.correlation_id.clone(),
1236 description: description.clone(),
1237 transformed_payload: transformed_payload.clone(),
1238 };
1239 apply_collaboration_change_set_operation(record, operation, lowered, rebase)
1240 }
1241 RuntimeCollaborationOperationPayload::UndoRedo { action, .. } => {
1242 apply_collaboration_undo_redo_operation(record, operation, action.clone(), rebase)
1243 }
1244 }
1245}
1246
1247fn collaboration_payload_base_revision(
1248 payload: &RuntimeCollaborationOperationPayload,
1249) -> Option<&str> {
1250 match payload {
1251 RuntimeCollaborationOperationPayload::ChangeSet { target, .. } => {
1252 Some(target.base_revision.as_str())
1253 }
1254 RuntimeCollaborationOperationPayload::PasteGraphFragment { request, .. } => {
1255 Some(request.target.base_revision.as_str())
1256 }
1257 RuntimeCollaborationOperationPayload::UndoRedo { .. } => None,
1258 }
1259}
1260
1261fn collaboration_payload_target(
1262 payload: &RuntimeCollaborationOperationPayload,
1263) -> Option<&crate::GraphTargetRef> {
1264 match payload {
1265 RuntimeCollaborationOperationPayload::ChangeSet { target, .. } => Some(target),
1266 RuntimeCollaborationOperationPayload::PasteGraphFragment { request, .. } => {
1267 Some(&request.target)
1268 }
1269 RuntimeCollaborationOperationPayload::UndoRedo { .. } => None,
1270 }
1271}
1272
1273fn transform_collaboration_payload_to_revision(
1274 payload: &RuntimeCollaborationOperationPayload,
1275 revision: &str,
1276) -> RuntimeCollaborationOperationPayload {
1277 let mut payload = payload.clone();
1278 match &mut payload {
1279 RuntimeCollaborationOperationPayload::ChangeSet { target, .. } => {
1280 target.base_revision = revision.to_owned();
1281 }
1282 RuntimeCollaborationOperationPayload::PasteGraphFragment { request, .. } => {
1283 request.target.base_revision = revision.to_owned();
1284 }
1285 RuntimeCollaborationOperationPayload::UndoRedo { .. } => {}
1286 }
1287 payload
1288}
1289
1290fn apply_collaboration_paste_operation(
1291 record: &RuntimeSessionRecord,
1292 operation: RuntimeCollaborationOperationEnvelope,
1293 runtime_operation: RuntimeOperationEnvelope,
1294 rebase: Option<RuntimeCollaborationRebase>,
1295) -> RuntimeCollaborationOperationResult {
1296 let sequence = record.collaboration.reserve_sequence();
1297 let mut session = record
1298 .session
1299 .write()
1300 .expect("runtime session lock should not be poisoned");
1301 let response = session.apply_runtime_operation(runtime_operation);
1302 if response.ok && response.applied {
1303 publish_session_event(
1304 record,
1305 RuntimeSessionEventKind::Mutate,
1306 &session,
1307 Vec::new(),
1308 );
1309 }
1310 let revision = response
1311 .revision_after
1312 .clone()
1313 .unwrap_or_else(|| response.revision_before.clone());
1314 let diagnostics: Vec<_> = response
1315 .diagnostics
1316 .iter()
1317 .map(|diagnostic| {
1318 collaboration_diagnostic_from_operation_diagnostic(
1319 diagnostic,
1320 &operation.operation_id,
1321 &operation.participant_id,
1322 &operation.idempotency_key,
1323 )
1324 })
1325 .collect();
1326 let status = if response.ok && response.applied {
1327 if rebase.is_some() {
1328 RuntimeCollaborationOperationStatus::Rebased
1329 } else {
1330 RuntimeCollaborationOperationStatus::Accepted
1331 }
1332 } else {
1333 RuntimeCollaborationOperationStatus::Rejected
1334 };
1335 let nack = if status == RuntimeCollaborationOperationStatus::Rejected {
1336 Some(RuntimeCollaborationNack {
1337 reason: RuntimeCollaborationNackReason::InvalidOperation,
1338 retryable: Some(response.conflict),
1339 diagnostics: Some(diagnostics.clone()),
1340 })
1341 } else {
1342 None
1343 };
1344 let ack = if status != RuntimeCollaborationOperationStatus::Rejected {
1345 Some(collaboration_ack(&operation, sequence, revision))
1346 } else {
1347 None
1348 };
1349
1350 publish_collaboration_operation_result(
1351 record,
1352 RuntimeCollaborationOperationResult {
1353 schema: "skenion.runtime.collaboration.operation-result".to_owned(),
1354 schema_version: "0.1.0".to_owned(),
1355 session_id: record.id.clone(),
1356 operation_id: operation.operation_id,
1357 participant_id: operation.participant_id,
1358 idempotency_key: operation.idempotency_key,
1359 status,
1360 causal: operation.causal,
1361 ack,
1362 nack,
1363 rebase,
1364 diagnostics,
1365 created_at: created_at_now(),
1366 },
1367 )
1368}
1369
1370fn apply_collaboration_change_set_operation(
1371 record: &RuntimeSessionRecord,
1372 operation: RuntimeCollaborationOperationEnvelope,
1373 lowered: LoweredCollaborationChangeSet,
1374 rebase: Option<RuntimeCollaborationRebase>,
1375) -> RuntimeCollaborationOperationResult {
1376 let sequence = record.collaboration.reserve_sequence();
1377 let mut session = record
1378 .session
1379 .write()
1380 .expect("runtime session lock should not be poisoned");
1381 let target = lowered.target.clone();
1382 let response = session.apply_collaboration_change_set_current(
1383 target.clone(),
1384 lowered.changes,
1385 lowered.actor_id,
1386 lowered.client_id,
1387 lowered.description,
1388 );
1389 if response.ok && response.applied {
1390 publish_session_event(
1391 record,
1392 RuntimeSessionEventKind::Mutate,
1393 &session,
1394 Vec::new(),
1395 );
1396 }
1397 let target_revision = session
1398 .target_revision_current(&target)
1399 .or_else(|| response.snapshot.graph_revision().map(ToOwned::to_owned))
1400 .unwrap_or_else(|| "0".to_owned());
1401 collaboration_result_from_patch_response(
1402 record,
1403 operation,
1404 response,
1405 sequence,
1406 rebase,
1407 Some(target_revision),
1408 Some(lowered.transformed_payload),
1409 )
1410}
1411
1412fn apply_collaboration_undo_redo_operation(
1413 record: &RuntimeSessionRecord,
1414 operation: RuntimeCollaborationOperationEnvelope,
1415 action: RuntimeCollaborationUndoRedoAction,
1416 rebase: Option<RuntimeCollaborationRebase>,
1417) -> RuntimeCollaborationOperationResult {
1418 let sequence = record.collaboration.reserve_sequence();
1419 let mut session = record
1420 .session
1421 .write()
1422 .expect("runtime session lock should not be poisoned");
1423 let response = match action {
1424 RuntimeCollaborationUndoRedoAction::Undo => {
1425 session.undo_for_actor(&operation.participant_id)
1426 }
1427 RuntimeCollaborationUndoRedoAction::Redo => {
1428 session.redo_for_actor(&operation.participant_id)
1429 }
1430 };
1431 if response.ok && response.applied {
1432 publish_session_event(
1433 record,
1434 RuntimeSessionEventKind::Mutate,
1435 &session,
1436 Vec::new(),
1437 );
1438 }
1439 collaboration_result_from_patch_response(
1440 record, operation, response, sequence, rebase, None, None,
1441 )
1442}
1443
1444fn collaboration_result_from_patch_response(
1445 record: &RuntimeSessionRecord,
1446 operation: RuntimeCollaborationOperationEnvelope,
1447 response: RuntimePatchResponse,
1448 sequence: u64,
1449 rebase: Option<RuntimeCollaborationRebase>,
1450 revision_override: Option<String>,
1451 transformed_payload: Option<RuntimeCollaborationOperationPayload>,
1452) -> RuntimeCollaborationOperationResult {
1453 let revision = revision_override.unwrap_or_else(|| {
1454 response
1455 .snapshot
1456 .graph_revision()
1457 .map(ToOwned::to_owned)
1458 .unwrap_or_else(|| "0".to_owned())
1459 });
1460 let diagnostics: Vec<_> = response
1461 .diagnostics
1462 .iter()
1463 .map(|diagnostic| {
1464 collaboration_diagnostic_from_runtime_diagnostic(
1465 diagnostic,
1466 &operation.operation_id,
1467 &operation.participant_id,
1468 &operation.idempotency_key,
1469 )
1470 })
1471 .collect();
1472 let accepted = response.ok;
1473 let status = if accepted && rebase.is_some() {
1474 RuntimeCollaborationOperationStatus::Rebased
1475 } else if accepted {
1476 RuntimeCollaborationOperationStatus::Accepted
1477 } else {
1478 RuntimeCollaborationOperationStatus::Rejected
1479 };
1480 let nack = (!accepted).then(|| RuntimeCollaborationNack {
1481 reason: RuntimeCollaborationNackReason::InvalidOperation,
1482 retryable: Some(response.conflict),
1483 diagnostics: Some(diagnostics.clone()),
1484 });
1485 let ack = accepted.then(|| collaboration_ack(&operation, sequence, revision));
1486 let rebase = rebase.map(|mut rebase| {
1487 if rebase.transformed_payload.is_none() {
1488 rebase.transformed_payload = transformed_payload;
1489 }
1490 rebase
1491 });
1492
1493 publish_collaboration_operation_result(
1494 record,
1495 RuntimeCollaborationOperationResult {
1496 schema: "skenion.runtime.collaboration.operation-result".to_owned(),
1497 schema_version: "0.1.0".to_owned(),
1498 session_id: record.id.clone(),
1499 operation_id: operation.operation_id,
1500 participant_id: operation.participant_id,
1501 idempotency_key: operation.idempotency_key,
1502 status,
1503 causal: operation.causal,
1504 ack,
1505 nack,
1506 rebase,
1507 diagnostics,
1508 created_at: created_at_now(),
1509 },
1510 )
1511}
1512
1513fn publish_collaboration_operation_result(
1514 record: &RuntimeSessionRecord,
1515 result: RuntimeCollaborationOperationResult,
1516) -> RuntimeCollaborationOperationResult {
1517 validate_runtime_collaboration_operation_result(&result)
1518 .expect("runtime collaboration operation result should validate");
1519 record.collaboration.remember_result(result.clone());
1520 let sequence = match result.ack.as_ref() {
1521 Some(ack) => ack.sequence,
1522 None => record.collaboration.reserve_sequence(),
1523 };
1524 record
1525 .collaboration
1526 .publish_operation_result(&record.id, sequence, result.clone());
1527 result
1528}
1529
1530fn duplicate_collaboration_operation_result(
1531 record: &RuntimeSessionRecord,
1532 operation: &RuntimeCollaborationOperationEnvelope,
1533) -> RuntimeCollaborationOperationResult {
1534 RuntimeCollaborationOperationResult {
1535 schema: "skenion.runtime.collaboration.operation-result".to_owned(),
1536 schema_version: "0.1.0".to_owned(),
1537 session_id: record.id.clone(),
1538 operation_id: operation.operation_id.clone(),
1539 participant_id: operation.participant_id.clone(),
1540 idempotency_key: operation.idempotency_key.clone(),
1541 status: RuntimeCollaborationOperationStatus::Duplicate,
1542 causal: operation.causal.clone(),
1543 ack: None,
1544 nack: Some(RuntimeCollaborationNack {
1545 reason: RuntimeCollaborationNackReason::DuplicateIdempotencyKey,
1546 retryable: Some(false),
1547 diagnostics: Some(vec![collaboration_diagnostic(
1548 "warning",
1549 "collaboration.duplicate-idempotency-key",
1550 "collaboration operation idempotency key was already processed",
1551 &operation.operation_id,
1552 &operation.participant_id,
1553 &operation.idempotency_key,
1554 )]),
1555 }),
1556 rebase: None,
1557 diagnostics: Vec::new(),
1558 created_at: created_at_now(),
1559 }
1560}
1561
1562fn collaboration_rebase(
1563 record: &RuntimeSessionRecord,
1564 operation: &RuntimeCollaborationOperationEnvelope,
1565 current_revision: String,
1566 strategy: RuntimeCollaborationRebaseStrategy,
1567 transformed_payload: Option<RuntimeCollaborationOperationPayload>,
1568 conflicts: Vec<RuntimeCollaborationConflict>,
1569) -> RuntimeCollaborationRebase {
1570 let sequence = record.collaboration.current_sequence();
1571 RuntimeCollaborationRebase {
1572 from: operation.causal.clone(),
1573 to: RuntimeCollaborationCausalMetadata {
1574 base_revision: current_revision,
1575 base_sequence: sequence,
1576 vector: BTreeMap::from([("runtime".to_owned(), sequence)]),
1577 observed_operation_ids: Some(vec![operation.operation_id.clone()]),
1578 },
1579 strategy,
1580 transformed_payload,
1581 conflicts,
1582 }
1583}
1584
1585fn invalid_collaboration_operation_result(
1586 record: &RuntimeSessionRecord,
1587 operation_id: &str,
1588 participant_id: &str,
1589 idempotency_key: &str,
1590 causal: RuntimeCollaborationCausalMetadata,
1591 message: String,
1592) -> RuntimeCollaborationOperationResult {
1593 RuntimeCollaborationOperationResult {
1594 schema: "skenion.runtime.collaboration.operation-result".to_owned(),
1595 schema_version: "0.1.0".to_owned(),
1596 session_id: record.id.clone(),
1597 operation_id: operation_id.to_owned(),
1598 participant_id: participant_id.to_owned(),
1599 idempotency_key: idempotency_key.to_owned(),
1600 status: RuntimeCollaborationOperationStatus::Rejected,
1601 causal,
1602 ack: None,
1603 nack: Some(RuntimeCollaborationNack {
1604 reason: RuntimeCollaborationNackReason::InvalidOperation,
1605 retryable: Some(false),
1606 diagnostics: Some(vec![collaboration_diagnostic(
1607 "error",
1608 "collaboration.invalid-operation",
1609 &message,
1610 operation_id,
1611 participant_id,
1612 idempotency_key,
1613 )]),
1614 }),
1615 rebase: None,
1616 diagnostics: Vec::new(),
1617 created_at: created_at_now(),
1618 }
1619}
1620
1621fn invalid_collaboration_batch_result(
1622 session_id: &str,
1623 message: String,
1624) -> RuntimeCollaborationOperationBatchResult {
1625 let result = RuntimeCollaborationOperationResult {
1626 schema: "skenion.runtime.collaboration.operation-result".to_owned(),
1627 schema_version: "0.1.0".to_owned(),
1628 session_id: session_id.to_owned(),
1629 operation_id: "invalid-batch".to_owned(),
1630 participant_id: "runtime".to_owned(),
1631 idempotency_key: "invalid-batch".to_owned(),
1632 status: RuntimeCollaborationOperationStatus::Rejected,
1633 causal: RuntimeCollaborationCausalMetadata {
1634 base_revision: "0".to_owned(),
1635 base_sequence: 0,
1636 vector: BTreeMap::from([("runtime".to_owned(), 0)]),
1637 observed_operation_ids: None,
1638 },
1639 ack: None,
1640 nack: Some(RuntimeCollaborationNack {
1641 reason: RuntimeCollaborationNackReason::InvalidOperation,
1642 retryable: Some(false),
1643 diagnostics: Some(vec![RuntimeCollaborationOperationDiagnostic {
1644 severity: "error".to_owned(),
1645 code: "collaboration.invalid-batch".to_owned(),
1646 message: message.clone(),
1647 path: None,
1648 participant_id: Some("runtime".to_owned()),
1649 operation_id: Some("invalid-batch".to_owned()),
1650 idempotency_key: Some("invalid-batch".to_owned()),
1651 expected_revision: None,
1652 actual_revision: None,
1653 expected_sequence: None,
1654 actual_sequence: None,
1655 }]),
1656 }),
1657 rebase: None,
1658 diagnostics: Vec::new(),
1659 created_at: created_at_now(),
1660 };
1661 let batch_result = RuntimeCollaborationOperationBatchResult {
1662 schema: "skenion.runtime.collaboration.operation-batch-result".to_owned(),
1663 schema_version: "0.1.0".to_owned(),
1664 session_id: session_id.to_owned(),
1665 results: vec![result],
1666 diagnostics: vec![RuntimeCollaborationOperationDiagnostic {
1667 severity: "error".to_owned(),
1668 code: "collaboration.invalid-batch".to_owned(),
1669 message,
1670 path: None,
1671 participant_id: Some("runtime".to_owned()),
1672 operation_id: None,
1673 idempotency_key: None,
1674 expected_revision: None,
1675 actual_revision: None,
1676 expected_sequence: None,
1677 actual_sequence: None,
1678 }],
1679 created_at: created_at_now(),
1680 };
1681 validate_runtime_collaboration_operation_batch_result(&batch_result)
1682 .expect("invalid collaboration batch result should validate");
1683 batch_result
1684}
1685
1686fn invalid_paste_operation_response(
1687 record: &RuntimeSessionRecord,
1688 message: String,
1689) -> crate::PasteGraphFragmentResponse {
1690 let revision_before = current_session_graph_revision(record);
1691 crate::PasteGraphFragmentResponse {
1692 schema: "skenion.runtime.paste-graph-fragment.response".to_owned(),
1693 schema_version: "0.1.0".to_owned(),
1694 ok: false,
1695 applied: false,
1696 conflict: false,
1697 target: crate::GraphTargetRef {
1698 path: crate::PatchPath::Root,
1699 base_revision: revision_before.clone(),
1700 target_revision: None,
1701 },
1702 revision_before,
1703 revision_after: None,
1704 history_entry_id: None,
1705 id_remap: crate::IdRemapResult {
1706 node_id_map: BTreeMap::new(),
1707 edge_id_map: BTreeMap::new(),
1708 omitted_edge_ids: Vec::new(),
1709 },
1710 diagnostics: vec![crate::RuntimeOperationDiagnostic {
1711 severity: "error".to_owned(),
1712 code: "paste.operation.invalid-json".to_owned(),
1713 message,
1714 path: None,
1715 target: None,
1716 expected_revision: None,
1717 actual_revision: None,
1718 duplicates: None,
1719 nodes: None,
1720 edges: None,
1721 }],
1722 }
1723}
1724
1725fn collaboration_ack(
1726 operation: &RuntimeCollaborationOperationEnvelope,
1727 sequence: u64,
1728 revision: String,
1729) -> RuntimeCollaborationAck {
1730 let mut vector = operation.causal.vector.clone();
1731 vector.insert("runtime".to_owned(), sequence);
1732 vector.insert(operation.participant_id.clone(), sequence);
1733 RuntimeCollaborationAck {
1734 sequence,
1735 revision: revision.clone(),
1736 server_clock: RuntimeCollaborationServerClock {
1737 revision,
1738 sequence,
1739 vector,
1740 },
1741 applied_at: created_at_now(),
1742 }
1743}
1744
1745fn collaboration_diagnostic_from_operation_diagnostic(
1746 diagnostic: &crate::RuntimeOperationDiagnostic,
1747 operation_id: &str,
1748 participant_id: &str,
1749 idempotency_key: &str,
1750) -> RuntimeCollaborationOperationDiagnostic {
1751 RuntimeCollaborationOperationDiagnostic {
1752 severity: diagnostic.severity.clone(),
1753 code: diagnostic.code.clone(),
1754 message: diagnostic.message.clone(),
1755 path: diagnostic.path.clone(),
1756 participant_id: Some(participant_id.to_owned()),
1757 operation_id: Some(operation_id.to_owned()),
1758 idempotency_key: Some(idempotency_key.to_owned()),
1759 expected_revision: diagnostic.expected_revision.clone(),
1760 actual_revision: diagnostic.actual_revision.clone(),
1761 expected_sequence: None,
1762 actual_sequence: None,
1763 }
1764}
1765
1766fn collaboration_diagnostic_from_runtime_diagnostic(
1767 diagnostic: &RuntimeDiagnostic,
1768 operation_id: &str,
1769 participant_id: &str,
1770 idempotency_key: &str,
1771) -> RuntimeCollaborationOperationDiagnostic {
1772 RuntimeCollaborationOperationDiagnostic {
1773 severity: match &diagnostic.severity {
1774 DiagnosticSeverity::Error => "error",
1775 DiagnosticSeverity::Warning => "warning",
1776 DiagnosticSeverity::Info => "info",
1777 }
1778 .to_owned(),
1779 code: diagnostic
1780 .code
1781 .clone()
1782 .unwrap_or_else(|| "runtime.patch".to_owned()),
1783 message: diagnostic.message.clone(),
1784 path: None,
1785 participant_id: Some(participant_id.to_owned()),
1786 operation_id: Some(operation_id.to_owned()),
1787 idempotency_key: Some(idempotency_key.to_owned()),
1788 expected_revision: None,
1789 actual_revision: None,
1790 expected_sequence: None,
1791 actual_sequence: None,
1792 }
1793}
1794
1795fn collaboration_diagnostic(
1796 severity: &str,
1797 code: &str,
1798 message: &str,
1799 operation_id: &str,
1800 participant_id: &str,
1801 idempotency_key: &str,
1802) -> RuntimeCollaborationOperationDiagnostic {
1803 RuntimeCollaborationOperationDiagnostic {
1804 severity: severity.to_owned(),
1805 code: code.to_owned(),
1806 message: message.to_owned(),
1807 path: None,
1808 participant_id: Some(participant_id.to_owned()),
1809 operation_id: Some(operation_id.to_owned()),
1810 idempotency_key: Some(idempotency_key.to_owned()),
1811 expected_revision: None,
1812 actual_revision: None,
1813 expected_sequence: None,
1814 actual_sequence: None,
1815 }
1816}
1817
1818fn current_session_graph_revision(record: &RuntimeSessionRecord) -> String {
1819 record
1820 .session
1821 .read()
1822 .expect("runtime session lock should not be poisoned")
1823 .snapshot()
1824 .graph_revision()
1825 .map(ToOwned::to_owned)
1826 .unwrap_or_else(|| "0".to_owned())
1827}
1828
1829fn current_session_target_revision(
1830 record: &RuntimeSessionRecord,
1831 target: Option<&crate::GraphTargetRef>,
1832) -> String {
1833 let session = record
1834 .session
1835 .read()
1836 .expect("runtime session lock should not be poisoned");
1837 match target {
1838 Some(target) => session
1839 .target_revision_current(target)
1840 .or_else(|| target.target_revision.clone())
1841 .unwrap_or_else(|| target.base_revision.clone()),
1842 None => session
1843 .snapshot()
1844 .graph_revision()
1845 .map(ToOwned::to_owned)
1846 .unwrap_or_else(|| "0".to_owned()),
1847 }
1848}
1849
1850async fn session_history_by_id(
1851 State(state): State<RuntimeServerState>,
1852 Path(session_id): Path<String>,
1853) -> Json<crate::RuntimeHistory> {
1854 session_history_for(state.sessions.get_or_create(&session_id))
1855}
1856
1857fn session_history_for(record: RuntimeSessionRecord) -> Json<crate::RuntimeHistory> {
1858 let session = record
1859 .session
1860 .read()
1861 .expect("runtime session lock should not be poisoned");
1862 Json(session.history())
1863}
1864
1865async fn undo_session_by_id(
1866 State(state): State<RuntimeServerState>,
1867 Path(session_id): Path<String>,
1868) -> Json<crate::RuntimePatchResponse> {
1869 undo_session_for(&state, state.sessions.get_or_create(&session_id))
1870}
1871
1872fn undo_session_for(
1873 state: &RuntimeServerState,
1874 record: RuntimeSessionRecord,
1875) -> Json<crate::RuntimePatchResponse> {
1876 let _coordination_guard = record.collaboration.operation_guard();
1877 let mut session = record
1878 .session
1879 .write()
1880 .expect("runtime session lock should not be poisoned");
1881 let response = session.undo();
1882 if response.ok && response.applied {
1883 publish_session_event(
1884 &record,
1885 RuntimeSessionEventKind::Undo,
1886 &session,
1887 response.diagnostics.clone(),
1888 );
1889 }
1890 patch_json(state, response)
1891}
1892
1893async fn redo_session_by_id(
1894 State(state): State<RuntimeServerState>,
1895 Path(session_id): Path<String>,
1896) -> Json<crate::RuntimePatchResponse> {
1897 redo_session_for(&state, state.sessions.get_or_create(&session_id))
1898}
1899
1900fn redo_session_for(
1901 state: &RuntimeServerState,
1902 record: RuntimeSessionRecord,
1903) -> Json<crate::RuntimePatchResponse> {
1904 let _coordination_guard = record.collaboration.operation_guard();
1905 let mut session = record
1906 .session
1907 .write()
1908 .expect("runtime session lock should not be poisoned");
1909 let response = session.redo();
1910 if response.ok && response.applied {
1911 publish_session_event(
1912 &record,
1913 RuntimeSessionEventKind::Redo,
1914 &session,
1915 response.diagnostics.clone(),
1916 );
1917 }
1918 patch_json(state, response)
1919}
1920
1921async fn control_event_by_id(
1922 State(state): State<RuntimeServerState>,
1923 Path(session_id): Path<String>,
1924 Json(request): Json<RuntimeControlEventRequest>,
1925) -> Json<RuntimeControlEventResponse> {
1926 control_event_for(&state, state.sessions.get_or_create(&session_id), request)
1927}
1928
1929fn control_event_for(
1930 state: &RuntimeServerState,
1931 record: RuntimeSessionRecord,
1932 request: RuntimeControlEventRequest,
1933) -> Json<RuntimeControlEventResponse> {
1934 let (mut response, control_snapshot) = {
1935 let mut session = record
1936 .session
1937 .write()
1938 .expect("runtime session lock should not be poisoned");
1939 let response = session.apply_control_event(request);
1940 let control_snapshot = if response.ok && response.changed {
1941 session.preview_control_state_snapshot()
1942 } else {
1943 None
1944 };
1945 (response, control_snapshot)
1946 };
1947
1948 if let Some(control_snapshot) = control_snapshot {
1949 let mut preview = record
1950 .preview
1951 .lock()
1952 .expect("runtime preview lock should not be poisoned");
1953 if let Err(error) = preview.update_control_state(control_snapshot) {
1954 add_preview_control_update_warning(&mut response, error);
1955 }
1956 }
1957
1958 control_event_json(state, response)
1959}
1960
1961fn add_preview_control_update_warning(response: &mut RuntimeControlEventResponse, error: String) {
1962 response
1963 .diagnostics
1964 .push(RuntimeDiagnostic::warning(format!(
1965 "failed to update running preview control state: {error}"
1966 )));
1967}
1968
1969async fn control_state_by_id(
1970 State(state): State<RuntimeServerState>,
1971 Path(session_id): Path<String>,
1972) -> Json<RuntimeControlStateResponse> {
1973 control_state_for(state.sessions.get_or_create(&session_id))
1974}
1975
1976fn control_state_for(record: RuntimeSessionRecord) -> Json<RuntimeControlStateResponse> {
1977 let session = record
1978 .session
1979 .read()
1980 .expect("runtime session lock should not be poisoned");
1981 Json(session.control_state_response())
1982}
1983
1984async fn control_read_by_id(
1985 State(state): State<RuntimeServerState>,
1986 Path(session_id): Path<String>,
1987 Json(request): Json<RuntimeControlReadRequest>,
1988) -> Json<RuntimeControlReadResponse> {
1989 control_read_for(&state, state.sessions.get_or_create(&session_id), request)
1990}
1991
1992fn control_read_for(
1993 state: &RuntimeServerState,
1994 record: RuntimeSessionRecord,
1995 request: RuntimeControlReadRequest,
1996) -> Json<RuntimeControlReadResponse> {
1997 let session = record
1998 .session
1999 .read()
2000 .expect("runtime session lock should not be poisoned");
2001 let response = session.read_control(request);
2002 control_read_json(state, response)
2003}
2004
2005async fn clear_session_by_id(
2006 State(state): State<RuntimeServerState>,
2007 Path(session_id): Path<String>,
2008) -> Json<crate::RuntimeSessionResponse> {
2009 clear_session_for(&state, state.sessions.get_or_create(&session_id))
2010}
2011
2012fn clear_session_for(
2013 state: &RuntimeServerState,
2014 record: RuntimeSessionRecord,
2015) -> Json<crate::RuntimeSessionResponse> {
2016 let _coordination_guard = record.collaboration.operation_guard();
2017 let snapshot = {
2018 let session = record
2019 .session
2020 .read()
2021 .expect("runtime session lock should not be poisoned");
2022 session.snapshot()
2023 };
2024 let _ = record
2025 .preview
2026 .lock()
2027 .expect("runtime preview lock should not be poisoned")
2028 .stop(snapshot);
2029
2030 let mut session = record
2031 .session
2032 .write()
2033 .expect("runtime session lock should not be poisoned");
2034 let response = session.clear();
2035 if response.ok {
2036 publish_session_event(
2037 &record,
2038 RuntimeSessionEventKind::Clear,
2039 &session,
2040 response.diagnostics.clone(),
2041 );
2042 }
2043 session_json(state, response)
2044}
2045
2046async fn preview_status_by_id(
2047 State(state): State<RuntimeServerState>,
2048 Path(session_id): Path<String>,
2049) -> Json<crate::RuntimePreviewStatusResponse> {
2050 preview_status_for(&state, state.sessions.get_or_create(&session_id))
2051}
2052
2053fn preview_status_for(
2054 state: &RuntimeServerState,
2055 record: RuntimeSessionRecord,
2056) -> Json<crate::RuntimePreviewStatusResponse> {
2057 let snapshot = {
2058 let session = record
2059 .session
2060 .read()
2061 .expect("runtime session lock should not be poisoned");
2062 session.snapshot()
2063 };
2064 let mut preview = record
2065 .preview
2066 .lock()
2067 .expect("runtime preview lock should not be poisoned");
2068 let response = preview.status(snapshot);
2069 preview_status_json(state, response)
2070}
2071
2072async fn start_preview_by_id(
2073 State(state): State<RuntimeServerState>,
2074 Path(session_id): Path<String>,
2075 body: Bytes,
2076) -> Json<crate::RuntimePreviewStatusResponse> {
2077 start_preview_for(&state, state.sessions.get_or_create(&session_id), body)
2078}
2079
2080fn start_preview_for(
2081 state: &RuntimeServerState,
2082 record: RuntimeSessionRecord,
2083 body: Bytes,
2084) -> Json<crate::RuntimePreviewStatusResponse> {
2085 let snapshot = {
2086 let session = record
2087 .session
2088 .read()
2089 .expect("runtime session lock should not be poisoned");
2090 session.snapshot()
2091 };
2092 let request = match preview_start_request(&body) {
2093 Ok(request) => request,
2094 Err(diagnostic) => {
2095 let preview = record
2096 .preview
2097 .lock()
2098 .expect("runtime preview lock should not be poisoned");
2099 let response = preview.request_error(snapshot, diagnostic);
2100 return preview_status_json(state, response);
2101 }
2102 };
2103 let context = {
2104 let session = record
2105 .session
2106 .read()
2107 .expect("runtime session lock should not be poisoned");
2108 session.preview_context()
2109 };
2110 let mut preview = record
2111 .preview
2112 .lock()
2113 .expect("runtime preview lock should not be poisoned");
2114 let response = preview.start(context, snapshot, request.restart);
2115 preview_status_json(state, response)
2116}
2117
2118async fn restart_preview_by_id(
2119 State(state): State<RuntimeServerState>,
2120 Path(session_id): Path<String>,
2121) -> Json<crate::RuntimePreviewStatusResponse> {
2122 restart_preview_for(&state, state.sessions.get_or_create(&session_id))
2123}
2124
2125fn restart_preview_for(
2126 state: &RuntimeServerState,
2127 record: RuntimeSessionRecord,
2128) -> Json<crate::RuntimePreviewStatusResponse> {
2129 let (snapshot, context) = {
2130 let session = record
2131 .session
2132 .read()
2133 .expect("runtime session lock should not be poisoned");
2134 (session.snapshot(), session.preview_context())
2135 };
2136 let mut preview = record
2137 .preview
2138 .lock()
2139 .expect("runtime preview lock should not be poisoned");
2140 let response = preview.restart(context, snapshot);
2141 preview_status_json(state, response)
2142}
2143
2144async fn stop_preview_by_id(
2145 State(state): State<RuntimeServerState>,
2146 Path(session_id): Path<String>,
2147) -> Json<crate::RuntimePreviewStatusResponse> {
2148 stop_preview_for(&state, state.sessions.get_or_create(&session_id))
2149}
2150
2151fn stop_preview_for(
2152 state: &RuntimeServerState,
2153 record: RuntimeSessionRecord,
2154) -> Json<crate::RuntimePreviewStatusResponse> {
2155 let snapshot = {
2156 let session = record
2157 .session
2158 .read()
2159 .expect("runtime session lock should not be poisoned");
2160 session.snapshot()
2161 };
2162 let mut preview = record
2163 .preview
2164 .lock()
2165 .expect("runtime preview lock should not be poisoned");
2166 let response = preview.stop(snapshot);
2167 preview_status_json(state, response)
2168}
2169
2170async fn generated_shader_by_id(
2171 State(state): State<RuntimeServerState>,
2172 Path(session_id): Path<String>,
2173) -> Json<GeneratedShaderResponse> {
2174 generated_shader_for(&state, state.sessions.get_or_create(&session_id))
2175}
2176
2177fn generated_shader_for(
2178 state: &RuntimeServerState,
2179 record: RuntimeSessionRecord,
2180) -> Json<GeneratedShaderResponse> {
2181 let context = {
2182 let session = record
2183 .session
2184 .read()
2185 .expect("runtime session lock should not be poisoned");
2186 session.preview_context()
2187 };
2188
2189 let response = match context {
2190 Ok(context) => {
2191 let document = PreviewDocument::with_control_state(
2192 context.graph,
2193 context.plan,
2194 context.control_state,
2195 context.session_revision,
2196 );
2197 generated_shader_response_from_preview_document(&document)
2198 }
2199 Err(diagnostics) => GeneratedShaderResponse {
2200 ok: false,
2201 node_id: None,
2202 language: None,
2203 source: None,
2204 source_map: None,
2205 diagnostics: diagnostics
2206 .into_iter()
2207 .map(|diagnostic| {
2208 ShaderDiagnostic::error(
2209 ShaderDiagnosticPhase::SourceSync,
2210 "generated-shader-unavailable",
2211 diagnostic.message,
2212 ShaderDiagnosticSource::Runtime,
2213 )
2214 })
2215 .collect(),
2216 },
2217 };
2218
2219 generated_shader_json(state, response)
2220}
2221
2222async fn import_asset(
2223 State(state): State<RuntimeServerState>,
2224 mut multipart: Multipart,
2225) -> Json<RuntimeAssetImportResponse> {
2226 while let Ok(Some(field)) = multipart.next_field().await {
2227 if field.name() != Some("file") {
2228 continue;
2229 }
2230 let name = field
2231 .file_name()
2232 .map(str::to_owned)
2233 .unwrap_or_else(|| "asset.bin".to_owned());
2234 let mime_type = field
2235 .content_type()
2236 .map(str::to_owned)
2237 .unwrap_or_else(|| "application/octet-stream".to_owned());
2238 let bytes = match field.bytes().await {
2239 Ok(bytes) => bytes,
2240 Err(error) => {
2241 let response = RuntimeAssetImportResponse {
2242 ok: false,
2243 asset: None,
2244 diagnostics: vec![RuntimeDiagnostic::error(format!(
2245 "failed to read uploaded asset bytes: {error}"
2246 ))],
2247 };
2248 return asset_import_json(&state, response);
2249 }
2250 };
2251
2252 let response = store_asset(&state, name, mime_type, bytes);
2253 return asset_import_json(&state, response);
2254 }
2255
2256 let response = RuntimeAssetImportResponse {
2257 ok: false,
2258 asset: None,
2259 diagnostics: vec![RuntimeDiagnostic::error(
2260 "asset import request did not include a file field",
2261 )],
2262 };
2263 asset_import_json(&state, response)
2264}
2265
2266async fn list_assets(State(state): State<RuntimeServerState>) -> Json<RuntimeAssetListResponse> {
2267 let assets = state
2268 .assets
2269 .read()
2270 .expect("runtime asset store lock should not be poisoned")
2271 .assets
2272 .values()
2273 .cloned()
2274 .collect();
2275 Json(RuntimeAssetListResponse {
2276 ok: true,
2277 assets,
2278 diagnostics: Vec::new(),
2279 })
2280}
2281
2282async fn get_asset(
2283 State(state): State<RuntimeServerState>,
2284 Path(asset_id): Path<String>,
2285) -> Json<RuntimeAssetGetResponse> {
2286 let asset = state
2287 .assets
2288 .read()
2289 .expect("runtime asset store lock should not be poisoned")
2290 .assets
2291 .get(&asset_id)
2292 .cloned();
2293 let ok = asset.is_some();
2294 let response = RuntimeAssetGetResponse {
2295 ok,
2296 asset,
2297 diagnostics: if ok {
2298 Vec::new()
2299 } else {
2300 vec![RuntimeDiagnostic::error(format!(
2301 "asset {asset_id} does not exist"
2302 ))]
2303 },
2304 };
2305 asset_get_json(&state, response)
2306}
2307
2308async fn session_telemetry_by_id(
2309 State(state): State<RuntimeServerState>,
2310 Path(session_id): Path<String>,
2311) -> Json<RuntimeTelemetrySnapshot> {
2312 Json(telemetry_snapshot(
2313 &state,
2314 state.sessions.get_or_create(&session_id),
2315 ))
2316}
2317
2318async fn session_telemetry_stream_by_id(
2319 State(state): State<RuntimeServerState>,
2320 Path(session_id): Path<String>,
2321) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
2322 session_telemetry_stream_for(state, session_id)
2323}
2324
2325fn session_telemetry_stream_for(
2326 state: RuntimeServerState,
2327 session_id: String,
2328) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
2329 let stream =
2330 IntervalStream::new(tokio::time::interval(Duration::from_millis(1000))).map(move |_| {
2331 let record = state.sessions.get_or_create(&session_id);
2332 let event = Event::default()
2333 .event("telemetry")
2334 .json_data(telemetry_snapshot(&state, record))
2335 .expect("telemetry snapshot should serialize");
2336 Ok(event)
2337 });
2338 Sse::new(stream).keep_alive(KeepAlive::default())
2339}
2340
2341fn telemetry_snapshot(
2342 state: &RuntimeServerState,
2343 record: RuntimeSessionRecord,
2344) -> RuntimeTelemetrySnapshot {
2345 let snapshot = {
2346 let session = record
2347 .session
2348 .read()
2349 .expect("runtime session lock should not be poisoned");
2350 session.snapshot()
2351 };
2352 let mut preview = record
2353 .preview
2354 .lock()
2355 .expect("runtime preview lock should not be poisoned");
2356 preview.telemetry(
2357 snapshot,
2358 state
2359 .started_at
2360 .elapsed()
2361 .as_millis()
2362 .try_into()
2363 .unwrap_or(u64::MAX),
2364 )
2365}
2366
2367fn store_asset(
2368 state: &RuntimeServerState,
2369 name: String,
2370 mime_type: String,
2371 bytes: Bytes,
2372) -> RuntimeAssetImportResponse {
2373 let id = asset_id(&name, &mime_type, &bytes);
2374 store_asset_with_id(state, id, name, mime_type, bytes, runtime_asset_directory())
2375}
2376
2377fn store_asset_with_id(
2378 state: &RuntimeServerState,
2379 id: String,
2380 name: String,
2381 mime_type: String,
2382 bytes: Bytes,
2383 directory: PathBuf,
2384) -> RuntimeAssetImportResponse {
2385 let kind = asset_kind(&mime_type);
2386 let runtime_uri = format!("skenion-runtime://assets/{id}");
2387 if let Err(error) = fs::create_dir_all(&directory) {
2388 return RuntimeAssetImportResponse {
2389 ok: false,
2390 asset: None,
2391 diagnostics: vec![RuntimeDiagnostic::error(format!(
2392 "failed to create runtime asset directory: {error}"
2393 ))],
2394 };
2395 }
2396 let path = directory.join(&id);
2397 if let Err(error) = fs::write(&path, &bytes) {
2398 return RuntimeAssetImportResponse {
2399 ok: false,
2400 asset: None,
2401 diagnostics: vec![RuntimeDiagnostic::error(format!(
2402 "failed to store runtime asset: {error}"
2403 ))],
2404 };
2405 }
2406 let asset = RuntimeAsset {
2407 id: id.clone(),
2408 name,
2409 mime_type,
2410 kind,
2411 size_bytes: bytes.len().try_into().unwrap_or(u64::MAX),
2412 runtime_uri,
2413 };
2414 state
2415 .assets
2416 .write()
2417 .expect("runtime asset store lock should not be poisoned")
2418 .assets
2419 .insert(id, asset.clone());
2420 RuntimeAssetImportResponse {
2421 ok: true,
2422 asset: Some(asset),
2423 diagnostics: Vec::new(),
2424 }
2425}
2426
2427fn runtime_asset_directory() -> PathBuf {
2428 std::env::temp_dir().join("skenion-runtime-assets")
2429}
2430
2431fn asset_id(name: &str, mime_type: &str, bytes: &Bytes) -> String {
2432 let mut hasher = std::collections::hash_map::DefaultHasher::new();
2433 name.hash(&mut hasher);
2434 mime_type.hash(&mut hasher);
2435 bytes.hash(&mut hasher);
2436 SystemTime::now()
2437 .duration_since(UNIX_EPOCH)
2438 .unwrap_or_default()
2439 .as_nanos()
2440 .hash(&mut hasher);
2441 format!("asset_{:016x}", hasher.finish())
2442}
2443
2444fn asset_kind(mime_type: &str) -> String {
2445 if mime_type.starts_with("video/") {
2446 "video".to_owned()
2447 } else if mime_type.starts_with("image/") {
2448 "image".to_owned()
2449 } else if mime_type.starts_with("audio/") {
2450 "audio".to_owned()
2451 } else {
2452 "binary".to_owned()
2453 }
2454}
2455
2456impl RuntimeApiResponse {
2457 fn diagnostics(diagnostics: Vec<RuntimeDiagnostic>) -> Self {
2458 Self {
2459 ok: false,
2460 diagnostics,
2461 plan: None,
2462 report: None,
2463 }
2464 }
2465}
2466
2467impl RuntimeDiagnostic {
2468 pub(crate) fn error(message: impl Into<String>) -> Self {
2469 Self {
2470 severity: DiagnosticSeverity::Error,
2471 message: message.into(),
2472 code: None,
2473 details: None,
2474 }
2475 }
2476
2477 pub(crate) fn warning(message: impl Into<String>) -> Self {
2478 Self {
2479 severity: DiagnosticSeverity::Warning,
2480 message: message.into(),
2481 code: None,
2482 details: None,
2483 }
2484 }
2485
2486 pub(crate) fn structured_error(
2487 code: impl Into<String>,
2488 message: impl Into<String>,
2489 details: serde_json::Value,
2490 ) -> Self {
2491 Self {
2492 severity: DiagnosticSeverity::Error,
2493 message: message.into(),
2494 code: Some(code.into()),
2495 details: Some(details),
2496 }
2497 }
2498
2499 pub(crate) fn structured_warning(
2500 code: impl Into<String>,
2501 message: impl Into<String>,
2502 details: serde_json::Value,
2503 ) -> Self {
2504 Self {
2505 severity: DiagnosticSeverity::Warning,
2506 message: message.into(),
2507 code: Some(code.into()),
2508 details: Some(details),
2509 }
2510 }
2511}
2512
2513enum ProjectPayload {
2514 Current(Box<ProjectRequestCurrent>),
2515}
2516
2517enum RunProjectPayload {
2518 Current(Box<RunProjectRequestCurrent>),
2519}
2520
2521fn decode_project_payload(
2522 value: serde_json::Value,
2523) -> Result<ProjectPayload, Vec<RuntimeDiagnostic>> {
2524 match project_schema_version(&value).as_deref() {
2525 Some(CURRENT_SCHEMA_VERSION) => decode_project_payload_current(value)
2526 .map(Box::new)
2527 .map(ProjectPayload::Current),
2528 received => Err(vec![
2529 schema_version_diagnostic(project_schema_surface(&value), received)
2530 .expect("current schema version should have decoded as current 0.1"),
2531 ]),
2532 }
2533}
2534
2535fn decode_run_project_payload(
2536 value: serde_json::Value,
2537) -> Result<RunProjectPayload, Vec<RuntimeDiagnostic>> {
2538 match project_schema_version(&value).as_deref() {
2539 Some(CURRENT_SCHEMA_VERSION) => decode_run_project_payload_current(value)
2540 .map(Box::new)
2541 .map(RunProjectPayload::Current),
2542 received => Err(vec![
2543 schema_version_diagnostic(project_schema_surface(&value), received)
2544 .expect("current schema version should have decoded as current 0.1"),
2545 ]),
2546 }
2547}
2548
2549fn decode_project_payload_current(
2550 value: serde_json::Value,
2551) -> Result<ProjectRequestCurrent, Vec<RuntimeDiagnostic>> {
2552 if is_project_document_current(&value) {
2553 return decode_project_document_request_current(value);
2554 }
2555
2556 serde_json::from_value(value).map_err(invalid_project_payload)
2557}
2558
2559fn decode_run_project_payload_current(
2560 value: serde_json::Value,
2561) -> Result<RunProjectRequestCurrent, Vec<RuntimeDiagnostic>> {
2562 if is_project_document_current(&value) {
2563 return decode_run_project_document_request_current(value);
2564 }
2565
2566 serde_json::from_value(value).map_err(invalid_project_payload)
2567}
2568
2569fn decode_project_document_request_current(
2570 mut value: serde_json::Value,
2571) -> Result<ProjectRequestCurrent, Vec<RuntimeDiagnostic>> {
2572 let nodes = take_node_definitions_current(&mut value)?;
2573 let _ = take_frames_current(&mut value)?;
2574 let document = decode_project_document_current(value)?;
2575 Ok(ProjectRequestCurrent::from_project_document(
2576 document, nodes,
2577 ))
2578}
2579
2580fn decode_run_project_document_request_current(
2581 mut value: serde_json::Value,
2582) -> Result<RunProjectRequestCurrent, Vec<RuntimeDiagnostic>> {
2583 let nodes = take_node_definitions_current(&mut value)?;
2584 let frames = take_frames_current(&mut value)?;
2585 let document = decode_project_document_current(value)?;
2586 Ok(RunProjectRequestCurrent::from_project_document(
2587 document, nodes, frames,
2588 ))
2589}
2590
2591fn decode_project_document_current(
2592 value: serde_json::Value,
2593) -> Result<ProjectDocumentCurrent, Vec<RuntimeDiagnostic>> {
2594 let schema_diagnostics = project_document_payload_schema_diagnostics(&value);
2595 if !schema_diagnostics.is_empty() {
2596 return Err(schema_diagnostics);
2597 }
2598 let document =
2599 serde_json::from_value::<ProjectDocumentCurrent>(value).map_err(invalid_project_payload)?;
2600 if let Err(report) = skenion_contracts::validate_project_document_v01(&document) {
2601 return Err(project_document_validation_diagnostics_current(
2602 &document, &report,
2603 ));
2604 }
2605 Ok(document)
2606}
2607
2608fn take_node_definitions_current(
2609 value: &mut serde_json::Value,
2610) -> Result<Vec<NodeDefinitionCurrent>, Vec<RuntimeDiagnostic>> {
2611 let nodes = value
2612 .as_object_mut()
2613 .and_then(|object| object.remove("nodes"))
2614 .unwrap_or_else(|| serde_json::Value::Array(Vec::new()));
2615 serde_json::from_value(nodes).map_err(invalid_project_payload)
2616}
2617
2618fn take_frames_current(
2619 value: &mut serde_json::Value,
2620) -> Result<Option<usize>, Vec<RuntimeDiagnostic>> {
2621 let frames = value
2622 .as_object_mut()
2623 .and_then(|object| object.remove("frames"))
2624 .unwrap_or(serde_json::Value::Null);
2625 serde_json::from_value(frames).map_err(invalid_project_payload)
2626}
2627
2628fn project_schema_version(value: &serde_json::Value) -> Option<String> {
2629 if is_project_document(value) {
2630 return value
2631 .get("schemaVersion")
2632 .and_then(|version| version.as_str())
2633 .map(str::to_owned);
2634 }
2635
2636 value
2637 .get("graph")
2638 .and_then(|graph| graph.get("schemaVersion"))
2639 .and_then(|version| version.as_str())
2640 .map(str::to_owned)
2641}
2642
2643fn is_project_document_current(value: &serde_json::Value) -> bool {
2644 is_project_document(value)
2645 && value
2646 .get("schemaVersion")
2647 .and_then(|version| version.as_str())
2648 == Some(CURRENT_SCHEMA_VERSION)
2649}
2650
2651fn is_project_document(value: &serde_json::Value) -> bool {
2652 value.get("schema").and_then(|schema| schema.as_str()) == Some("skenion.project")
2653}
2654
2655fn project_schema_surface(value: &serde_json::Value) -> &'static str {
2656 if is_project_document(value) {
2657 "project"
2658 } else {
2659 "graph"
2660 }
2661}
2662
2663fn invalid_project_payload(error: serde_json::Error) -> Vec<RuntimeDiagnostic> {
2664 vec![RuntimeDiagnostic::error(format!(
2665 "invalid project request: {error}"
2666 ))]
2667}
2668
2669pub(crate) fn registry_from_nodes(
2670 nodes: Vec<NodeDefinition>,
2671) -> Result<NodeRegistry, Vec<RuntimeDiagnostic>> {
2672 let mut registry = NodeRegistry::new();
2673 let mut diagnostics = Vec::new();
2674
2675 for definition in nodes {
2676 if let Err(error) = registry.insert(definition) {
2677 diagnostics.push(RuntimeDiagnostic::error(error.to_string()));
2678 }
2679 }
2680
2681 if diagnostics.is_empty() {
2682 Ok(registry)
2683 } else {
2684 Err(diagnostics)
2685 }
2686}
2687
2688fn preview_start_request(body: &[u8]) -> Result<RuntimePreviewStartRequest, RuntimeDiagnostic> {
2689 if body.is_empty() {
2690 return Ok(RuntimePreviewStartRequest { restart: false });
2691 }
2692 serde_json::from_slice(body).map_err(|error| {
2693 RuntimeDiagnostic::error(format!("invalid preview start request: {error}"))
2694 })
2695}
2696
2697fn cors_layer() -> CorsLayer {
2698 CorsLayer::new()
2699 .allow_origin(AllowOrigin::predicate(|origin: &HeaderValue, _| {
2700 matches!(
2701 origin.to_str(),
2702 Ok("http://127.0.0.1:5173"
2703 | "http://localhost:5173"
2704 | "http://127.0.0.1:5174"
2705 | "http://localhost:5174"
2706 | "http://127.0.0.1:5175"
2707 | "http://localhost:5175")
2708 )
2709 }))
2710 .allow_methods([Method::DELETE, Method::GET, Method::POST])
2711 .allow_headers([CONTENT_TYPE])
2712}
2713
2714#[cfg(test)]
2715mod tests {
2716 use std::sync::Arc;
2717
2718 use axum::{
2719 body::{Body, to_bytes},
2720 http::{
2721 Method, Request, StatusCode,
2722 header::{
2723 ACCESS_CONTROL_ALLOW_ORIGIN, ACCESS_CONTROL_REQUEST_METHOD, CONTENT_TYPE, ORIGIN,
2724 },
2725 },
2726 };
2727 use serde_json::{Value, json};
2728 use skenion_contracts::{
2729 RuntimeCollaborationEventEnvelope, RuntimeCollaborationEventKind,
2730 RuntimeCollaborationOperationBatchResult, RuntimeCollaborationOperationResult,
2731 validate_runtime_collaboration_event_envelope,
2732 validate_runtime_collaboration_operation_batch_result,
2733 validate_runtime_collaboration_operation_result, validate_runtime_session_event,
2734 };
2735 use tower::ServiceExt;
2736
2737 use crate::{
2738 CanvasNodeView, RuntimeIoDeviceDescriptor, RuntimeIoDeviceListResponse, RuntimeLogEvent,
2739 RuntimeLogSource, RuntimeSession, RuntimeSessionEvent, RuntimeViewPatch,
2740 RuntimeViewPatchOperation, io_device_manager::RuntimeIoDeviceRegistry,
2741 session_registry::DEFAULT_SESSION_ID,
2742 };
2743
2744 use super::*;
2745
2746 struct ServerFakeIoDeviceRegistry {
2747 devices: Vec<RuntimeIoDeviceDescriptor>,
2748 }
2749
2750 impl RuntimeIoDeviceRegistry for ServerFakeIoDeviceRegistry {
2751 fn list_devices(&self) -> RuntimeIoDeviceListResponse {
2752 RuntimeIoDeviceListResponse {
2753 ok: true,
2754 devices: self.devices.clone(),
2755 diagnostics: Vec::new(),
2756 }
2757 }
2758 }
2759
2760 #[tokio::test]
2761 async fn health_response() {
2762 let response = get_json("/health").await;
2763
2764 assert_eq!(response["ok"], true);
2765 assert_eq!(response["service"], "skenion-runtime");
2766 assert_eq!(response["version"], env!("CARGO_PKG_VERSION"));
2767 }
2768
2769 #[tokio::test]
2770 async fn runtime_info_response() {
2771 let response = get_json("/v0/runtime/info").await;
2772
2773 assert_eq!(response["name"], "skenion-runtime");
2774 assert_eq!(response["apiVersion"], RUNTIME_API_VERSION);
2775 let capabilities = response["capabilities"].as_array().unwrap();
2776 for expected in [
2777 "project.validate",
2778 "project.validate.v0.1",
2779 "project.plan",
2780 "project.plan.v0.1",
2781 "dummy.run",
2782 "session.load",
2783 "session.load.v0.1",
2784 "session.mutate",
2785 "session.operation",
2786 "session.history",
2787 "session.undo",
2788 "session.redo",
2789 "session.control.event",
2790 "session.control.state",
2791 "session.control.channels",
2792 "session.control.messages",
2793 "assets.import",
2794 "assets.list",
2795 "assets.get",
2796 "session.preview.start",
2797 "session.render.generatedShader",
2798 "session.telemetry",
2799 "session.telemetry.stream",
2800 "runtime.logs",
2801 "runtime.logs.stream",
2802 "runtime.extensions",
2803 "session.addressing",
2804 "session.info",
2805 "session.events.replay",
2806 "runtime.profile.localManaged",
2807 "runtime.sidecar.startup",
2808 "runtime.sidecar.health",
2809 "runtime.sidecar.shutdown",
2810 "io.devices",
2811 ] {
2812 assert!(
2813 capabilities
2814 .iter()
2815 .any(|capability| capability.as_str() == Some(expected)),
2816 "missing capability {expected}"
2817 );
2818 }
2819 for removed in ["session.import.legacy.v0.1", "session.defaultAlias"] {
2820 assert!(
2821 !capabilities
2822 .iter()
2823 .any(|capability| capability.as_str() == Some(removed)),
2824 "removed compatibility capability {removed} should not be advertised"
2825 );
2826 }
2827 }
2828
2829 #[tokio::test]
2830 async fn sidecar_startup_health_and_shutdown_are_machine_readable() {
2831 let app = runtime_router();
2832
2833 let startup = get_json_with(app.clone(), "/v0/sidecar/startup").await;
2834 let health = get_json_with(app.clone(), "/v0/sidecar/health").await;
2835 let empty_shutdown = post_empty_with(app.clone(), "/v0/sidecar/shutdown").await;
2836 let shutdown = post_json_with(
2837 app.clone(),
2838 "/v0/sidecar/shutdown",
2839 json!({ "reason": "window-close", "ownerWindowId": "window-1" }),
2840 )
2841 .await;
2842 let invalid_shutdown = post_raw_with(app, "/v0/sidecar/shutdown", b"{".to_vec()).await;
2843 let startup_from_state = runtime_state_with_dry_preview().sidecar_startup_response();
2844
2845 assert_eq!(startup["schema"], "skenion.runtime.sidecar.startup");
2846 assert_eq!(startup["ok"], true);
2847 assert_eq!(startup["runtime"]["version"], env!("CARGO_PKG_VERSION"));
2848 assert_eq!(startup["runtime"]["apiVersion"], RUNTIME_API_VERSION);
2849 assert_eq!(startup["endpoint"]["protocol"], "http");
2850 assert_eq!(startup["profile"]["mode"], "local-managed");
2851 assert_eq!(startup["profile"]["ownership"], "owned-child");
2852 assert_eq!(startup["defaultSessionId"], DEFAULT_SESSION_ID);
2853 assert_eq!(startup["token"]["required"], false);
2854 assert_eq!(startup["token"]["header"], "Authorization");
2855 assert_eq!(startup["shutdown"]["scope"], "owned-child-only");
2856 assert!(startup["defaultSessionUrl"].is_string());
2857 assert_eq!(health["schema"], "skenion.runtime.sidecar.health");
2858 assert_eq!(health["ok"], true);
2859 assert_eq!(health["readiness"], "ready");
2860 assert_eq!(health["runtime"]["version"], env!("CARGO_PKG_VERSION"));
2861 assert_eq!(health["runtime"]["apiVersion"], RUNTIME_API_VERSION);
2862 assert_eq!(health["endpoint"]["protocol"], "http");
2863 assert_eq!(health["profile"]["mode"], "local-managed");
2864 assert!(health.get("token").is_none());
2865 assert!(health.get("shutdown").is_none());
2866 assert!(health.get("defaultSessionUrl").is_none());
2867 assert_eq!(empty_shutdown["ok"], true);
2868 assert_eq!(shutdown["schema"], "skenion.runtime.sidecar.shutdown");
2869 assert_eq!(shutdown["ok"], true);
2870 assert_eq!(shutdown["accepted"], false);
2871 assert_eq!(shutdown["action"], "host-owned-process-stop-required");
2872 assert_eq!(shutdown["scope"], "owned-child-only");
2873 assert_eq!(invalid_shutdown["ok"], false);
2874 assert!(startup_from_state.ok);
2875 assert!(
2876 runtime_state_with_dry_preview()
2877 .sidecar_health_response()
2878 .ok
2879 );
2880 }
2881
2882 #[tokio::test]
2883 async fn session_addressed_route_family_covers_canonical_surface() {
2884 let app = runtime_router_with_dry_preview();
2885 let registry = RuntimeSessionRegistry::dry_preview();
2886 assert_eq!(registry.default_record().id, DEFAULT_SESSION_ID);
2887
2888 post_json_with(
2889 app.clone(),
2890 "/v0/sessions/gamma/load",
2891 sample_project_document_current(),
2892 )
2893 .await;
2894 let default_info = get_json_with(app.clone(), "/v0/sessions/default/info").await;
2895 let gamma_info = get_json_with(app.clone(), "/v0/sessions/gamma/info").await;
2896 assert_eq!(default_info["sessionId"], DEFAULT_SESSION_ID);
2897 assert_eq!(gamma_info["sessionId"], "gamma");
2898
2899 let response = app
2900 .clone()
2901 .oneshot(
2902 Request::builder()
2903 .uri("/v0/sessions/gamma/events/stream")
2904 .body(Body::empty())
2905 .expect("request should build"),
2906 )
2907 .await
2908 .expect("router should respond");
2909 assert_eq!(response.status(), StatusCode::OK);
2910 let mut stream = response.into_body().into_data_stream();
2911 let chunk = tokio::time::timeout(Duration::from_secs(1), stream.next())
2912 .await
2913 .expect("session event stream should emit")
2914 .expect("session event stream should have a chunk")
2915 .expect("session event stream chunk should be ok");
2916 let text = std::str::from_utf8(&chunk).expect("session event stream should be utf8");
2917 assert!(text.contains("\"sessionId\":\"gamma\""));
2918
2919 assert_eq!(
2920 post_empty_with(app.clone(), "/v0/sessions/gamma/validate").await["ok"],
2921 true
2922 );
2923 assert_eq!(
2924 post_empty_with(app.clone(), "/v0/sessions/gamma/plan").await["ok"],
2925 true
2926 );
2927 assert_eq!(
2928 post_json_with(
2929 app.clone(),
2930 "/v0/sessions/gamma/run",
2931 json!({ "frames": 1 })
2932 )
2933 .await["ok"],
2934 true
2935 );
2936
2937 let read = post_json_with(
2938 app.clone(),
2939 "/v0/sessions/gamma/control/read",
2940 json!({ "nodeId": "value_1", "target": "port", "id": "value" }),
2941 )
2942 .await;
2943 assert_eq!(read["ok"], true);
2944
2945 assert_eq!(
2946 get_json_with(app.clone(), "/v0/sessions/gamma/preview").await["ok"],
2947 true
2948 );
2949 assert_eq!(
2950 post_empty_with(app.clone(), "/v0/sessions/gamma/preview/start").await["ok"],
2951 true
2952 );
2953 assert_eq!(
2954 post_empty_with(app.clone(), "/v0/sessions/gamma/preview/restart").await["ok"],
2955 true
2956 );
2957 assert_eq!(
2958 post_empty_with(app.clone(), "/v0/sessions/gamma/preview/stop").await["ok"],
2959 true
2960 );
2961
2962 assert_eq!(
2963 get_json_with(app.clone(), "/v0/sessions/gamma/telemetry").await["ok"],
2964 true
2965 );
2966 let response = app
2967 .clone()
2968 .oneshot(
2969 Request::builder()
2970 .uri("/v0/sessions/gamma/telemetry/stream")
2971 .body(Body::empty())
2972 .expect("request should build"),
2973 )
2974 .await
2975 .expect("router should respond");
2976 let mut stream = response.into_body().into_data_stream();
2977 let chunk = tokio::time::timeout(Duration::from_secs(2), stream.next())
2978 .await
2979 .expect("telemetry stream should emit")
2980 .expect("telemetry stream should have a chunk")
2981 .expect("telemetry stream chunk should be ok");
2982 let text = std::str::from_utf8(&chunk).expect("telemetry stream should be utf8");
2983 assert!(text.contains("event: telemetry"));
2984
2985 post_json_with(
2986 app.clone(),
2987 "/v0/sessions/shader/load",
2988 sample_shader_project_current(),
2989 )
2990 .await;
2991 assert_eq!(
2992 get_json_with(app.clone(), "/v0/sessions/shader/render/generated-shader").await["ok"],
2993 true
2994 );
2995
2996 post_json_with(
2997 app.clone(),
2998 "/v0/sessions/delta/load",
2999 sample_project_document_current(),
3000 )
3001 .await;
3002 assert_eq!(
3003 post_json_with(
3004 app.clone(),
3005 "/v0/sessions/delta/operation",
3006 paste_operation("1")
3007 )
3008 .await["ok"],
3009 true
3010 );
3011
3012 assert_eq!(
3013 post_json_with(
3014 app.clone(),
3015 "/v0/sessions/gamma/operation",
3016 paste_operation("1")
3017 )
3018 .await["ok"],
3019 true
3020 );
3021 assert_eq!(
3022 post_empty_with(app.clone(), "/v0/sessions/gamma/undo").await["ok"],
3023 true
3024 );
3025 assert_eq!(
3026 post_empty_with(app.clone(), "/v0/sessions/gamma/redo").await["ok"],
3027 true
3028 );
3029 assert_eq!(
3030 delete_json_with(app, "/v0/sessions/gamma").await["ok"],
3031 true
3032 );
3033 }
3034
3035 #[tokio::test]
3036 async fn runtime_extensions_response_defaults_to_empty_package_list() {
3037 let response = get_json("/v0/extensions").await;
3038
3039 assert_eq!(response["ok"], true);
3040 assert_eq!(response["extensions"], json!([]));
3041 assert_eq!(response["diagnostics"], json!([]));
3042 }
3043
3044 #[tokio::test]
3045 async fn runtime_log_snapshot_replays_warning_error_backlog() {
3046 let app = runtime_router_with_fake_io_devices(Vec::new());
3047
3048 let empty = get_json_with(app.clone(), "/v0/runtime/logs").await;
3049 assert_eq!(empty["schema"], "skenion.runtime.logs");
3050 assert_eq!(empty["events"], json!([]));
3051 assert_eq!(empty["retention"]["replayLimit"], 200);
3052 assert_eq!(
3053 empty["retention"]["replayLevels"],
3054 json!(["warning", "error"])
3055 );
3056
3057 let undo = post_empty_with(app.clone(), "/v0/sessions/default/undo").await;
3058 assert_eq!(undo["ok"], false);
3059
3060 let snapshot = get_json_with(app, "/v0/runtime/logs").await;
3061 let events = snapshot["events"].as_array().unwrap();
3062 assert_eq!(events.len(), 1);
3063 assert_eq!(events[0]["source"], "runtime");
3064 assert_eq!(events[0]["level"], "error");
3065 assert!(
3066 events[0]["message"]
3067 .as_str()
3068 .unwrap()
3069 .contains("available to undo")
3070 );
3071 }
3072
3073 #[tokio::test]
3074 async fn runtime_log_stream_replays_backlog_as_sse() {
3075 let app = runtime_router_with_fake_io_devices(Vec::new());
3076 let _ = post_empty_with(app.clone(), "/v0/sessions/default/undo").await;
3077
3078 let response = app
3079 .oneshot(
3080 Request::builder()
3081 .uri("/v0/runtime/logs/stream")
3082 .body(Body::empty())
3083 .expect("request should build"),
3084 )
3085 .await
3086 .expect("router should respond");
3087
3088 assert_eq!(response.status(), StatusCode::OK);
3089 assert!(
3090 response
3091 .headers()
3092 .get(CONTENT_TYPE)
3093 .unwrap()
3094 .to_str()
3095 .unwrap()
3096 .starts_with("text/event-stream")
3097 );
3098 let mut stream = response.into_body().into_data_stream();
3099 let chunk = tokio::time::timeout(Duration::from_secs(1), stream.next())
3100 .await
3101 .expect("runtime log stream should emit")
3102 .expect("runtime log stream should have a chunk")
3103 .expect("runtime log stream chunk should be ok");
3104 let text = std::str::from_utf8(&chunk).expect("runtime log stream should be utf8");
3105 assert!(text.contains("event: log"));
3106 assert!(text.contains("available to undo"));
3107 }
3108
3109 #[tokio::test]
3110 async fn session_event_stream_replays_current_snapshot_as_sse() {
3111 let app = runtime_router_with_fake_io_devices(Vec::new());
3112
3113 let response = app
3114 .oneshot(
3115 Request::builder()
3116 .uri("/v0/sessions/default/events/stream")
3117 .body(Body::empty())
3118 .expect("request should build"),
3119 )
3120 .await
3121 .expect("router should respond");
3122
3123 assert_eq!(response.status(), StatusCode::OK);
3124 let mut stream = response.into_body().into_data_stream();
3125 let chunk = tokio::time::timeout(Duration::from_secs(1), stream.next())
3126 .await
3127 .expect("session event stream should emit")
3128 .expect("session event stream should have a chunk")
3129 .expect("session event stream chunk should be ok");
3130 let text = std::str::from_utf8(&chunk).expect("session event stream should be utf8");
3131 assert!(text.contains("event: session"));
3132 assert!(text.contains("skenion.runtime.session.event"));
3133 assert!(text.contains("\"kind\":\"snapshot\""));
3134 }
3135
3136 fn session_event_from_sse_text(text: &str) -> RuntimeSessionEvent {
3137 let data = text
3138 .lines()
3139 .filter_map(|line| line.strip_prefix("data: "))
3140 .collect::<Vec<_>>()
3141 .join("");
3142 serde_json::from_str(&data).expect("session SSE event data should parse")
3143 }
3144
3145 #[tokio::test]
3146 async fn session_event_stream_emits_live_events_after_cursor() {
3147 let state = runtime_state_with_dry_preview();
3148 let app = runtime_router_with_state(state.clone());
3149
3150 let response = app
3151 .oneshot(
3152 Request::builder()
3153 .uri("/v0/sessions/alpha/events/stream?after=0")
3154 .body(Body::empty())
3155 .expect("request should build"),
3156 )
3157 .await
3158 .expect("router should respond");
3159
3160 assert_eq!(response.status(), StatusCode::OK);
3161 let record = state.sessions.get_or_create("alpha");
3162 {
3163 let session = record
3164 .session
3165 .read()
3166 .expect("runtime session lock should not be poisoned");
3167 publish_session_event(
3168 &record,
3169 RuntimeSessionEventKind::Snapshot,
3170 &session,
3171 Vec::new(),
3172 );
3173 }
3174
3175 let mut stream = response.into_body().into_data_stream();
3176 let chunk = tokio::time::timeout(Duration::from_secs(1), stream.next())
3177 .await
3178 .expect("session event stream should emit")
3179 .expect("session event stream should have a chunk")
3180 .expect("session event stream chunk should be ok");
3181 let text = std::str::from_utf8(&chunk).expect("session event stream should be utf8");
3182 assert!(text.contains("event: session"));
3183 assert!(text.contains("\"sessionId\":\"alpha\""));
3184 assert!(text.contains("\"cursor\":\"1\""));
3185 let event = session_event_from_sse_text(text);
3186 validate_runtime_session_event(&event).expect("live event should validate");
3187 }
3188
3189 #[tokio::test]
3190 async fn session_event_stream_replays_after_query_and_last_event_id() {
3191 let state = runtime_state_with_dry_preview();
3192 let app = runtime_router_with_state(state.clone());
3193 post_json_with(
3194 app.clone(),
3195 "/v0/sessions/alpha/load",
3196 sample_project_document_current(),
3197 )
3198 .await;
3199 post_json_with(
3200 app.clone(),
3201 "/v0/sessions/alpha/load",
3202 sample_shader_project_current(),
3203 )
3204 .await;
3205
3206 let record = state.sessions.get_or_create("alpha");
3207 assert_eq!(
3208 crate::session_registry::current_session_event_sequence(&record),
3209 2
3210 );
3211
3212 let after_query = app
3213 .clone()
3214 .oneshot(
3215 Request::builder()
3216 .uri("/v0/sessions/alpha/events/stream?after=1")
3217 .body(Body::empty())
3218 .expect("request should build"),
3219 )
3220 .await
3221 .expect("router should respond");
3222 let mut after_query_stream = after_query.into_body().into_data_stream();
3223 let after_query_chunk =
3224 tokio::time::timeout(Duration::from_secs(1), after_query_stream.next())
3225 .await
3226 .expect("session event stream should emit")
3227 .expect("session event stream should have a chunk")
3228 .expect("session event stream chunk should be ok");
3229 let after_query_text =
3230 std::str::from_utf8(&after_query_chunk).expect("session event stream should be utf8");
3231 let after_query_event = session_event_from_sse_text(after_query_text);
3232
3233 assert_eq!(after_query_event.sequence, 2);
3234 assert!(after_query_event.replay.replayed);
3235 validate_runtime_session_event(&after_query_event)
3236 .expect("after query replay event should validate");
3237 assert_eq!(
3238 crate::session_registry::current_session_event_sequence(&record),
3239 2
3240 );
3241
3242 let last_event_id = app
3243 .oneshot(
3244 Request::builder()
3245 .uri("/v0/sessions/alpha/events/stream")
3246 .header("last-event-id", "1")
3247 .body(Body::empty())
3248 .expect("request should build"),
3249 )
3250 .await
3251 .expect("router should respond");
3252 let mut last_event_id_stream = last_event_id.into_body().into_data_stream();
3253 let last_event_id_chunk =
3254 tokio::time::timeout(Duration::from_secs(1), last_event_id_stream.next())
3255 .await
3256 .expect("session event stream should emit")
3257 .expect("session event stream should have a chunk")
3258 .expect("session event stream chunk should be ok");
3259 let last_event_id_text =
3260 std::str::from_utf8(&last_event_id_chunk).expect("session event stream should be utf8");
3261 let last_event_id_event = session_event_from_sse_text(last_event_id_text);
3262
3263 assert_eq!(last_event_id_event.sequence, 2);
3264 assert!(last_event_id_event.replay.replayed);
3265 validate_runtime_session_event(&last_event_id_event)
3266 .expect("Last-Event-ID replay event should validate");
3267 assert_eq!(
3268 crate::session_registry::current_session_event_sequence(&record),
3269 2
3270 );
3271 }
3272
3273 #[test]
3274 fn stream_broadcast_helpers_format_live_and_gap_events() {
3275 let log_event = RuntimeLogEvent {
3276 id: 1,
3277 timestamp: "1970-01-01T00:00:00.000Z".to_owned(),
3278 source: RuntimeLogSource::Runtime,
3279 level: DiagnosticSeverity::Warning,
3280 code: Some("test-log".to_owned()),
3281 message: "test log".to_owned(),
3282 };
3283 let session = RuntimeSession::default();
3284 let record = RuntimeSessionRegistry::dry_preview().default_record();
3285 let session_event = session_snapshot_event(&record, &session);
3286
3287 assert!(runtime_log_broadcast_event(Ok(log_event)).is_ok());
3288 assert!(runtime_log_broadcast_event(Err(BroadcastStreamRecvError::Lagged(1))).is_ok());
3289 assert!(
3290 session_broadcast_event_after_high_water(Ok(session_event), record.clone(), 0)
3291 .is_some()
3292 );
3293 assert!(
3294 session_broadcast_event_after_high_water(
3295 Err(BroadcastStreamRecvError::Lagged(1)),
3296 record,
3297 0
3298 )
3299 .is_some()
3300 );
3301 }
3302
3303 #[tokio::test]
3304 async fn per_session_events_carry_session_id_sequence_and_replay_metadata() {
3305 let state = runtime_state_with_dry_preview();
3306 let app = runtime_router_with_state(state.clone());
3307
3308 post_json_with(
3309 app.clone(),
3310 "/v0/sessions/alpha/load",
3311 sample_project_document_current(),
3312 )
3313 .await;
3314 post_json_with(
3315 app,
3316 "/v0/sessions/beta/load",
3317 sample_shader_project_current(),
3318 )
3319 .await;
3320
3321 let alpha = state.sessions.get_or_create("alpha");
3322 let beta = state.sessions.get_or_create("beta");
3323 let alpha_events = alpha
3324 .event_store
3325 .lock()
3326 .expect("event store should not be poisoned")
3327 .clone();
3328 let beta_events = beta
3329 .event_store
3330 .lock()
3331 .expect("event store should not be poisoned")
3332 .clone();
3333
3334 assert_eq!(alpha_events.len(), 1);
3335 assert_eq!(alpha_events[0].session_id, "alpha");
3336 assert_eq!(alpha_events[0].sequence, 1);
3337 assert_eq!(alpha_events[0].replay.cursor, "1");
3338 assert_eq!(beta_events[0].session_id, "beta");
3339 assert_eq!(beta_events[0].sequence, 1);
3340
3341 let replay = capture_session_replay(&alpha, Some(0), alpha_events[0].clone()).events;
3342 assert_eq!(replay.len(), 1);
3343 assert!(replay[0].replay.replayed);
3344 assert_eq!(replay[0].session_id, "alpha");
3345 }
3346
3347 #[tokio::test]
3348 async fn io_device_api_reports_empty_state() {
3349 let app = runtime_router_with_fake_io_devices(Vec::new());
3350
3351 let devices = get_json_with(app.clone(), "/v0/io/devices").await;
3352 assert_eq!(devices["ok"], true);
3353 assert_eq!(devices["devices"], json!([]));
3354 }
3355
3356 #[tokio::test]
3357 async fn asset_import_list_and_get_endpoints() {
3358 let app = runtime_router();
3359 let boundary = "skenion-test-boundary";
3360 let body = format!(
3361 "--{boundary}\r\ncontent-disposition: form-data; name=\"file\"; filename=\"clip.mov\"\r\ncontent-type: video/quicktime\r\n\r\nasset-bytes\r\n--{boundary}--\r\n"
3362 );
3363
3364 let response = app
3365 .clone()
3366 .oneshot(
3367 Request::builder()
3368 .method(Method::POST)
3369 .uri("/v0/assets/import")
3370 .header(
3371 CONTENT_TYPE,
3372 format!("multipart/form-data; boundary={boundary}"),
3373 )
3374 .body(Body::from(body))
3375 .expect("request should build"),
3376 )
3377 .await
3378 .expect("router should respond");
3379 assert_eq!(response.status(), StatusCode::OK);
3380 let imported = body_json(response.into_body()).await;
3381 assert_eq!(imported["ok"], true);
3382 assert_eq!(imported["asset"]["name"], "clip.mov");
3383 assert_eq!(imported["asset"]["mimeType"], "video/quicktime");
3384 assert_eq!(imported["asset"]["kind"], "video");
3385 let asset_id = imported["asset"]["id"].as_str().unwrap();
3386 assert!(
3387 imported["asset"]["runtimeUri"]
3388 .as_str()
3389 .unwrap()
3390 .contains(asset_id)
3391 );
3392
3393 let mut large_body = format!(
3394 "--{boundary}\r\ncontent-disposition: form-data; name=\"file\"; filename=\"large.mp4\"\r\ncontent-type: video/mp4\r\n\r\n"
3395 )
3396 .into_bytes();
3397 large_body.extend(vec![b'x'; 3 * 1024 * 1024]);
3398 large_body.extend(format!("\r\n--{boundary}--\r\n").into_bytes());
3399 let large = app
3400 .clone()
3401 .oneshot(
3402 Request::builder()
3403 .method(Method::POST)
3404 .uri("/v0/assets/import")
3405 .header(
3406 CONTENT_TYPE,
3407 format!("multipart/form-data; boundary={boundary}"),
3408 )
3409 .body(Body::from(large_body))
3410 .expect("request should build"),
3411 )
3412 .await
3413 .expect("router should respond");
3414 assert_eq!(large.status(), StatusCode::OK);
3415 let large = body_json(large.into_body()).await;
3416 assert_eq!(large["ok"], true);
3417 assert_eq!(large["asset"]["name"], "large.mp4");
3418
3419 let unnamed_body = format!(
3420 "--{boundary}\r\ncontent-disposition: form-data; name=\"file\"\r\n\r\nasset-bytes\r\n--{boundary}--\r\n"
3421 );
3422 let unnamed = app
3423 .clone()
3424 .oneshot(
3425 Request::builder()
3426 .method(Method::POST)
3427 .uri("/v0/assets/import")
3428 .header(
3429 CONTENT_TYPE,
3430 format!("multipart/form-data; boundary={boundary}"),
3431 )
3432 .body(Body::from(unnamed_body))
3433 .expect("request should build"),
3434 )
3435 .await
3436 .expect("router should respond");
3437 let unnamed = body_json(unnamed.into_body()).await;
3438 assert_eq!(unnamed["ok"], true);
3439 assert_eq!(unnamed["asset"]["name"], "asset.bin");
3440 assert_eq!(unnamed["asset"]["mimeType"], "application/octet-stream");
3441 assert_eq!(unnamed["asset"]["kind"], "binary");
3442
3443 let listed = app
3444 .clone()
3445 .oneshot(
3446 Request::builder()
3447 .method(Method::GET)
3448 .uri("/v0/assets")
3449 .body(Body::empty())
3450 .expect("request should build"),
3451 )
3452 .await
3453 .expect("router should respond");
3454 let listed = body_json(listed.into_body()).await;
3455 assert_eq!(listed["ok"], true);
3456 assert_eq!(listed["assets"].as_array().unwrap().len(), 3);
3457
3458 let fetched = app
3459 .clone()
3460 .oneshot(
3461 Request::builder()
3462 .method(Method::GET)
3463 .uri(format!("/v0/assets/{asset_id}"))
3464 .body(Body::empty())
3465 .expect("request should build"),
3466 )
3467 .await
3468 .expect("router should respond");
3469 let fetched = body_json(fetched.into_body()).await;
3470 assert_eq!(fetched["ok"], true);
3471 assert_eq!(fetched["asset"]["id"], asset_id);
3472
3473 let missing = app
3474 .oneshot(
3475 Request::builder()
3476 .method(Method::GET)
3477 .uri("/v0/assets/missing")
3478 .body(Body::empty())
3479 .expect("request should build"),
3480 )
3481 .await
3482 .expect("router should respond");
3483 let missing = body_json(missing.into_body()).await;
3484 assert_eq!(missing["ok"], false);
3485 assert!(
3486 missing["diagnostics"][0]["message"]
3487 .as_str()
3488 .unwrap()
3489 .contains("missing")
3490 );
3491
3492 let ignored_field = format!(
3493 "--{boundary}\r\ncontent-disposition: form-data; name=\"metadata\"\r\n\r\nignored\r\n--{boundary}--\r\n"
3494 );
3495 let missing_file = runtime_router()
3496 .oneshot(
3497 Request::builder()
3498 .method(Method::POST)
3499 .uri("/v0/assets/import")
3500 .header(
3501 CONTENT_TYPE,
3502 format!("multipart/form-data; boundary={boundary}"),
3503 )
3504 .body(Body::from(ignored_field))
3505 .expect("request should build"),
3506 )
3507 .await
3508 .expect("router should respond");
3509 let missing_file = body_json(missing_file.into_body()).await;
3510 assert_eq!(missing_file["ok"], false);
3511 assert!(
3512 missing_file["diagnostics"][0]["message"]
3513 .as_str()
3514 .unwrap()
3515 .contains("did not include a file field")
3516 );
3517
3518 let malformed_file = format!(
3519 "--{boundary}\r\ncontent-disposition: form-data; name=\"file\"; filename=\"broken.bin\"\r\ncontent-type: application/octet-stream\r\n\r\nunterminated"
3520 );
3521 let malformed = runtime_router()
3522 .oneshot(
3523 Request::builder()
3524 .method(Method::POST)
3525 .uri("/v0/assets/import")
3526 .header(
3527 CONTENT_TYPE,
3528 format!("multipart/form-data; boundary={boundary}"),
3529 )
3530 .body(Body::from(malformed_file))
3531 .expect("request should build"),
3532 )
3533 .await
3534 .expect("router should respond");
3535 let malformed = body_json(malformed.into_body()).await;
3536 assert_eq!(malformed["ok"], false);
3537 }
3538
3539 #[test]
3540 fn asset_store_helpers_report_filesystem_errors_and_kind_labels() {
3541 let state = RuntimeServerState::default();
3542 let base = std::env::temp_dir().join(format!(
3543 "skenion-asset-store-test-{}-{}",
3544 std::process::id(),
3545 std::time::SystemTime::now()
3546 .duration_since(std::time::UNIX_EPOCH)
3547 .unwrap()
3548 .as_nanos()
3549 ));
3550 std::fs::write(&base, b"not a directory").expect("blocker should write");
3551
3552 let create_error = store_asset_with_id(
3553 &state,
3554 "asset_create_error".to_owned(),
3555 "clip.mov".to_owned(),
3556 "video/quicktime".to_owned(),
3557 Bytes::from_static(b"asset"),
3558 base.clone(),
3559 );
3560 assert!(!create_error.ok);
3561 assert!(
3562 create_error.diagnostics[0]
3563 .message
3564 .contains("failed to create runtime asset directory")
3565 );
3566
3567 std::fs::remove_file(&base).expect("blocker should remove");
3568 std::fs::create_dir_all(&base).expect("base directory should create");
3569 std::fs::create_dir(base.join("asset_write_error")).expect("asset blocker should create");
3570
3571 let write_error = store_asset_with_id(
3572 &state,
3573 "asset_write_error".to_owned(),
3574 "clip.mov".to_owned(),
3575 "video/quicktime".to_owned(),
3576 Bytes::from_static(b"asset"),
3577 base.clone(),
3578 );
3579 assert!(!write_error.ok);
3580 assert!(
3581 write_error.diagnostics[0]
3582 .message
3583 .contains("failed to store runtime asset")
3584 );
3585
3586 assert_eq!(asset_kind("video/mp4"), "video");
3587 assert_eq!(asset_kind("image/png"), "image");
3588 assert_eq!(asset_kind("audio/wav"), "audio");
3589 assert_eq!(asset_kind("application/octet-stream"), "binary");
3590
3591 std::fs::remove_dir_all(base).expect("base directory should remove");
3592 }
3593
3594 #[test]
3595 fn preview_control_update_warning_is_attached_to_control_response() {
3596 let mut response = RuntimeControlEventResponse {
3597 ok: true,
3598 changed: true,
3599 control_revision: Some(1),
3600 emitted: Vec::new(),
3601 diagnostics: Vec::new(),
3602 };
3603
3604 add_preview_control_update_warning(&mut response, "snapshot write failed".to_owned());
3605
3606 assert_eq!(response.diagnostics.len(), 1);
3607 assert_eq!(
3608 response.diagnostics[0].severity,
3609 crate::DiagnosticSeverity::Warning
3610 );
3611 assert!(
3612 response.diagnostics[0]
3613 .message
3614 .contains("snapshot write failed")
3615 );
3616 }
3617
3618 #[tokio::test]
3619 async fn cors_allows_local_studio_origin() {
3620 for origin in [
3621 "http://127.0.0.1:5173",
3622 "http://localhost:5173",
3623 "http://127.0.0.1:5174",
3624 "http://localhost:5174",
3625 "http://127.0.0.1:5175",
3626 "http://localhost:5175",
3627 ] {
3628 let response = runtime_router()
3629 .oneshot(
3630 Request::builder()
3631 .method(Method::OPTIONS)
3632 .uri("/v0/runtime/info")
3633 .header(ORIGIN, origin)
3634 .header(ACCESS_CONTROL_REQUEST_METHOD, "GET")
3635 .body(Body::empty())
3636 .expect("request should build"),
3637 )
3638 .await
3639 .expect("router should respond");
3640
3641 assert_eq!(response.status(), StatusCode::OK);
3642 assert_eq!(
3643 response.headers().get(ACCESS_CONTROL_ALLOW_ORIGIN).unwrap(),
3644 origin
3645 );
3646 }
3647 }
3648
3649 #[tokio::test]
3650 async fn cors_rejects_unknown_origin() {
3651 let response = runtime_router()
3652 .oneshot(
3653 Request::builder()
3654 .method(Method::OPTIONS)
3655 .uri("/v0/runtime/info")
3656 .header(ORIGIN, "http://example.test")
3657 .header(ACCESS_CONTROL_REQUEST_METHOD, "GET")
3658 .body(Body::empty())
3659 .expect("request should build"),
3660 )
3661 .await
3662 .expect("router should respond");
3663
3664 assert_eq!(response.status(), StatusCode::OK);
3665 assert!(
3666 response
3667 .headers()
3668 .get(ACCESS_CONTROL_ALLOW_ORIGIN)
3669 .is_none()
3670 );
3671 }
3672
3673 #[tokio::test]
3674 async fn project_endpoints_reject_missing_graph_schema_version() {
3675 for path in ["/v0/validate", "/v0/plan", "/v0/run"] {
3676 let response = post_json(path, json!({ "graph": 42, "nodes": [] })).await;
3677
3678 assert_eq!(response["ok"], false);
3679 assert_eq!(
3680 response["diagnostics"][0]["code"],
3681 "project.missing-schema-version"
3682 );
3683 assert_eq!(response["plan"], Value::Null);
3684 assert_eq!(response["report"], Value::Null);
3685 }
3686 }
3687
3688 #[tokio::test]
3689 async fn current_project_endpoints_validate_plan_and_run_with_edge_metadata() {
3690 let validation = post_json("/v0/validate", sample_project_current()).await;
3691 assert_eq!(validation["ok"], true);
3692 assert_eq!(validation["diagnostics"].as_array().unwrap().len(), 0);
3693 assert_eq!(validation["plan"], Value::Null);
3694
3695 let plan = post_json("/v0/plan", sample_project_current()).await;
3696 assert_eq!(plan["ok"], true);
3697 assert_eq!(plan["plan"]["graphId"], "render-output-current");
3698 assert_eq!(plan["plan"]["graphRevision"], "1");
3699 assert_eq!(
3700 plan["plan"]["edges"][0]["metadata"]["resolvedType"],
3701 "render.frame"
3702 );
3703 assert_eq!(
3704 plan["plan"]["edges"][0]["metadata"]["mergePolicy"],
3705 "forbid"
3706 );
3707 assert_eq!(
3708 plan["plan"]["edges"][0]["metadata"]["fanOutPolicy"],
3709 "allow"
3710 );
3711 assert_eq!(
3712 plan["plan"]["edges"][0]["metadata"]["cycleClassification"],
3713 Value::Null
3714 );
3715 assert_eq!(plan["report"], Value::Null);
3716
3717 let mut run_request = sample_project_current();
3718 run_request["frames"] = json!(3);
3719 let run = post_json("/v0/run", run_request).await;
3720 assert_eq!(run["ok"], true);
3721 assert_eq!(run["report"]["frameCount"], 3);
3722 assert_eq!(
3723 run["report"]["frames"][0]["executedNodes"][0]["status"],
3724 "simulated"
3725 );
3726 }
3727
3728 #[tokio::test]
3729 async fn current_project_document_payload_expands_patch_library_before_plan_and_run() {
3730 let validation =
3731 post_json("/v0/validate", sample_subpatch_project_document_current()).await;
3732 assert_eq!(validation["ok"], true);
3733 assert_eq!(validation["diagnostics"].as_array().unwrap().len(), 0);
3734
3735 let plan = post_json("/v0/plan", sample_subpatch_project_document_current()).await;
3736 assert_eq!(plan["ok"], true);
3737 assert_eq!(plan["plan"]["graphId"], "subpatch-project-root");
3738 assert!(
3739 plan["plan"]["nodes"]
3740 .as_array()
3741 .unwrap()
3742 .iter()
3743 .any(|node| node["nodeId"] == "fx::pass")
3744 );
3745 assert!(
3746 plan["plan"]["edges"]
3747 .as_array()
3748 .unwrap()
3749 .iter()
3750 .any(|edge| {
3751 edge["fromNode"] == "clear_color"
3752 && edge["toNode"] == "fx::pass"
3753 && edge["toPort"] == "in"
3754 })
3755 );
3756
3757 let mut run_request = sample_subpatch_project_document_current();
3758 run_request["frames"] = json!(2);
3759 let run = post_json("/v0/run", run_request).await;
3760 assert_eq!(run["ok"], true);
3761 assert_eq!(run["report"]["frameCount"], 2);
3762 }
3763
3764 #[tokio::test]
3765 async fn current_project_document_payload_reports_decode_and_contract_errors() {
3766 let malformed_project = json!({
3767 "schema": "skenion.project",
3768 "schemaVersion": "0.1.0"
3769 });
3770 let malformed_response = post_json("/v0/validate", malformed_project).await;
3771 assert_eq!(malformed_response["ok"], false);
3772 assert_eq!(
3773 malformed_response["diagnostics"][0]["code"],
3774 "project.missing-schema-version"
3775 );
3776 assert_eq!(
3777 malformed_response["diagnostics"][0]["details"]["surface"],
3778 "graph"
3779 );
3780
3781 let mut duplicate_patch = sample_subpatch_project_document_current();
3782 let patch = duplicate_patch["patchLibrary"][0].clone();
3783 duplicate_patch["patchLibrary"]
3784 .as_array_mut()
3785 .unwrap()
3786 .push(patch);
3787
3788 let response = post_json("/v0/plan", duplicate_patch).await;
3789 assert_eq!(response["ok"], false);
3790 assert_eq!(
3791 response["diagnostics"][0]["code"],
3792 json!("project.invalid-0.1")
3793 );
3794 assert_eq!(
3795 response["diagnostics"][0]["details"]["projectId"],
3796 json!("subpatch-project")
3797 );
3798 }
3799
3800 #[tokio::test]
3801 async fn current_project_endpoints_reject_ambiguous_algebraic_loop() {
3802 let response = post_json("/v0/validate", sample_ambiguous_loop_project_current()).await;
3803
3804 assert_eq!(response["ok"], false);
3805 assert!(
3806 response["diagnostics"]
3807 .as_array()
3808 .unwrap()
3809 .iter()
3810 .any(|diagnostic| diagnostic["message"]
3811 .as_str()
3812 .unwrap()
3813 .contains("ambiguous-algebraic-loop"))
3814 );
3815
3816 let plan = post_json("/v0/plan", sample_ambiguous_loop_project_current()).await;
3817 assert_eq!(plan["ok"], false);
3818 assert!(
3819 plan["diagnostics"][0]["message"]
3820 .as_str()
3821 .unwrap()
3822 .contains("ambiguous-algebraic-loop")
3823 );
3824
3825 let run = post_json("/v0/run", sample_ambiguous_loop_project_current()).await;
3826 assert_eq!(run["ok"], false);
3827 assert!(
3828 run["diagnostics"][0]["message"]
3829 .as_str()
3830 .unwrap()
3831 .contains("ambiguous-algebraic-loop")
3832 );
3833 }
3834
3835 #[tokio::test]
3836 async fn project_endpoints_reject_missing_and_unsupported_schema_versions() {
3837 let mut missing = sample_project_current();
3838 missing["graph"]
3839 .as_object_mut()
3840 .unwrap()
3841 .remove("schemaVersion");
3842 let missing_response = post_json("/v0/validate", missing).await;
3843 assert_eq!(missing_response["ok"], false);
3844 assert_eq!(
3845 missing_response["diagnostics"][0]["code"],
3846 "project.missing-schema-version"
3847 );
3848 assert_eq!(
3849 missing_response["diagnostics"][0]["details"]["surface"],
3850 "graph"
3851 );
3852 assert_eq!(
3853 missing_response["diagnostics"][0]["details"]["expectedSchemaVersion"],
3854 "0.1.0"
3855 );
3856 assert_eq!(
3857 missing_response["diagnostics"][0]["details"]["receivedSchemaVersion"],
3858 Value::Null
3859 );
3860
3861 let mut unsupported = sample_project_current();
3862 unsupported["graph"]["schemaVersion"] = json!("9.9.9");
3863 let unsupported_response = post_json("/v0/plan", unsupported).await;
3864 assert_eq!(unsupported_response["ok"], false);
3865 assert_eq!(
3866 unsupported_response["diagnostics"][0]["code"],
3867 "project.unsupported-schema-version"
3868 );
3869 assert_eq!(
3870 unsupported_response["diagnostics"][0]["details"]["surface"],
3871 "graph"
3872 );
3873 assert_eq!(
3874 unsupported_response["diagnostics"][0]["details"]["expectedSchemaVersion"],
3875 "0.1.0"
3876 );
3877 assert_eq!(
3878 unsupported_response["diagnostics"][0]["details"]["receivedSchemaVersion"],
3879 "9.9.9"
3880 );
3881
3882 let mut missing_run = sample_project_current();
3883 missing_run["graph"]
3884 .as_object_mut()
3885 .unwrap()
3886 .remove("schemaVersion");
3887 let missing_run_response = post_json("/v0/run", missing_run).await;
3888 assert_eq!(missing_run_response["ok"], false);
3889 assert_eq!(
3890 missing_run_response["diagnostics"][0]["code"],
3891 "project.missing-schema-version"
3892 );
3893
3894 let mut unsupported_run = sample_project_current();
3895 unsupported_run["graph"]["schemaVersion"] = json!("9.9.9");
3896 let unsupported_run_response = post_json("/v0/run", unsupported_run).await;
3897 assert_eq!(unsupported_run_response["ok"], false);
3898 assert_eq!(
3899 unsupported_run_response["diagnostics"][0]["code"],
3900 "project.unsupported-schema-version"
3901 );
3902
3903 let mut unsupported_project = sample_project_document_current();
3904 unsupported_project["schemaVersion"] = json!("9.9.9");
3905 let unsupported_project_response = post_json("/v0/validate", unsupported_project).await;
3906 assert_eq!(unsupported_project_response["ok"], false);
3907 assert_eq!(
3908 unsupported_project_response["diagnostics"][0]["code"],
3909 "project.unsupported-schema-version"
3910 );
3911 assert_eq!(
3912 unsupported_project_response["diagnostics"][0]["details"]["surface"],
3913 "project"
3914 );
3915 assert_eq!(
3916 unsupported_project_response["diagnostics"][0]["details"]["expectedSchemaVersion"],
3917 "0.1.0"
3918 );
3919 assert_eq!(
3920 unsupported_project_response["diagnostics"][0]["details"]["receivedSchemaVersion"],
3921 "9.9.9"
3922 );
3923
3924 let mut unsupported_project_graph = sample_project_document_current();
3925 unsupported_project_graph["graph"]["schemaVersion"] = json!("9.9.9");
3926 let unsupported_project_graph_response =
3927 post_json("/v0/validate", unsupported_project_graph).await;
3928 assert_eq!(unsupported_project_graph_response["ok"], false);
3929 assert_eq!(
3930 unsupported_project_graph_response["diagnostics"][0]["code"],
3931 "project.unsupported-schema-version"
3932 );
3933 assert_eq!(
3934 unsupported_project_graph_response["diagnostics"][0]["details"]["surface"],
3935 "graph"
3936 );
3937 assert_eq!(
3938 unsupported_project_graph_response["diagnostics"][0]["details"]["expectedSchemaVersion"],
3939 "0.1.0"
3940 );
3941 assert_eq!(
3942 unsupported_project_graph_response["diagnostics"][0]["details"]["receivedSchemaVersion"],
3943 "9.9.9"
3944 );
3945 }
3946
3947 #[tokio::test]
3948 async fn project_endpoints_reject_malformed_payloads() {
3949 let mut request = sample_project_current();
3950 request["nodes"] = json!({});
3951
3952 let response = post_json("/v0/validate", request).await;
3953
3954 assert_eq!(response["ok"], false);
3955 assert!(
3956 response["diagnostics"][0]["message"]
3957 .as_str()
3958 .unwrap()
3959 .contains("invalid project request")
3960 );
3961 }
3962
3963 #[tokio::test]
3964 async fn session_endpoint_returns_empty_state() {
3965 let response = get_json("/v0/sessions/default").await;
3966
3967 assert_eq!(response["ok"], true);
3968 assert_eq!(response["snapshot"]["project"], Value::Null);
3969 assert_eq!(response["snapshot"]["sessionRevision"], 0);
3970 assert_eq!(response["snapshot"]["viewRevision"], 0);
3971 assert_eq!(response["snapshot"]["controlRevision"], 0);
3972 assert_eq!(response["diagnostics"].as_array().unwrap().len(), 0);
3973 assert_eq!(response["snapshot"]["plan"], Value::Null);
3974 assert_eq!(response["report"], Value::Null);
3975 }
3976
3977 #[tokio::test]
3978 async fn session_snapshot_returns_loaded_project() {
3979 let app = runtime_router();
3980
3981 let empty = get_json_with(app.clone(), "/v0/sessions/default").await;
3982 assert_eq!(empty["ok"], true);
3983 assert_eq!(empty["snapshot"]["project"], Value::Null);
3984
3985 post_json_with(
3986 app.clone(),
3987 "/v0/sessions/default/load",
3988 sample_project_document_current(),
3989 )
3990 .await;
3991 let project = get_json_with(app, "/v0/sessions/default").await;
3992
3993 assert_eq!(project["ok"], true);
3994 assert_eq!(
3995 project["snapshot"]["project"]["id"],
3996 "minimal-value-project"
3997 );
3998 assert_eq!(
3999 project["snapshot"]["project"]["graph"]["id"],
4000 "minimal-value"
4001 );
4002 assert!(project["snapshot"]["project"]["nodes"].is_null());
4003 }
4004
4005 #[tokio::test]
4006 async fn session_load_stores_valid_project() {
4007 let app = runtime_router();
4008 let mut project = sample_subpatch_project_document_current();
4009 project["metadata"] = json!({
4010 "title": "Loaded Subpatch Project",
4011 "source": "session-load-test"
4012 });
4013 project["tutorial"] = json!({
4014 "steps": [{ "id": "intro", "title": "Intro" }]
4015 });
4016 project["help"] = json!({
4017 "topics": ["core.subpatch"]
4018 });
4019 let response = post_json_with(app.clone(), "/v0/sessions/default/load", project).await;
4020
4021 assert_eq!(response["ok"], true);
4022 assert_eq!(response["snapshot"]["project"]["id"], "subpatch-project");
4023 assert_eq!(
4024 response["snapshot"]["project"]["metadata"]["title"],
4025 "Loaded Subpatch Project"
4026 );
4027 assert_eq!(
4028 response["snapshot"]["project"]["metadata"]["source"],
4029 "session-load-test"
4030 );
4031 assert_eq!(
4032 response["snapshot"]["project"]["tutorial"]["steps"][0]["id"],
4033 "intro"
4034 );
4035 assert_eq!(
4036 response["snapshot"]["project"]["help"]["topics"][0],
4037 "core.subpatch"
4038 );
4039 assert_eq!(
4040 response["snapshot"]["project"]["patchLibrary"][0]["id"],
4041 "identity"
4042 );
4043 assert_eq!(
4044 response["snapshot"]["project"]["graph"]["id"],
4045 "subpatch-project-root"
4046 );
4047 assert_eq!(response["snapshot"]["project"]["graph"]["revision"], "1");
4048 assert_eq!(response["snapshot"]["sessionRevision"], 1);
4049 assert_eq!(
4050 response["snapshot"]["plan"]["graphId"],
4051 "subpatch-project-root"
4052 );
4053
4054 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4055 assert_eq!(
4056 snapshot["snapshot"]["project"]["graph"]["id"],
4057 "subpatch-project-root"
4058 );
4059 assert!(
4060 snapshot["snapshot"]["plan"]["nodes"]
4061 .as_array()
4062 .unwrap()
4063 .iter()
4064 .any(|node| node["nodeId"] == "fx::pass")
4065 );
4066 }
4067
4068 #[tokio::test]
4069 async fn session_load_rejects_missing_graph_schema_version() {
4070 let app = runtime_router();
4071 let response = post_json_with(
4072 app,
4073 "/v0/sessions/default/load",
4074 json!({ "graph": 42, "nodes": [] }),
4075 )
4076 .await;
4077
4078 assert_eq!(response["ok"], false);
4079 assert_eq!(response["snapshot"]["project"], Value::Null);
4080 assert_eq!(
4081 response["diagnostics"][0]["code"],
4082 "project.missing-schema-version"
4083 );
4084 }
4085
4086 #[tokio::test]
4087 async fn legacy_import_routes_are_not_runtime_api_surface() {
4088 let app = runtime_router();
4089 let default_status = post_status_with(
4090 app.clone(),
4091 "/v0/sessions/default/import/legacy-v0.1",
4092 sample_project(),
4093 )
4094 .await;
4095 let named_status = post_status_with(
4096 app.clone(),
4097 "/v0/sessions/alpha/import/legacy-v0.1",
4098 sample_project(),
4099 )
4100 .await;
4101
4102 assert_eq!(default_status, StatusCode::NOT_FOUND);
4103 assert_eq!(named_status, StatusCode::NOT_FOUND);
4104
4105 for path in ["/v0/sessions/default", "/v0/sessions/alpha"] {
4106 let snapshot = get_json_with(app.clone(), path).await;
4107 assert_eq!(snapshot["snapshot"]["project"], Value::Null);
4108 assert_eq!(snapshot["snapshot"]["sessionRevision"], 0);
4109 }
4110 }
4111
4112 #[tokio::test]
4113 async fn default_session_uses_explicit_session_route_only() {
4114 let app = runtime_router();
4115
4116 assert_eq!(
4117 status_with(app.clone(), "/v0/session").await,
4118 StatusCode::NOT_FOUND
4119 );
4120 assert_eq!(
4121 status_with(app.clone(), "/v0/session/info").await,
4122 StatusCode::NOT_FOUND
4123 );
4124
4125 let loaded = post_json_with(
4126 app.clone(),
4127 "/v0/sessions/default/load",
4128 sample_project_document_current(),
4129 )
4130 .await;
4131 let explicit = get_json_with(app.clone(), "/v0/sessions/default").await;
4132 let info = get_json_with(app, "/v0/sessions/default/info").await;
4133
4134 assert_eq!(loaded["ok"], true);
4135 assert_eq!(explicit["ok"], true);
4136 assert_eq!(loaded["snapshot"], explicit["snapshot"]);
4137 assert_eq!(info["sessionId"], DEFAULT_SESSION_ID);
4138 assert_eq!(
4139 info["snapshot"]["project"]["graph"]["id"],
4140 loaded["snapshot"]["project"]["graph"]["id"]
4141 );
4142 let info = serde_json::from_value::<RuntimeSessionInfoResponse>(info)
4143 .expect("session info should match contract shape");
4144 skenion_contracts::validate_runtime_session_info_response(&info)
4145 .expect("session info should validate against contracts");
4146 }
4147
4148 #[tokio::test]
4149 async fn explicit_sessions_keep_graph_control_and_history_state_separate() {
4150 let app = runtime_router();
4151
4152 post_json_with(
4153 app.clone(),
4154 "/v0/sessions/alpha/load",
4155 sample_project_document_current(),
4156 )
4157 .await;
4158 post_json_with(
4159 app.clone(),
4160 "/v0/sessions/beta/load",
4161 sample_shader_project_current(),
4162 )
4163 .await;
4164 post_json_with(
4165 app.clone(),
4166 "/v0/sessions/alpha/operation",
4167 paste_operation("1"),
4168 )
4169 .await;
4170 let alpha_control = post_json_with(
4171 app.clone(),
4172 "/v0/sessions/alpha/control/event",
4173 json!({
4174 "nodeId": "value_1",
4175 "portId": "in",
4176 "message": { "selector": "set", "atoms": [{ "type": "float", "representation": "f32", "value": 7.0 }] }
4177 }),
4178 )
4179 .await;
4180
4181 let alpha = get_json_with(app.clone(), "/v0/sessions/alpha").await;
4182 let beta = get_json_with(app.clone(), "/v0/sessions/beta").await;
4183 let alpha_history = get_json_with(app.clone(), "/v0/sessions/alpha/history").await;
4184 let beta_history = get_json_with(app.clone(), "/v0/sessions/beta/history").await;
4185 let beta_control = get_json_with(app, "/v0/sessions/beta/control/state").await;
4186
4187 assert_eq!(alpha_control["ok"], true);
4188 assert_eq!(alpha["snapshot"]["project"]["graph"]["id"], "minimal-value");
4189 assert_eq!(alpha["snapshot"]["project"]["graph"]["revision"], "2");
4190 assert_eq!(
4191 beta["snapshot"]["project"]["graph"]["id"],
4192 "shader-diagnostics"
4193 );
4194 assert_eq!(beta["snapshot"]["project"]["graph"]["revision"], "1");
4195 assert_eq!(alpha_history["entries"].as_array().unwrap().len(), 1);
4196 assert_eq!(beta_history["entries"], json!([]));
4197 assert_eq!(beta_control["controlRevision"], 0);
4198 }
4199
4200 #[tokio::test]
4201 async fn invalid_session_load_does_not_replace_existing_session() {
4202 let app = runtime_router();
4203 let loaded = post_json_with(
4204 app.clone(),
4205 "/v0/sessions/default/load",
4206 sample_project_document_current(),
4207 )
4208 .await;
4209 let mut invalid = sample_project_document_current();
4210 invalid["nodes"] = json!([]);
4211
4212 let response = post_json_with(app.clone(), "/v0/sessions/default/load", invalid).await;
4213
4214 assert_eq!(loaded["snapshot"]["sessionRevision"], 1);
4215 assert_eq!(response["ok"], false);
4216 assert_eq!(
4217 response["snapshot"]["project"]["graph"]["id"],
4218 "minimal-value"
4219 );
4220 assert_eq!(response["snapshot"]["sessionRevision"], 1);
4221 assert!(
4222 response["diagnostics"][0]["message"]
4223 .as_str()
4224 .unwrap()
4225 .contains("missing node definition")
4226 );
4227
4228 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4229 assert_eq!(snapshot["ok"], true);
4230 assert_eq!(
4231 snapshot["snapshot"]["project"]["graph"]["id"],
4232 "minimal-value"
4233 );
4234 assert_eq!(
4235 snapshot["snapshot"]["diagnostics"]
4236 .as_array()
4237 .unwrap()
4238 .len(),
4239 0
4240 );
4241 }
4242
4243 #[tokio::test]
4244 async fn session_validate_plan_and_run_use_loaded_project_document_patch_library() {
4245 let app = runtime_router();
4246 post_json_with(
4247 app.clone(),
4248 "/v0/sessions/default/load",
4249 sample_subpatch_project_document_current(),
4250 )
4251 .await;
4252
4253 let validation = post_empty_with(app.clone(), "/v0/sessions/default/validate").await;
4254 assert_eq!(validation["ok"], true);
4255 assert_eq!(validation["diagnostics"].as_array().unwrap().len(), 0);
4256
4257 let plan = post_empty_with(app.clone(), "/v0/sessions/default/plan").await;
4258 assert_eq!(plan["ok"], true);
4259 assert_eq!(plan["snapshot"]["project"]["id"], "subpatch-project");
4260 assert_eq!(
4261 plan["snapshot"]["project"]["patchLibrary"][0]["id"],
4262 "identity"
4263 );
4264 assert_eq!(plan["snapshot"]["plan"]["graphId"], "subpatch-project-root");
4265 assert!(
4266 plan["snapshot"]["plan"]["nodes"]
4267 .as_array()
4268 .unwrap()
4269 .iter()
4270 .any(|node| node["nodeId"] == "fx::pass")
4271 );
4272
4273 let run = post_json_with(app, "/v0/sessions/default/run", json!({ "frames": 2 })).await;
4274 assert_eq!(run["ok"], true);
4275 assert_eq!(run["report"]["frameCount"], 2);
4276 assert_eq!(
4277 run["report"]["frames"][0]["executedNodes"][0]["status"],
4278 "simulated"
4279 );
4280 }
4281
4282 #[tokio::test]
4283 async fn session_operation_endpoint_applies_and_rejects_conflicts() {
4284 let app = runtime_router();
4285 post_json_with(
4286 app.clone(),
4287 "/v0/sessions/default/load",
4288 sample_project_document_current(),
4289 )
4290 .await;
4291
4292 let patched = post_json_with(
4293 app.clone(),
4294 "/v0/sessions/default/operation",
4295 paste_operation("1"),
4296 )
4297 .await;
4298 assert_eq!(patched["ok"], true);
4299 assert_eq!(patched["applied"], true);
4300 assert_eq!(patched["conflict"], false);
4301 assert_eq!(patched["revisionBefore"], "1");
4302 assert_eq!(patched["revisionAfter"], "2");
4303
4304 let snapshot = get_json_with(app.clone(), "/v0/sessions/default").await;
4305 let history = get_json_with(app.clone(), "/v0/sessions/default/history").await;
4306 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "2");
4307 assert_eq!(history["entries"][0]["kind"], "apply");
4308 assert_eq!(history["undoDepth"], 1);
4309 assert_eq!(history["redoDepth"], 0);
4310 assert_eq!(snapshot["snapshot"]["sessionRevision"], 2);
4311 assert_eq!(snapshot["snapshot"]["plan"]["graphRevision"], "2");
4312
4313 let conflict =
4314 post_json_with(app, "/v0/sessions/default/operation", paste_operation("1")).await;
4315 assert_eq!(conflict["ok"], false);
4316 assert_eq!(conflict["applied"], false);
4317 assert_eq!(conflict["conflict"], true);
4318 assert!(
4319 conflict["diagnostics"][0]["message"]
4320 .as_str()
4321 .unwrap()
4322 .contains("does not match target graph revision")
4323 );
4324 }
4325
4326 #[tokio::test]
4327 async fn actor_attribution_is_optional_and_client_metadata_is_preserved() {
4328 let app = runtime_router();
4329 post_json_with(
4330 app.clone(),
4331 "/v0/sessions/default/load",
4332 sample_project_document_current(),
4333 )
4334 .await;
4335
4336 let mut omitted_operation = paste_operation("1");
4337 omitted_operation
4338 .as_object_mut()
4339 .expect("operation should be an object")
4340 .remove("attribution");
4341 let omitted = post_json_with(
4342 app.clone(),
4343 "/v0/sessions/default/operation",
4344 omitted_operation,
4345 )
4346 .await;
4347 let mut attributed_operation = paste_operation("2");
4348 attributed_operation["attribution"]["clientId"] = json!("studio-window-a");
4349 let attributed = post_json_with(
4350 app.clone(),
4351 "/v0/sessions/default/operation",
4352 attributed_operation,
4353 )
4354 .await;
4355 let history = get_json_with(app, "/v0/sessions/default/history").await;
4356
4357 assert_eq!(omitted["ok"], true);
4358 assert_eq!(attributed["ok"], true);
4359 assert_eq!(history["entries"][0]["clientId"], Value::Null);
4360 assert_eq!(history["entries"][1]["clientId"], "studio-window-a");
4361 assert_eq!(
4362 history["entries"][1]["mutation"]["clientId"],
4363 "studio-window-a"
4364 );
4365 }
4366
4367 #[tokio::test]
4368 async fn session_operation_endpoint_pastes_graph_fragment() {
4369 let app = runtime_router();
4370 post_json_with(
4371 app.clone(),
4372 "/v0/sessions/default/load",
4373 sample_project_document_current(),
4374 )
4375 .await;
4376
4377 let response = post_json_with(
4378 app.clone(),
4379 "/v0/sessions/default/operation",
4380 paste_operation("1"),
4381 )
4382 .await;
4383
4384 assert_eq!(response["ok"], true);
4385 assert_eq!(response["applied"], true);
4386 assert_eq!(response["revisionBefore"], "1");
4387 assert_eq!(response["revisionAfter"], "2");
4388 assert_eq!(
4389 response["idRemap"]["nodeIdMap"]["value_1"],
4390 json!("value_1_2")
4391 );
4392 assert_eq!(
4393 response["idRemap"]["edgeIdMap"]["edge_value_to_pasted"],
4394 json!("edge_value_to_pasted")
4395 );
4396
4397 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4398 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "2");
4399 assert!(
4400 snapshot["snapshot"]["project"]["graph"]["edges"]
4401 .as_array()
4402 .unwrap()
4403 .iter()
4404 .any(|edge| {
4405 edge["source"]["nodeId"] == "value_1_2"
4406 && edge["source"]["portId"] == "value"
4407 && edge["target"]["nodeId"] == "pasted_target"
4408 && edge["target"]["portId"] == "cold"
4409 })
4410 );
4411 }
4412
4413 #[tokio::test]
4414 async fn session_operation_endpoint_pastes_into_project_patch_definition_target() {
4415 let app = runtime_router();
4416 post_json_with(
4417 app.clone(),
4418 "/v0/sessions/default/load",
4419 sample_subpatch_project_document_current(),
4420 )
4421 .await;
4422
4423 let response = post_json_with(
4424 app.clone(),
4425 "/v0/sessions/default/operation",
4426 patch_definition_paste_operation("1"),
4427 )
4428 .await;
4429
4430 assert_eq!(response["ok"], true);
4431 assert_eq!(response["applied"], true);
4432 assert_eq!(response["revisionBefore"], "1");
4433 assert_eq!(response["revisionAfter"], "2");
4434 assert_eq!(
4435 response["target"]["path"]["kind"],
4436 "project-patch-definition"
4437 );
4438
4439 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4440 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "1");
4441 assert_eq!(
4442 snapshot["snapshot"]["project"]["patchLibrary"][0]["revision"],
4443 "2"
4444 );
4445 assert_eq!(
4446 snapshot["snapshot"]["project"]["patchLibrary"][0]["graph"]["revision"],
4447 "2"
4448 );
4449 assert!(
4450 snapshot["snapshot"]["project"]["patchLibrary"][0]["graph"]["nodes"]
4451 .as_array()
4452 .unwrap()
4453 .iter()
4454 .any(|node| node["id"] == "patch_debug")
4455 );
4456 }
4457
4458 #[tokio::test]
4459 async fn session_operation_endpoint_rejects_invalid_envelope_json() {
4460 let response = post_json(
4461 "/v0/sessions/default/operation",
4462 json!({
4463 "schema": "skenion.runtime.operation",
4464 "schemaVersion": "0.1.0",
4465 "kind": "pasteGraphFragment"
4466 }),
4467 )
4468 .await;
4469
4470 assert_eq!(response["ok"], false);
4471 assert_eq!(response["applied"], false);
4472 assert_eq!(response["target"]["path"]["kind"], "root");
4473 assert_eq!(
4474 response["diagnostics"][0]["code"],
4475 "paste.operation.invalid-json"
4476 );
4477 }
4478
4479 #[tokio::test]
4480 async fn session_operations_endpoint_accepts_runtime_paste_operation_alias() {
4481 let app = runtime_router();
4482 post_json_with(
4483 app.clone(),
4484 "/v0/sessions/default/load",
4485 sample_project_document_current(),
4486 )
4487 .await;
4488
4489 let response = post_json_with(
4490 app.clone(),
4491 "/v0/sessions/default/operations",
4492 paste_operation("1"),
4493 )
4494 .await;
4495
4496 assert_eq!(
4497 response["schema"],
4498 "skenion.runtime.paste-graph-fragment.response"
4499 );
4500 assert_eq!(response["ok"], true);
4501 assert_eq!(response["applied"], true);
4502 assert_eq!(response["revisionBefore"], "1");
4503 assert_eq!(response["revisionAfter"], "2");
4504 }
4505
4506 #[tokio::test]
4507 async fn collaboration_operations_apply_paste_and_publish_result_events() {
4508 let state = runtime_state_with_dry_preview();
4509 let app = runtime_router_with_state(state.clone());
4510 post_json_with(
4511 app.clone(),
4512 "/v0/sessions/default/load",
4513 sample_project_document_current(),
4514 )
4515 .await;
4516
4517 let response = post_json_with(
4518 app.clone(),
4519 "/v0/sessions/default/operations",
4520 collaboration_paste_operation("1", "op-collab-paste", "idem-collab-paste"),
4521 )
4522 .await;
4523 let result: RuntimeCollaborationOperationResult =
4524 serde_json::from_value(response).expect("collaboration result should parse");
4525 validate_runtime_collaboration_operation_result(&result)
4526 .expect("collaboration result should validate");
4527
4528 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Accepted);
4529 assert_eq!(
4530 result.ack.as_ref().map(|ack| ack.revision.as_str()),
4531 Some("2")
4532 );
4533 assert_eq!(result.operation_id, "op-collab-paste");
4534
4535 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4536 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "2");
4537
4538 let replay = state
4539 .sessions
4540 .default_record()
4541 .collaboration
4542 .capture_replay(Some(0))
4543 .events;
4544 assert_eq!(replay.len(), 1);
4545 let event: RuntimeCollaborationEventEnvelope = replay[0].clone();
4546 validate_runtime_collaboration_event_envelope(&event)
4547 .expect("collaboration event should validate");
4548 assert_eq!(event.kind, RuntimeCollaborationEventKind::OperationResult);
4549 }
4550
4551 #[tokio::test]
4552 async fn collaboration_operations_report_duplicate_idempotency_without_reapplying() {
4553 let app = runtime_router();
4554 post_json_with(
4555 app.clone(),
4556 "/v0/sessions/default/load",
4557 sample_project_document_current(),
4558 )
4559 .await;
4560 post_json_with(
4561 app.clone(),
4562 "/v0/sessions/default/operations",
4563 collaboration_paste_operation("1", "op-collab-paste", "idem-collab-paste"),
4564 )
4565 .await;
4566
4567 let duplicate = post_json_with(
4568 app.clone(),
4569 "/v0/sessions/default/operations",
4570 collaboration_paste_operation("2", "op-collab-paste-retry", "idem-collab-paste"),
4571 )
4572 .await;
4573 let result: RuntimeCollaborationOperationResult =
4574 serde_json::from_value(duplicate).expect("duplicate result should parse");
4575 validate_runtime_collaboration_operation_result(&result)
4576 .expect("duplicate result should validate");
4577
4578 assert_eq!(
4579 result.status,
4580 RuntimeCollaborationOperationStatus::Duplicate
4581 );
4582 assert_eq!(
4583 result.nack.as_ref().map(|nack| nack.reason.clone()),
4584 Some(RuntimeCollaborationNackReason::DuplicateIdempotencyKey)
4585 );
4586 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4587 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "2");
4588 }
4589
4590 #[tokio::test]
4591 async fn collaboration_operations_serialize_concurrent_idempotency() {
4592 let app = runtime_router();
4593 post_json_with(
4594 app.clone(),
4595 "/v0/sessions/default/load",
4596 sample_project_document_current(),
4597 )
4598 .await;
4599
4600 let first = post_json_with(
4601 app.clone(),
4602 "/v0/sessions/default/operations",
4603 collaboration_paste_operation("1", "op-concurrent-a", "idem-concurrent"),
4604 );
4605 let second = post_json_with(
4606 app.clone(),
4607 "/v0/sessions/default/operations",
4608 collaboration_paste_operation("1", "op-concurrent-b", "idem-concurrent"),
4609 );
4610 let (first, second) = tokio::join!(first, second);
4611 let statuses = [first, second]
4612 .into_iter()
4613 .map(|value| {
4614 let result: RuntimeCollaborationOperationResult =
4615 serde_json::from_value(value).expect("collaboration result should parse");
4616 validate_runtime_collaboration_operation_result(&result)
4617 .expect("collaboration result should validate");
4618 result.status
4619 })
4620 .collect::<Vec<_>>();
4621
4622 assert_eq!(
4623 statuses
4624 .iter()
4625 .filter(|status| **status == RuntimeCollaborationOperationStatus::Accepted)
4626 .count(),
4627 1
4628 );
4629 assert_eq!(
4630 statuses
4631 .iter()
4632 .filter(|status| **status == RuntimeCollaborationOperationStatus::Duplicate)
4633 .count(),
4634 1
4635 );
4636 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4637 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "2");
4638 }
4639
4640 #[tokio::test]
4641 async fn collaboration_operations_transform_stale_paste_to_current_revision() {
4642 let app = runtime_router();
4643 post_json_with(
4644 app.clone(),
4645 "/v0/sessions/default/load",
4646 sample_project_document_current(),
4647 )
4648 .await;
4649 post_json_with(
4650 app.clone(),
4651 "/v0/sessions/default/operations",
4652 collaboration_paste_operation("1", "op-fresh", "idem-fresh"),
4653 )
4654 .await;
4655
4656 let stale = post_json_with(
4657 app.clone(),
4658 "/v0/sessions/default/operations",
4659 collaboration_paste_operation("1", "op-stale", "idem-stale"),
4660 )
4661 .await;
4662 let result: RuntimeCollaborationOperationResult =
4663 serde_json::from_value(stale).expect("stale result should parse");
4664 validate_runtime_collaboration_operation_result(&result)
4665 .expect("stale result should validate");
4666
4667 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rebased);
4668 assert_eq!(
4669 result.rebase.as_ref().map(|rebase| rebase.strategy),
4670 Some(RuntimeCollaborationRebaseStrategy::CrdtMerge)
4671 );
4672 let transformed_payload = result
4673 .rebase
4674 .as_ref()
4675 .and_then(|rebase| rebase.transformed_payload.as_ref())
4676 .expect("stale paste should expose transformed payload");
4677 let transformed_payload_json = serde_json::to_value(transformed_payload)
4678 .expect("transformed payload should serialize");
4679 assert_eq!(transformed_payload_json["kind"], "pasteGraphFragment");
4680 assert_eq!(
4681 transformed_payload_json["request"]["target"]["baseRevision"],
4682 "2"
4683 );
4684 assert_eq!(
4685 result.ack.as_ref().map(|ack| ack.revision.as_str()),
4686 Some("3")
4687 );
4688 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4689 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "3");
4690 }
4691
4692 #[tokio::test]
4693 async fn collaboration_operation_batches_report_mixed_accept_and_rebase_results() {
4694 let app = runtime_router();
4695 post_json_with(
4696 app.clone(),
4697 "/v0/sessions/default/load",
4698 sample_project_document_current(),
4699 )
4700 .await;
4701
4702 let response = post_json_with(
4703 app.clone(),
4704 "/v0/sessions/default/operations",
4705 json!({
4706 "schema": "skenion.runtime.collaboration.operation-batch",
4707 "schemaVersion": "0.1.0",
4708 "sessionId": "default",
4709 "operations": [
4710 collaboration_paste_operation("1", "op-batch-accepted", "idem-batch-accepted"),
4711 collaboration_paste_operation("1", "op-batch-rebased", "idem-batch-rebased")
4712 ],
4713 "submittedAt": "2026-06-22T00:00:00.000Z"
4714 }),
4715 )
4716 .await;
4717 let result: RuntimeCollaborationOperationBatchResult =
4718 serde_json::from_value(response).expect("batch result should parse");
4719 validate_runtime_collaboration_operation_batch_result(&result)
4720 .expect("batch result should validate");
4721
4722 assert_eq!(result.results.len(), 2);
4723 assert_eq!(
4724 result.results[0].status,
4725 RuntimeCollaborationOperationStatus::Accepted
4726 );
4727 assert_eq!(
4728 result.results[1].status,
4729 RuntimeCollaborationOperationStatus::Rebased
4730 );
4731 assert_eq!(
4732 result.results[1]
4733 .ack
4734 .as_ref()
4735 .map(|ack| ack.revision.as_str()),
4736 Some("3")
4737 );
4738 }
4739
4740 #[tokio::test]
4741 async fn collaboration_change_sets_apply_node_view_and_edge_operations() {
4742 let app = runtime_router();
4743 post_json_with(
4744 app.clone(),
4745 "/v0/sessions/default/load",
4746 sample_project_document_current(),
4747 )
4748 .await;
4749
4750 let accepted = post_json_with(
4751 app.clone(),
4752 "/v0/sessions/default/operations",
4753 collaboration_change_set_operation(
4754 "1",
4755 "op-change-add",
4756 "idem-change-add",
4757 "participant-a",
4758 vec![
4759 json!({
4760 "op": "node.add",
4761 "changeId": "change-add-gain",
4762 "node": {
4763 "id": "gain",
4764 "kind": "core.float",
4765 "kindVersion": "0.1.0",
4766 "params": {},
4767 "ports": value_f32_ports_current_json()
4768 },
4769 "view": { "x": 360.0, "y": 140.0 }
4770 }),
4771 json!({
4772 "op": "node.move",
4773 "changeId": "change-move-value",
4774 "nodeId": "value_1",
4775 "from": { "x": 96.0, "y": 96.0 },
4776 "to": { "x": 160.0, "y": 140.0 }
4777 }),
4778 json!({
4779 "op": "edge.connect",
4780 "changeId": "change-connect-value-gain",
4781 "edge": {
4782 "id": "edge-value-gain",
4783 "source": { "nodeId": "value_1", "portId": "value" },
4784 "target": { "nodeId": "gain", "portId": "cold" }
4785 }
4786 }),
4787 json!({
4788 "op": "node.delete",
4789 "changeId": "change-delete-target",
4790 "nodeId": "target_1"
4791 }),
4792 ],
4793 ),
4794 )
4795 .await;
4796 let result: RuntimeCollaborationOperationResult =
4797 serde_json::from_value(accepted).expect("change-set result should parse");
4798 validate_runtime_collaboration_operation_result(&result)
4799 .expect("change-set result should validate");
4800 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Accepted);
4801 assert_eq!(
4802 result.ack.as_ref().map(|ack| ack.revision.as_str()),
4803 Some("2")
4804 );
4805
4806 let snapshot = get_json_with(app.clone(), "/v0/sessions/default").await;
4807 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "2");
4808 assert!(
4809 snapshot["snapshot"]["project"]["graph"]["nodes"]
4810 .as_array()
4811 .unwrap()
4812 .iter()
4813 .any(|node| node["id"] == "gain")
4814 );
4815 assert!(
4816 snapshot["snapshot"]["project"]["graph"]["edges"]
4817 .as_array()
4818 .unwrap()
4819 .iter()
4820 .any(
4821 |edge| edge["target"]["nodeId"] == "gain" && edge["target"]["portId"] == "cold"
4822 )
4823 );
4824 assert_eq!(
4825 snapshot["snapshot"]["project"]["viewState"]["canvas"]["nodes"]["value_1"]["x"],
4826 160.0
4827 );
4828
4829 let stale_move = post_json_with(
4830 app.clone(),
4831 "/v0/sessions/default/operations",
4832 collaboration_change_set_operation(
4833 "1",
4834 "op-change-stale-move",
4835 "idem-change-stale-move",
4836 "participant-a",
4837 vec![json!({
4838 "op": "node.move",
4839 "changeId": "change-stale-move-value",
4840 "nodeId": "value_1",
4841 "from": { "x": 160.0, "y": 140.0 },
4842 "to": { "x": 220.0, "y": 180.0 }
4843 })],
4844 ),
4845 )
4846 .await;
4847 let result: RuntimeCollaborationOperationResult =
4848 serde_json::from_value(stale_move).expect("stale move result should parse");
4849 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rebased);
4850 assert_eq!(
4851 result
4852 .rebase
4853 .as_ref()
4854 .and_then(|rebase| rebase.transformed_payload.as_ref())
4855 .and_then(collaboration_payload_base_revision),
4856 Some("2")
4857 );
4858
4859 let disconnected = post_json_with(
4860 app.clone(),
4861 "/v0/sessions/default/operations",
4862 collaboration_change_set_operation(
4863 "2",
4864 "op-change-disconnect",
4865 "idem-change-disconnect",
4866 "participant-a",
4867 vec![json!({
4868 "op": "edge.disconnect",
4869 "changeId": "change-disconnect-value-gain",
4870 "edgeId": "edge-value-gain"
4871 })],
4872 ),
4873 )
4874 .await;
4875 let result: RuntimeCollaborationOperationResult =
4876 serde_json::from_value(disconnected).expect("disconnect result should parse");
4877 validate_runtime_collaboration_operation_result(&result)
4878 .expect("disconnect result should validate");
4879 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Accepted);
4880
4881 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4882 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "3");
4883 assert!(
4884 snapshot["snapshot"]["project"]["graph"]["edges"]
4885 .as_array()
4886 .unwrap()
4887 .is_empty()
4888 );
4889 }
4890
4891 #[tokio::test]
4892 async fn collaboration_change_sets_resolve_patch_definition_target_revision() {
4893 let app = runtime_router();
4894 post_json_with(
4895 app.clone(),
4896 "/v0/sessions/default/load",
4897 sample_subpatch_project_document_current(),
4898 )
4899 .await;
4900 let root_bump = post_json_with(
4901 app.clone(),
4902 "/v0/sessions/default/operation",
4903 root_render_paste_operation("1"),
4904 )
4905 .await;
4906 assert_eq!(root_bump["ok"], true);
4907
4908 let accepted = post_json_with(
4909 app.clone(),
4910 "/v0/sessions/default/operations",
4911 collaboration_patch_change_set_operation(
4912 "1",
4913 "op-patch-change",
4914 "idem-patch-change",
4915 "participant-a",
4916 vec![json!({
4917 "op": "node.add",
4918 "changeId": "change-add-patch-debug",
4919 "node": render_clear_color_node_current_json("patch_debug_collab")
4920 })],
4921 ),
4922 )
4923 .await;
4924 let result: RuntimeCollaborationOperationResult =
4925 serde_json::from_value(accepted).expect("patch change-set result should parse");
4926 validate_runtime_collaboration_operation_result(&result)
4927 .expect("patch change-set result should validate");
4928 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Accepted);
4929 assert!(result.rebase.is_none());
4930 assert_eq!(
4931 result.ack.as_ref().map(|ack| ack.revision.as_str()),
4932 Some("2")
4933 );
4934
4935 let stale = post_json_with(
4936 app.clone(),
4937 "/v0/sessions/default/operations",
4938 collaboration_patch_change_set_operation(
4939 "1",
4940 "op-patch-stale-change",
4941 "idem-patch-stale-change",
4942 "participant-a",
4943 vec![json!({
4944 "op": "node.add",
4945 "changeId": "change-add-patch-debug-rebased",
4946 "node": render_clear_color_node_current_json("patch_debug_rebased")
4947 })],
4948 ),
4949 )
4950 .await;
4951 let result: RuntimeCollaborationOperationResult =
4952 serde_json::from_value(stale).expect("stale patch change-set result should parse");
4953 validate_runtime_collaboration_operation_result(&result)
4954 .expect("stale patch change-set result should validate");
4955 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rebased);
4956 assert_eq!(
4957 result
4958 .rebase
4959 .as_ref()
4960 .and_then(|rebase| rebase.transformed_payload.as_ref())
4961 .and_then(collaboration_payload_base_revision),
4962 Some("2")
4963 );
4964 assert_eq!(
4965 result.ack.as_ref().map(|ack| ack.revision.as_str()),
4966 Some("3")
4967 );
4968
4969 let snapshot = get_json_with(app, "/v0/sessions/default").await;
4970 assert_eq!(snapshot["snapshot"]["project"]["graph"]["revision"], "2");
4971 assert_eq!(
4972 snapshot["snapshot"]["project"]["patchLibrary"][0]["graph"]["revision"],
4973 "3"
4974 );
4975 let patch_nodes = snapshot["snapshot"]["project"]["patchLibrary"][0]["graph"]["nodes"]
4976 .as_array()
4977 .unwrap();
4978 assert!(
4979 patch_nodes
4980 .iter()
4981 .any(|node| node["id"] == "patch_debug_collab")
4982 );
4983 assert!(
4984 patch_nodes
4985 .iter()
4986 .any(|node| node["id"] == "patch_debug_rebased")
4987 );
4988 }
4989
4990 #[tokio::test]
4991 async fn collaboration_undo_redo_uses_participant_scoped_history() {
4992 let app = runtime_router();
4993 post_json_with(
4994 app.clone(),
4995 "/v0/sessions/default/load",
4996 sample_project_document_current(),
4997 )
4998 .await;
4999 post_json_with(
5000 app.clone(),
5001 "/v0/sessions/default/operations",
5002 collaboration_paste_operation_for("1", "op-a-paste", "idem-a-paste", "participant-a"),
5003 )
5004 .await;
5005 post_json_with(
5006 app.clone(),
5007 "/v0/sessions/default/operations",
5008 collaboration_paste_operation_for("2", "op-b-paste", "idem-b-paste", "participant-b"),
5009 )
5010 .await;
5011
5012 let undone = post_json_with(
5013 app.clone(),
5014 "/v0/sessions/default/operations",
5015 collaboration_undo_redo_operation(
5016 "3",
5017 "op-a-undo",
5018 "idem-a-undo",
5019 "participant-a",
5020 "undo",
5021 ),
5022 )
5023 .await;
5024 let result: RuntimeCollaborationOperationResult =
5025 serde_json::from_value(undone).expect("undo result should parse");
5026 validate_runtime_collaboration_operation_result(&result)
5027 .expect("undo result should validate");
5028 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Accepted);
5029 assert_eq!(
5030 result.ack.as_ref().map(|ack| ack.revision.as_str()),
5031 Some("4")
5032 );
5033
5034 let snapshot = get_json_with(app, "/v0/sessions/default").await;
5035 let nodes = snapshot["snapshot"]["project"]["graph"]["nodes"]
5036 .as_array()
5037 .unwrap();
5038 assert!(!nodes.iter().any(|node| node["id"] == "pasted_target"));
5039 assert!(nodes.iter().any(|node| node["id"] == "pasted_target_2"));
5040
5041 let app = runtime_router();
5042 post_json_with(
5043 app.clone(),
5044 "/v0/sessions/default/load",
5045 sample_project_document_current(),
5046 )
5047 .await;
5048 post_json_with(
5049 app.clone(),
5050 "/v0/sessions/default/operations",
5051 collaboration_paste_operation_for(
5052 "1",
5053 "op-redo-paste",
5054 "idem-redo-paste",
5055 "participant-a",
5056 ),
5057 )
5058 .await;
5059 post_json_with(
5060 app.clone(),
5061 "/v0/sessions/default/operations",
5062 collaboration_undo_redo_operation(
5063 "2",
5064 "op-redo-undo",
5065 "idem-redo-undo",
5066 "participant-a",
5067 "undo",
5068 ),
5069 )
5070 .await;
5071 let redone = post_json_with(
5072 app,
5073 "/v0/sessions/default/operations",
5074 collaboration_undo_redo_operation(
5075 "3",
5076 "op-redo-redo",
5077 "idem-redo-redo",
5078 "participant-a",
5079 "redo",
5080 ),
5081 )
5082 .await;
5083 let result: RuntimeCollaborationOperationResult =
5084 serde_json::from_value(redone).expect("redo result should parse");
5085 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Accepted);
5086 assert_eq!(
5087 result.ack.as_ref().map(|ack| ack.revision.as_str()),
5088 Some("4")
5089 );
5090 }
5091
5092 #[tokio::test]
5093 async fn collaboration_presence_selection_and_stream_routes_publish_events() {
5094 let state = runtime_state_with_dry_preview();
5095 let app = runtime_router_with_state(state.clone());
5096
5097 let presence = post_json_with(
5098 app.clone(),
5099 "/v0/sessions/beta/collaboration/presence",
5100 collaboration_presence("wrong-session", "participant-a"),
5101 )
5102 .await;
5103 assert_eq!(presence["sessionId"], "beta");
5104 assert_eq!(presence["participantId"], "participant-a");
5105
5106 let live_response = app
5107 .clone()
5108 .oneshot(
5109 Request::builder()
5110 .uri("/v0/sessions/default/collaboration/events/stream?after=0")
5111 .body(Body::empty())
5112 .expect("request should build"),
5113 )
5114 .await
5115 .expect("router should respond");
5116 assert_eq!(live_response.status(), StatusCode::OK);
5117 let live_presence = post_json_with(
5118 app.clone(),
5119 "/v0/sessions/default/collaboration/presence",
5120 collaboration_presence("wrong-session", "participant-live"),
5121 )
5122 .await;
5123 assert_eq!(live_presence["sessionId"], "default");
5124 let mut live_stream = live_response.into_body().into_data_stream();
5125 let live_chunk = tokio::time::timeout(Duration::from_secs(1), live_stream.next())
5126 .await
5127 .expect("default collaboration stream should emit")
5128 .expect("default collaboration stream should have a chunk")
5129 .expect("default collaboration stream chunk should be ok");
5130 let live_text =
5131 std::str::from_utf8(&live_chunk).expect("collaboration stream should be utf8");
5132 assert!(live_text.contains("\"participantId\":\"participant-live\""));
5133
5134 let selection = post_json_with(
5135 app.clone(),
5136 "/v0/sessions/beta/collaboration/selection",
5137 collaboration_selection("wrong-session", "participant-a"),
5138 )
5139 .await;
5140 assert_eq!(selection["sessionId"], "beta");
5141
5142 let default_selection = post_json_with(
5143 app.clone(),
5144 "/v0/sessions/default/collaboration/selection",
5145 collaboration_selection("wrong-session", "participant-live"),
5146 )
5147 .await;
5148 assert_eq!(default_selection["sessionId"], "default");
5149
5150 let beta_replay = state
5151 .sessions
5152 .get_or_create("beta")
5153 .collaboration
5154 .capture_replay(Some(0));
5155 assert_eq!(beta_replay.events.len(), 2);
5156 assert_eq!(
5157 beta_replay.events[0].kind,
5158 RuntimeCollaborationEventKind::Presence
5159 );
5160 assert_eq!(
5161 beta_replay.events[1].kind,
5162 RuntimeCollaborationEventKind::Selection
5163 );
5164
5165 let response = app
5166 .clone()
5167 .oneshot(
5168 Request::builder()
5169 .uri("/v0/sessions/beta/collaboration/events/stream?after=0")
5170 .body(Body::empty())
5171 .expect("request should build"),
5172 )
5173 .await
5174 .expect("router should respond");
5175 assert_eq!(response.status(), StatusCode::OK);
5176 assert!(
5177 response
5178 .headers()
5179 .get(CONTENT_TYPE)
5180 .unwrap()
5181 .to_str()
5182 .unwrap()
5183 .starts_with("text/event-stream")
5184 );
5185 let mut stream = response.into_body().into_data_stream();
5186 let chunk = tokio::time::timeout(Duration::from_secs(1), stream.next())
5187 .await
5188 .expect("collaboration event stream should emit")
5189 .expect("collaboration event stream should have a chunk")
5190 .expect("collaboration event stream chunk should be ok");
5191 let text = std::str::from_utf8(&chunk).expect("collaboration stream should be utf8");
5192 assert!(text.contains("event: collaboration"));
5193 assert!(text.contains("\"kind\":\"presence\""));
5194
5195 let header_response = app
5196 .oneshot(
5197 Request::builder()
5198 .uri("/v0/sessions/beta/collaboration/events/stream")
5199 .header("last-event-id", "0")
5200 .body(Body::empty())
5201 .expect("request should build"),
5202 )
5203 .await
5204 .expect("router should respond");
5205 assert_eq!(header_response.status(), StatusCode::OK);
5206 }
5207
5208 #[tokio::test]
5209 async fn collaboration_presence_and_selection_reject_invalid_metadata() {
5210 let app = runtime_router();
5211 let mut invalid_presence = collaboration_presence("default", "participant-invalid");
5212 invalid_presence["expiresAt"] = invalid_presence["updatedAt"].clone();
5213 let (presence_status, presence_body) = post_json_status_with(
5214 app.clone(),
5215 "/v0/sessions/default/collaboration/presence",
5216 invalid_presence,
5217 )
5218 .await;
5219 assert_eq!(presence_status, StatusCode::BAD_REQUEST);
5220 assert_eq!(presence_body["ok"], false);
5221 assert_eq!(
5222 presence_body["diagnostics"][0]["code"],
5223 "collaboration.invalid-presence"
5224 );
5225
5226 let mut invalid_selection = collaboration_selection("default", "participant-invalid");
5227 invalid_selection["expiresAt"] = invalid_selection["updatedAt"].clone();
5228 let (selection_status, selection_body) = post_json_status_with(
5229 app,
5230 "/v0/sessions/default/collaboration/selection",
5231 invalid_selection,
5232 )
5233 .await;
5234 assert_eq!(selection_status, StatusCode::BAD_REQUEST);
5235 assert_eq!(selection_body["ok"], false);
5236 assert_eq!(
5237 selection_body["diagnostics"][0]["code"],
5238 "collaboration.invalid-selection"
5239 );
5240 }
5241
5242 #[tokio::test]
5243 async fn collaboration_operations_report_structured_invalid_inputs() {
5244 let app = runtime_router();
5245
5246 let invalid_runtime_operation = post_json_with(
5247 app.clone(),
5248 "/v0/sessions/default/operations",
5249 json!({
5250 "schema": "skenion.runtime.operation",
5251 "schemaVersion": "0.1.0",
5252 "kind": "pasteGraphFragment"
5253 }),
5254 )
5255 .await;
5256 assert_eq!(invalid_runtime_operation["ok"], false);
5257 assert_eq!(
5258 invalid_runtime_operation["diagnostics"][0]["code"],
5259 "paste.operation.invalid-json"
5260 );
5261
5262 let invalid_batch = post_json_with(
5263 app.clone(),
5264 "/v0/sessions/default/operations",
5265 json!({
5266 "schema": "skenion.runtime.collaboration.operation-batch",
5267 "schemaVersion": "0.1.0",
5268 "sessionId": "default"
5269 }),
5270 )
5271 .await;
5272 let batch: RuntimeCollaborationOperationBatchResult =
5273 serde_json::from_value(invalid_batch).expect("invalid batch result should parse");
5274 validate_runtime_collaboration_operation_batch_result(&batch)
5275 .expect("invalid batch result should validate");
5276 assert_eq!(
5277 batch.results[0].status,
5278 RuntimeCollaborationOperationStatus::Rejected
5279 );
5280
5281 let duplicate_batch = post_json_with(
5282 app.clone(),
5283 "/v0/sessions/default/operations",
5284 json!({
5285 "schema": "skenion.runtime.collaboration.operation-batch",
5286 "schemaVersion": "0.1.0",
5287 "sessionId": "default",
5288 "operations": [
5289 collaboration_undo_redo_operation("0", "op-dup-a", "same-idem", "participant-a", "undo"),
5290 collaboration_undo_redo_operation("0", "op-dup-b", "same-idem", "participant-a", "undo")
5291 ],
5292 "submittedAt": "2026-06-22T00:00:00.000Z"
5293 }),
5294 )
5295 .await;
5296 let batch: RuntimeCollaborationOperationBatchResult =
5297 serde_json::from_value(duplicate_batch).expect("duplicate batch result should parse");
5298 assert_eq!(batch.results[0].operation_id, "invalid-batch");
5299
5300 let invalid_single = post_json_with(
5301 app.clone(),
5302 "/v0/sessions/default/operations",
5303 json!({ "schema": "not-a-runtime-collaboration-operation" }),
5304 )
5305 .await;
5306 let result: RuntimeCollaborationOperationResult =
5307 serde_json::from_value(invalid_single).expect("invalid single result should parse");
5308 validate_runtime_collaboration_operation_result(&result)
5309 .expect("invalid single result should validate");
5310 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rejected);
5311
5312 let session_mismatch_batch = post_json_with(
5313 app.clone(),
5314 "/v0/sessions/default/operations",
5315 json!({
5316 "schema": "skenion.runtime.collaboration.operation-batch",
5317 "schemaVersion": "0.1.0",
5318 "sessionId": "other",
5319 "operations": [],
5320 "submittedAt": "2026-06-22T00:00:00.000Z"
5321 }),
5322 )
5323 .await;
5324 let batch: RuntimeCollaborationOperationBatchResult =
5325 serde_json::from_value(session_mismatch_batch)
5326 .expect("session mismatch batch result should parse");
5327 assert_eq!(batch.results[0].operation_id, "invalid-batch");
5328
5329 let mut invalid_operation =
5330 collaboration_paste_operation("1", "op-invalid", "idem-invalid");
5331 invalid_operation["schemaVersion"] = json!("bogus");
5332 let invalid_operation = post_json_with(
5333 app.clone(),
5334 "/v0/sessions/default/operations",
5335 invalid_operation,
5336 )
5337 .await;
5338 let result: RuntimeCollaborationOperationResult = serde_json::from_value(invalid_operation)
5339 .expect("invalid operation result should parse");
5340 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rejected);
5341
5342 let mut mismatch = collaboration_paste_operation("1", "op-mismatch", "idem-mismatch");
5343 mismatch["sessionId"] = json!("other");
5344 let mismatch =
5345 post_json_with(app.clone(), "/v0/sessions/default/operations", mismatch).await;
5346 let result: RuntimeCollaborationOperationResult =
5347 serde_json::from_value(mismatch).expect("mismatch result should parse");
5348 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rejected);
5349
5350 post_json_with(
5351 app.clone(),
5352 "/v0/sessions/gamma/load",
5353 sample_project_document_current(),
5354 )
5355 .await;
5356 let mut by_id_operation =
5357 collaboration_paste_operation_for("1", "op-by-id", "idem-by-id", "participant-a");
5358 by_id_operation["sessionId"] = json!("gamma");
5359 let by_id = post_json_with(app, "/v0/sessions/gamma/operations", by_id_operation).await;
5360 let result: RuntimeCollaborationOperationResult =
5361 serde_json::from_value(by_id).expect("by-id result should parse");
5362 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Accepted);
5363 }
5364
5365 #[tokio::test]
5366 async fn collaboration_change_set_and_undo_failures_are_nacked() {
5367 let app = runtime_router();
5368
5369 let no_project = post_json_with(
5370 app.clone(),
5371 "/v0/sessions/default/operations",
5372 collaboration_change_set_operation(
5373 "0",
5374 "op-no-project-change",
5375 "idem-no-project-change",
5376 "participant-a",
5377 vec![json!({
5378 "op": "node.add",
5379 "changeId": "change-add-without-project",
5380 "node": {
5381 "id": "gain",
5382 "kind": "core.float",
5383 "kindVersion": "0.1.0",
5384 "params": {},
5385 "ports": value_f32_ports_current_json()
5386 }
5387 })],
5388 ),
5389 )
5390 .await;
5391 let result: RuntimeCollaborationOperationResult =
5392 serde_json::from_value(no_project).expect("no-project result should parse");
5393 validate_runtime_collaboration_operation_result(&result)
5394 .expect("no-project result should validate");
5395 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rejected);
5396 assert_eq!(
5397 result.nack.as_ref().map(|nack| nack.reason.clone()),
5398 Some(RuntimeCollaborationNackReason::InvalidOperation)
5399 );
5400
5401 let no_project_paste = post_json_with(
5402 app.clone(),
5403 "/v0/sessions/default/operations",
5404 collaboration_paste_operation("0", "op-no-project-paste", "idem-no-project-paste"),
5405 )
5406 .await;
5407 let result: RuntimeCollaborationOperationResult =
5408 serde_json::from_value(no_project_paste).expect("no-project paste result should parse");
5409 validate_runtime_collaboration_operation_result(&result)
5410 .expect("no-project paste result should validate");
5411 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rejected);
5412 assert!(result.ack.is_none());
5413 assert!(
5414 result
5415 .nack
5416 .as_ref()
5417 .and_then(|nack| nack.diagnostics.as_ref())
5418 .unwrap()[0]
5419 .code
5420 .contains("paste.target.no-project")
5421 );
5422
5423 post_json_with(
5424 app.clone(),
5425 "/v0/sessions/default/load",
5426 sample_project_document_current(),
5427 )
5428 .await;
5429 let unknown_edge = post_json_with(
5430 app.clone(),
5431 "/v0/sessions/default/operations",
5432 collaboration_change_set_operation(
5433 "1",
5434 "op-unknown-edge",
5435 "idem-unknown-edge",
5436 "participant-a",
5437 vec![json!({
5438 "op": "edge.disconnect",
5439 "changeId": "change-disconnect-missing",
5440 "edgeId": "missing-edge-id"
5441 })],
5442 ),
5443 )
5444 .await;
5445 let result: RuntimeCollaborationOperationResult =
5446 serde_json::from_value(unknown_edge).expect("unknown-edge result should parse");
5447 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rejected);
5448 assert!(
5449 result
5450 .nack
5451 .as_ref()
5452 .and_then(|nack| nack.diagnostics.as_ref())
5453 .unwrap()[0]
5454 .message
5455 .contains("cannot resolve edge id")
5456 );
5457
5458 let empty_undo = post_json_with(
5459 app.clone(),
5460 "/v0/sessions/default/operations",
5461 collaboration_undo_redo_operation(
5462 "1",
5463 "op-empty-undo",
5464 "idem-empty-undo",
5465 "participant-a",
5466 "undo",
5467 ),
5468 )
5469 .await;
5470 let result: RuntimeCollaborationOperationResult =
5471 serde_json::from_value(empty_undo).expect("empty undo result should parse");
5472 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rejected);
5473
5474 let empty_redo = post_json_with(
5475 app,
5476 "/v0/sessions/default/operations",
5477 collaboration_undo_redo_operation(
5478 "1",
5479 "op-empty-redo",
5480 "idem-empty-redo",
5481 "participant-a",
5482 "redo",
5483 ),
5484 )
5485 .await;
5486 let result: RuntimeCollaborationOperationResult =
5487 serde_json::from_value(empty_redo).expect("empty redo result should parse");
5488 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rejected);
5489 }
5490
5491 #[test]
5492 fn collaboration_private_helpers_cover_direct_branch_shapes() {
5493 let state = RuntimeServerState::default();
5494 let record = state.sessions.default_record();
5495 let operation: RuntimeCollaborationOperationEnvelope =
5496 serde_json::from_value(collaboration_undo_redo_operation(
5497 "1",
5498 "op-helper",
5499 "idem-helper",
5500 "participant-a",
5501 "undo",
5502 ))
5503 .expect("operation should parse");
5504
5505 let response = {
5506 let mut session = record
5507 .session
5508 .write()
5509 .expect("runtime session lock should not be poisoned");
5510 assert!(
5511 session
5512 .load_project_current(sample_project_request_current())
5513 .ok
5514 );
5515 session.apply_mutation(RuntimeMutationRequest {
5516 graph_patch: None,
5517 view_patch: Some(RuntimeViewPatch {
5518 base_view_revision: 1,
5519 ops: vec![RuntimeViewPatchOperation::MoveNodeView {
5520 node_id: "value_1".to_owned(),
5521 from: None,
5522 to: CanvasNodeView {
5523 x: 120.0,
5524 y: 120.0,
5525 width: None,
5526 height: None,
5527 collapsed: None,
5528 },
5529 }],
5530 }),
5531 actor_id: Some("participant-a".to_owned()),
5532 client_id: Some("studio-test".to_owned()),
5533 description: Some("view-only helper mutation".to_owned()),
5534 })
5535 };
5536 let rebase = collaboration_rebase(
5537 &record,
5538 &operation,
5539 "2".to_owned(),
5540 RuntimeCollaborationRebaseStrategy::CrdtMerge,
5541 None,
5542 Vec::new(),
5543 );
5544 let result = collaboration_result_from_patch_response(
5545 &record,
5546 operation.clone(),
5547 response,
5548 record.collaboration.reserve_sequence(),
5549 Some(rebase),
5550 None,
5551 Some(operation.payload.clone()),
5552 );
5553 assert_eq!(result.status, RuntimeCollaborationOperationStatus::Rebased);
5554 assert!(result.rebase.unwrap().transformed_payload.is_some());
5555
5556 let warning = collaboration_diagnostic_from_runtime_diagnostic(
5557 &RuntimeDiagnostic {
5558 severity: DiagnosticSeverity::Warning,
5559 message: "warning".to_owned(),
5560 code: None,
5561 details: None,
5562 },
5563 "op-helper",
5564 "participant-a",
5565 "idem-helper",
5566 );
5567 assert_eq!(warning.severity, "warning");
5568 assert_eq!(warning.code, "runtime.patch");
5569
5570 let info = collaboration_diagnostic_from_runtime_diagnostic(
5571 &RuntimeDiagnostic {
5572 severity: DiagnosticSeverity::Info,
5573 message: "info".to_owned(),
5574 code: Some("custom.info".to_owned()),
5575 details: None,
5576 },
5577 "op-helper",
5578 "participant-a",
5579 "idem-helper",
5580 );
5581 assert_eq!(info.severity, "info");
5582 assert_eq!(info.code, "custom.info");
5583 }
5584
5585 #[tokio::test]
5586 async fn session_mutate_endpoint_reports_errors_without_loaded_session() {
5587 let response = post_json(
5588 "/v0/sessions/default/mutate",
5589 graph_mutation(set_value_patch("1")),
5590 )
5591 .await;
5592
5593 assert_eq!(response["ok"], false);
5594 assert_eq!(response["applied"], false);
5595 assert_eq!(response["conflict"], false);
5596 assert_eq!(response["snapshot"]["project"], Value::Null);
5597 assert_eq!(response["history"]["entries"].as_array().unwrap().len(), 0);
5598 assert!(
5599 response["diagnostics"][0]["message"]
5600 .as_str()
5601 .unwrap()
5602 .contains("no project loaded")
5603 );
5604 }
5605
5606 #[tokio::test]
5607 async fn session_mutate_endpoint_rejects_graph_patch_mutations() {
5608 let app = runtime_router();
5609 post_json_with(
5610 app.clone(),
5611 "/v0/sessions/default/load",
5612 sample_project_document_current(),
5613 )
5614 .await;
5615
5616 let response = post_json_with(
5617 app,
5618 "/v0/sessions/default/mutate",
5619 graph_mutation(set_value_patch("1")),
5620 )
5621 .await;
5622
5623 assert_eq!(response["ok"], false);
5624 assert_eq!(response["applied"], false);
5625 assert_eq!(response["conflict"], false);
5626 assert_eq!(response["snapshot"]["project"]["graph"]["revision"], "1");
5627 assert_eq!(response["history"]["entries"].as_array().unwrap().len(), 0);
5628 assert_eq!(
5629 response["diagnostics"][0]["code"],
5630 "project.graph-patch-unsupported"
5631 );
5632 }
5633
5634 #[tokio::test]
5635 async fn session_load_and_addressed_mutate_cover_decode_and_event_branches() {
5636 let state = runtime_state_with_dry_preview();
5637 let app = runtime_router_with_state(state.clone());
5638
5639 let bad_load = post_json_with(
5640 app.clone(),
5641 "/v0/sessions/default/load",
5642 json!({ "graph": { "schemaVersion": "0.1.0" } }),
5643 )
5644 .await;
5645 assert_eq!(bad_load["ok"], false);
5646 assert!(
5647 bad_load["diagnostics"][0]["message"]
5648 .as_str()
5649 .unwrap()
5650 .contains("invalid project request")
5651 );
5652
5653 let bad_mutation = post_json_with(
5654 app.clone(),
5655 "/v0/sessions/gamma/mutate",
5656 json!({ "viewPatch": { "baseViewRevision": "wrong", "ops": [] } }),
5657 )
5658 .await;
5659 assert_eq!(bad_mutation["ok"], false);
5660 assert!(
5661 bad_mutation["diagnostics"][0]["message"]
5662 .as_str()
5663 .unwrap()
5664 .contains("invalid runtime mutation")
5665 );
5666
5667 post_json_with(
5668 app.clone(),
5669 "/v0/sessions/gamma/load",
5670 sample_project_document_current(),
5671 )
5672 .await;
5673 let moved = post_json_with(
5674 app.clone(),
5675 "/v0/sessions/gamma/mutate",
5676 json!({
5677 "viewPatch": {
5678 "baseViewRevision": 1,
5679 "ops": [
5680 {
5681 "op": "moveNodeView",
5682 "nodeId": "value_1",
5683 "to": { "x": 128.0, "y": 64.0 }
5684 }
5685 ]
5686 },
5687 "clientId": "studio-test",
5688 "description": "move through addressed route"
5689 }),
5690 )
5691 .await;
5692 assert_eq!(moved["ok"], true);
5693 assert_eq!(moved["applied"], true);
5694 assert_eq!(
5695 moved["snapshot"]["project"]["viewState"]["canvas"]["nodes"]["value_1"]["x"],
5696 128.0
5697 );
5698
5699 let gamma = state.sessions.get_or_create("gamma");
5700 let events = gamma
5701 .event_store
5702 .lock()
5703 .expect("event store should not be poisoned")
5704 .clone();
5705 assert!(
5706 events
5707 .iter()
5708 .any(|event| event.kind == RuntimeSessionEventKind::Mutate)
5709 );
5710 }
5711
5712 #[test]
5713 fn registry_from_nodes_reports_duplicate_definitions() {
5714 let nodes: Vec<NodeDefinition> = serde_json::from_value(sample_project()["nodes"].clone())
5715 .expect("sample project nodes should parse");
5716 let duplicate_nodes = vec![nodes[0].clone(), nodes[0].clone()];
5717
5718 let diagnostics =
5719 registry_from_nodes(duplicate_nodes).expect_err("duplicate definitions should fail");
5720
5721 assert!(diagnostics[0].message.contains("duplicate node definition"));
5722 }
5723
5724 #[tokio::test]
5725 async fn session_history_endpoint_returns_empty_and_event_history() {
5726 let app = runtime_router();
5727
5728 let empty = get_json_with(app.clone(), "/v0/sessions/default/history").await;
5729 assert_eq!(empty["schema"], "skenion.runtime.history");
5730 assert_eq!(empty["entries"].as_array().unwrap().len(), 0);
5731 assert_eq!(empty["canUndo"], false);
5732 assert_eq!(empty["canRedo"], false);
5733
5734 post_json_with(
5735 app.clone(),
5736 "/v0/sessions/default/load",
5737 sample_project_document_current(),
5738 )
5739 .await;
5740 post_json_with(
5741 app.clone(),
5742 "/v0/sessions/default/operation",
5743 paste_operation("1"),
5744 )
5745 .await;
5746 let history = get_json_with(app, "/v0/sessions/default/history").await;
5747
5748 assert_eq!(history["entries"].as_array().unwrap().len(), 1);
5749 assert_eq!(history["entries"][0]["kind"], "apply");
5750 assert_eq!(history["undoDepth"], 1);
5751 assert_eq!(history["redoDepth"], 0);
5752 }
5753
5754 #[tokio::test]
5755 async fn session_undo_and_redo_endpoints_update_graph_and_history() {
5756 let app = runtime_router();
5757 post_json_with(
5758 app.clone(),
5759 "/v0/sessions/default/load",
5760 sample_project_document_current(),
5761 )
5762 .await;
5763 post_json_with(
5764 app.clone(),
5765 "/v0/sessions/default/operation",
5766 paste_operation("1"),
5767 )
5768 .await;
5769
5770 let undo = post_empty_with(app.clone(), "/v0/sessions/default/undo").await;
5771 assert_eq!(undo["ok"], true);
5772 assert_eq!(undo["applied"], true);
5773 assert_eq!(undo["history"]["entries"][1]["kind"], "undo");
5774 assert_eq!(undo["snapshot"]["project"]["graph"]["revision"], "3");
5775 assert_eq!(undo["history"]["entries"].as_array().unwrap().len(), 2);
5776 assert_eq!(undo["history"]["undoDepth"], 0);
5777 assert_eq!(undo["history"]["redoDepth"], 1);
5778
5779 let redo = post_empty_with(app, "/v0/sessions/default/redo").await;
5780 assert_eq!(redo["ok"], true);
5781 assert_eq!(redo["applied"], true);
5782 assert_eq!(redo["history"]["entries"][2]["kind"], "redo");
5783 assert_eq!(redo["snapshot"]["project"]["graph"]["revision"], "4");
5784 assert_eq!(redo["history"]["entries"].as_array().unwrap().len(), 3);
5785 assert_eq!(redo["history"]["undoDepth"], 1);
5786 assert_eq!(redo["history"]["redoDepth"], 0);
5787 }
5788
5789 #[tokio::test]
5790 async fn session_undo_and_redo_endpoints_report_empty_history() {
5791 let app = runtime_router();
5792
5793 let undo = post_empty_with(app.clone(), "/v0/sessions/default/undo").await;
5794 let redo = post_empty_with(app, "/v0/sessions/default/redo").await;
5795
5796 assert_eq!(undo["ok"], false);
5797 assert_eq!(undo["applied"], false);
5798 assert!(
5799 undo["diagnostics"][0]["message"]
5800 .as_str()
5801 .unwrap()
5802 .contains("available to undo")
5803 );
5804 assert_eq!(redo["ok"], false);
5805 assert_eq!(redo["applied"], false);
5806 assert!(
5807 redo["diagnostics"][0]["message"]
5808 .as_str()
5809 .unwrap()
5810 .contains("available to redo")
5811 );
5812 }
5813
5814 #[tokio::test]
5815 async fn session_control_event_and_state_endpoints_follow_value_semantics() {
5816 let app = runtime_router();
5817 post_json_with(
5818 app.clone(),
5819 "/v0/sessions/default/load",
5820 sample_project_document_current(),
5821 )
5822 .await;
5823
5824 let set = post_json_with(
5825 app.clone(),
5826 "/v0/sessions/default/control/event",
5827 json!({
5828 "nodeId": "value_1",
5829 "portId": "in",
5830 "message": { "selector": "set", "atoms": [{ "type": "float", "representation": "f32", "value": 32.0 }] }
5831 }),
5832 )
5833 .await;
5834 assert_eq!(set["ok"], true);
5835 assert_eq!(set["emitted"], json!([]));
5836
5837 let bang = post_json_with(
5838 app.clone(),
5839 "/v0/sessions/default/control/event",
5840 json!({ "nodeId": "value_1", "portId": "in", "message": { "selector": "bang", "atoms": [] } }),
5841 )
5842 .await;
5843 assert_eq!(bang["ok"], true);
5844 assert_eq!(
5845 bang["emitted"],
5846 json!([
5847 { "nodeId": "value_1", "portId": "value", "message": { "selector": "float", "atoms": [{ "type": "float", "representation": "f32", "value": 32.0 }] } }
5848 ])
5849 );
5850
5851 let input = post_json_with(
5852 app.clone(),
5853 "/v0/sessions/default/control/event",
5854 json!({
5855 "nodeId": "value_1",
5856 "portId": "in",
5857 "message": { "selector": "float", "atoms": [{ "type": "float", "representation": "f32", "value": 12.0 }] }
5858 }),
5859 )
5860 .await;
5861 assert_eq!(input["ok"], true);
5862 assert_eq!(
5863 input["emitted"],
5864 json!([
5865 { "nodeId": "value_1", "portId": "value", "message": { "selector": "float", "atoms": [{ "type": "float", "representation": "f32", "value": 12.0 }] } }
5866 ])
5867 );
5868
5869 let state = get_json_with(app.clone(), "/v0/sessions/default/control/state").await;
5870 assert_eq!(state["ok"], true);
5871 assert_eq!(
5872 state["values"]["value_1"],
5873 json!({ "type": "float", "representation": "f32", "value": 12.0 })
5874 );
5875
5876 let state_read = post_json_with(
5877 app.clone(),
5878 "/v0/sessions/default/control/read",
5879 json!({ "nodeId": "value_1", "target": "state", "id": "value" }),
5880 )
5881 .await;
5882 assert_eq!(state_read["ok"], true);
5883 assert_eq!(
5884 state_read["value"],
5885 json!({ "type": "float", "representation": "f32", "value": 12.0 })
5886 );
5887
5888 let port_read = post_json_with(
5889 app.clone(),
5890 "/v0/sessions/default/control/read",
5891 json!({ "nodeId": "value_1", "target": "port", "id": "value" }),
5892 )
5893 .await;
5894 assert_eq!(port_read["ok"], true);
5895 assert_eq!(port_read["value"]["value"]["id"], json!("value"));
5896
5897 let wrong_type = post_json_with(
5898 app,
5899 "/v0/sessions/default/control/event",
5900 json!({
5901 "nodeId": "value_1",
5902 "portId": "in",
5903 "message": { "selector": "bool", "atoms": [{ "type": "bool", "value": true }] }
5904 }),
5905 )
5906 .await;
5907 assert_eq!(wrong_type["ok"], false);
5908 assert_eq!(wrong_type["emitted"], json!([]));
5909 assert!(
5910 wrong_type["diagnostics"][0]["message"]
5911 .as_str()
5912 .unwrap()
5913 .contains("expects number.float")
5914 );
5915 }
5916
5917 #[tokio::test]
5918 async fn session_control_event_reports_running_preview_snapshot_update_warnings() {
5919 let state = runtime_state_with_dry_preview();
5920 let app = runtime_router_with_state(state.clone());
5921 post_json_with(
5922 app.clone(),
5923 "/v0/sessions/default/load",
5924 sample_project_document_current(),
5925 )
5926 .await;
5927 post_empty_with(app.clone(), "/v0/sessions/default/preview/start").await;
5928 let blocker = std::env::temp_dir().join(format!(
5929 "skenion-preview-control-update-blocker-{}-{}",
5930 std::process::id(),
5931 std::time::SystemTime::now()
5932 .duration_since(std::time::UNIX_EPOCH)
5933 .unwrap()
5934 .as_nanos()
5935 ));
5936 std::fs::write(&blocker, b"blocker").expect("blocker should write");
5937 state
5938 .sessions
5939 .default_record()
5940 .preview
5941 .lock()
5942 .expect("preview lock should not be poisoned")
5943 .set_control_state_path_for_test(blocker.join("control-state.json"));
5944
5945 let response = post_json_with(
5946 app,
5947 "/v0/sessions/default/control/event",
5948 json!({
5949 "nodeId": "value_1",
5950 "portId": "in",
5951 "message": { "selector": "set", "atoms": [{ "type": "float", "representation": "f32", "value": 2.0 }] }
5952 }),
5953 )
5954 .await;
5955
5956 assert_eq!(response["ok"], true);
5957 assert_eq!(response["changed"], true);
5958 assert!(
5959 response["diagnostics"][0]["message"]
5960 .as_str()
5961 .unwrap()
5962 .contains("failed to update running preview control state")
5963 );
5964 std::fs::remove_file(blocker).expect("blocker should remove");
5965 }
5966
5967 #[tokio::test]
5968 async fn session_control_endpoints_report_missing_session() {
5969 let app = runtime_router();
5970
5971 let event = post_json_with(
5972 app.clone(),
5973 "/v0/sessions/default/control/event",
5974 json!({
5975 "nodeId": "value_1",
5976 "portId": "in",
5977 "message": { "selector": "set", "atoms": [{ "type": "float", "representation": "f32", "value": 1.0 }] }
5978 }),
5979 )
5980 .await;
5981 let state = get_json_with(app, "/v0/sessions/default/control/state").await;
5982 let read = post_json_with(
5983 runtime_router(),
5984 "/v0/sessions/default/control/read",
5985 json!({ "nodeId": "value_1", "target": "state", "id": "value" }),
5986 )
5987 .await;
5988
5989 assert_eq!(event["ok"], false);
5990 assert_eq!(event["emitted"], json!([]));
5991 assert!(
5992 event["diagnostics"][0]["message"]
5993 .as_str()
5994 .unwrap()
5995 .contains("no project loaded")
5996 );
5997 assert_eq!(state["ok"], false);
5998 assert_eq!(state["values"], json!({}));
5999 assert_eq!(read["ok"], false);
6000 assert!(
6001 read["diagnostics"][0]["message"]
6002 .as_str()
6003 .unwrap()
6004 .contains("no project loaded")
6005 );
6006 }
6007
6008 #[tokio::test]
6009 async fn session_run_fails_without_loaded_project() {
6010 let response = post_json("/v0/sessions/default/run", json!({ "frames": 2 })).await;
6011
6012 assert_eq!(response["ok"], false);
6013 assert_eq!(response["snapshot"]["project"], Value::Null);
6014 assert!(
6015 response["diagnostics"][0]["message"]
6016 .as_str()
6017 .unwrap()
6018 .contains("no project loaded in runtime session")
6019 );
6020 }
6021
6022 #[tokio::test]
6023 async fn session_clear_removes_loaded_project() {
6024 let app = runtime_router();
6025 post_json_with(
6026 app.clone(),
6027 "/v0/sessions/default/load",
6028 sample_project_document_current(),
6029 )
6030 .await;
6031
6032 let response = delete_json_with(app, "/v0/sessions/default").await;
6033
6034 assert_eq!(response["ok"], true);
6035 assert_eq!(response["snapshot"]["project"], Value::Null);
6036 assert_eq!(response["snapshot"]["sessionRevision"], 2);
6037 assert_eq!(response["snapshot"]["plan"], Value::Null);
6038 }
6039
6040 #[tokio::test]
6041 async fn preview_status_reports_stopped_without_loaded_session() {
6042 let response = get_json_with(
6043 runtime_router_with_dry_preview(),
6044 "/v0/sessions/default/preview",
6045 )
6046 .await;
6047
6048 assert_eq!(response["ok"], true);
6049 assert_eq!(response["state"], "stopped");
6050 assert_eq!(response["sessionRevision"], Value::Null);
6051 assert_eq!(response["previewSessionRevision"], Value::Null);
6052 assert_eq!(response["stale"], false);
6053 }
6054
6055 #[tokio::test]
6056 async fn preview_start_requires_loaded_session() {
6057 let response = post_json_with(
6058 runtime_router_with_dry_preview(),
6059 "/v0/sessions/default/preview/start",
6060 json!({}),
6061 )
6062 .await;
6063
6064 assert_eq!(response["ok"], false);
6065 assert_eq!(response["state"], "stopped");
6066 assert!(
6067 response["diagnostics"][0]["message"]
6068 .as_str()
6069 .unwrap()
6070 .contains("no project loaded")
6071 );
6072 }
6073
6074 #[tokio::test]
6075 async fn preview_start_stop_and_restart_use_session_plan() {
6076 let app = runtime_router_with_dry_preview();
6077 post_json_with(
6078 app.clone(),
6079 "/v0/sessions/default/load",
6080 sample_project_document_current(),
6081 )
6082 .await;
6083
6084 let started = post_empty_with(app.clone(), "/v0/sessions/default/preview/start").await;
6085 assert_eq!(started["ok"], true);
6086 assert_eq!(started["state"], "running");
6087 assert_eq!(started["graphId"], "minimal-value");
6088 assert_eq!(started["graphRevision"], "1");
6089 assert_eq!(started["sessionRevision"], 1);
6090 assert_eq!(started["previewSessionRevision"], 1);
6091 assert_eq!(started["stale"], false);
6092
6093 let stopped = post_empty_with(app.clone(), "/v0/sessions/default/preview/stop").await;
6094 assert_eq!(stopped["ok"], true);
6095 assert_eq!(stopped["state"], "stopped");
6096 assert_eq!(stopped["graphId"], Value::Null);
6097
6098 let restarted = post_empty_with(app, "/v0/sessions/default/preview/restart").await;
6099 assert_eq!(restarted["ok"], true);
6100 assert_eq!(restarted["state"], "running");
6101 assert_eq!(restarted["previewSessionRevision"], 1);
6102 }
6103
6104 #[tokio::test]
6105 async fn preview_start_request_restart_replaces_existing_preview() {
6106 let app = runtime_router_with_dry_preview();
6107 post_json_with(
6108 app.clone(),
6109 "/v0/sessions/default/load",
6110 sample_project_document_current(),
6111 )
6112 .await;
6113 post_empty_with(app.clone(), "/v0/sessions/default/preview/start").await;
6114 post_json_with(
6115 app.clone(),
6116 "/v0/sessions/default/operation",
6117 paste_operation("1"),
6118 )
6119 .await;
6120
6121 let stale = get_json_with(app.clone(), "/v0/sessions/default/preview").await;
6122 assert_eq!(stale["state"], "running");
6123 assert_eq!(stale["graphRevision"], "1");
6124 assert_eq!(stale["sessionRevision"], 2);
6125 assert_eq!(stale["previewSessionRevision"], 1);
6126 assert_eq!(stale["stale"], true);
6127
6128 let restarted = post_json_with(
6129 app,
6130 "/v0/sessions/default/preview/start",
6131 json!({ "restart": true }),
6132 )
6133 .await;
6134 assert_eq!(restarted["ok"], true);
6135 assert_eq!(restarted["graphRevision"], "2");
6136 assert_eq!(restarted["previewSessionRevision"], 2);
6137 assert_eq!(restarted["stale"], false);
6138 }
6139
6140 #[tokio::test]
6141 async fn preview_start_rejects_invalid_request_json() {
6142 let app = runtime_router_with_dry_preview();
6143 post_json_with(
6144 app.clone(),
6145 "/v0/sessions/default/load",
6146 sample_project_document_current(),
6147 )
6148 .await;
6149
6150 let response =
6151 post_raw_with(app, "/v0/sessions/default/preview/start", b"{".to_vec()).await;
6152
6153 assert_eq!(response["ok"], false);
6154 assert_eq!(response["state"], "stopped");
6155 assert!(
6156 response["diagnostics"][0]["message"]
6157 .as_str()
6158 .unwrap()
6159 .contains("invalid preview start request")
6160 );
6161 }
6162
6163 #[tokio::test]
6164 async fn session_clear_stops_preview() {
6165 let app = runtime_router_with_dry_preview();
6166 post_json_with(
6167 app.clone(),
6168 "/v0/sessions/default/load",
6169 sample_project_document_current(),
6170 )
6171 .await;
6172 post_empty_with(app.clone(), "/v0/sessions/default/preview/start").await;
6173
6174 let cleared = delete_json_with(app.clone(), "/v0/sessions/default").await;
6175 assert_eq!(cleared["ok"], true);
6176
6177 let preview = get_json_with(app, "/v0/sessions/default/preview").await;
6178 assert_eq!(preview["state"], "stopped");
6179 assert_eq!(preview["sessionRevision"], Value::Null);
6180 assert_eq!(preview["stale"], false);
6181 }
6182
6183 #[tokio::test]
6184 async fn telemetry_endpoint_reports_empty_session() {
6185 let response = get_json_with(
6186 runtime_router_with_dry_preview(),
6187 "/v0/sessions/default/telemetry",
6188 )
6189 .await;
6190
6191 assert_eq!(response["schema"], "skenion.runtime.telemetry");
6192 assert_eq!(response["schemaVersion"], "0.1.0");
6193 assert_eq!(response["ok"], true);
6194 assert_eq!(response["session"]["project"], Value::Null);
6195 assert_eq!(response["preview"]["state"], "stopped");
6196 assert_eq!(response["render"]["active"], false);
6197 assert_eq!(response["render"]["diagnostics"], json!([]));
6198 assert_eq!(response["render"]["generatedSourceAvailable"], false);
6199 assert_eq!(
6200 response["process"]["runtimeVersion"],
6201 env!("CARGO_PKG_VERSION")
6202 );
6203 }
6204
6205 #[tokio::test]
6206 async fn telemetry_endpoint_reports_loaded_session_without_preview() {
6207 let app = runtime_router_with_dry_preview();
6208 post_json_with(
6209 app.clone(),
6210 "/v0/sessions/default/load",
6211 sample_project_document_current(),
6212 )
6213 .await;
6214
6215 let response = get_json_with(app, "/v0/sessions/default/telemetry").await;
6216
6217 assert_eq!(response["session"]["loaded"], true);
6218 assert_eq!(response["session"]["graphId"], "minimal-value");
6219 assert_eq!(response["session"]["graphRevision"], "1");
6220 assert_eq!(response["session"]["sessionRevision"], 1);
6221 assert_eq!(response["preview"]["state"], "stopped");
6222 assert_eq!(response["render"]["active"], false);
6223 assert_eq!(response["render"]["diagnostics"], json!([]));
6224 assert_eq!(response["render"]["generatedSourceAvailable"], false);
6225 }
6226
6227 #[tokio::test]
6228 async fn telemetry_endpoint_reports_dry_run_preview() {
6229 let app = runtime_router_with_dry_preview();
6230 post_json_with(
6231 app.clone(),
6232 "/v0/sessions/default/load",
6233 sample_project_document_current(),
6234 )
6235 .await;
6236 post_empty_with(app.clone(), "/v0/sessions/default/preview/start").await;
6237
6238 let response = get_json_with(app, "/v0/sessions/default/telemetry").await;
6239
6240 assert_eq!(response["preview"]["state"], "running");
6241 assert_eq!(response["preview"]["stale"], false);
6242 assert_eq!(response["render"]["active"], true);
6243 assert_eq!(response["render"]["backend"], "dry-run");
6244 assert_eq!(response["render"]["renderer"], "clear-color");
6245 assert_eq!(response["render"]["framesRendered"], 0);
6246 assert_eq!(response["render"]["diagnostics"], json!([]));
6247 assert_eq!(response["render"]["generatedSourceAvailable"], false);
6248 }
6249
6250 #[tokio::test]
6251 async fn telemetry_endpoint_marks_preview_stale_after_patch() {
6252 let app = runtime_router_with_dry_preview();
6253 post_json_with(
6254 app.clone(),
6255 "/v0/sessions/default/load",
6256 sample_project_document_current(),
6257 )
6258 .await;
6259 post_empty_with(app.clone(), "/v0/sessions/default/preview/start").await;
6260 post_json_with(
6261 app.clone(),
6262 "/v0/sessions/default/operation",
6263 paste_operation("1"),
6264 )
6265 .await;
6266
6267 let response = get_json_with(app, "/v0/sessions/default/telemetry").await;
6268
6269 assert_eq!(response["session"]["sessionRevision"], 2);
6270 assert_eq!(response["preview"]["state"], "running");
6271 assert_eq!(response["preview"]["previewSessionRevision"], 1);
6272 assert_eq!(response["preview"]["stale"], true);
6273 }
6274
6275 #[tokio::test]
6276 async fn generated_shader_endpoint_returns_source_and_source_map() {
6277 let app = runtime_router_with_dry_preview();
6278 post_json_with(
6279 app.clone(),
6280 "/v0/sessions/default/load",
6281 sample_shader_project_current(),
6282 )
6283 .await;
6284
6285 let response = get_json_with(app, "/v0/sessions/default/render/generated-shader").await;
6286 assert_eq!(response["ok"], true);
6287 assert_eq!(response["nodeId"], "shader_1");
6288 assert_eq!(response["language"], "wgsl");
6289 assert!(
6290 response["source"]
6291 .as_str()
6292 .unwrap()
6293 .contains("struct SkenionFrame")
6294 );
6295 assert!(response["source"].as_str().unwrap().contains("speed: f32"));
6296 assert!(response["source"].as_str().unwrap().contains("fn fs_main"));
6297 assert!(
6298 response["sourceMap"]["userSourceStartLine"]
6299 .as_u64()
6300 .unwrap()
6301 > 1
6302 );
6303 assert_eq!(response["diagnostics"], json!([]));
6304 }
6305
6306 #[tokio::test]
6307 async fn generated_shader_endpoint_reports_session_or_shader_diagnostics() {
6308 let empty = get_json_with(
6309 runtime_router_with_dry_preview(),
6310 "/v0/sessions/default/render/generated-shader",
6311 )
6312 .await;
6313 assert_eq!(empty["ok"], false);
6314 assert_eq!(empty["diagnostics"][0]["phase"], json!("source-sync"));
6315
6316 let app = runtime_router_with_dry_preview();
6317 let mut project = sample_shader_project_current();
6318 project["graph"]["nodes"][0]["params"]["source"] = json!(
6319 "// @skenion.uniform bad vec3\n@fragment\nfn fs_main() -> @location(0) vec4<f32> { return vec4<f32>(1.0); }"
6320 );
6321 let loaded = post_json_with(app.clone(), "/v0/sessions/default/load", project).await;
6322 assert_eq!(loaded["ok"], true);
6323
6324 let response = get_json_with(app, "/v0/sessions/default/render/generated-shader").await;
6325 assert_eq!(response["ok"], false);
6326 assert_eq!(
6327 response["diagnostics"][0]["phase"],
6328 json!("interface-analysis")
6329 );
6330 assert_eq!(
6331 response["diagnostics"][0]["code"],
6332 json!("unsupported-uniform-type")
6333 );
6334 assert_eq!(response["diagnostics"][0]["line"], json!(1));
6335 }
6336
6337 #[tokio::test]
6338 async fn telemetry_stream_endpoint_returns_sse_response() {
6339 let response = runtime_router_with_dry_preview()
6340 .oneshot(
6341 Request::builder()
6342 .uri("/v0/sessions/default/telemetry/stream")
6343 .body(Body::empty())
6344 .expect("request should build"),
6345 )
6346 .await
6347 .expect("router should respond");
6348
6349 assert_eq!(response.status(), StatusCode::OK);
6350 assert!(
6351 response
6352 .headers()
6353 .get(CONTENT_TYPE)
6354 .unwrap()
6355 .to_str()
6356 .unwrap()
6357 .starts_with("text/event-stream")
6358 );
6359 let mut stream = response.into_body().into_data_stream();
6360 let chunk = tokio::time::timeout(Duration::from_secs(1), stream.next())
6361 .await
6362 .expect("telemetry stream should emit")
6363 .expect("telemetry stream should have a chunk")
6364 .expect("telemetry stream chunk should be ok");
6365 let text = std::str::from_utf8(&chunk).expect("telemetry stream should be utf8");
6366 assert!(text.contains("event: telemetry"));
6367 assert!(text.contains("skenion.runtime.telemetry"));
6368 }
6369
6370 async fn get_json(path: &str) -> Value {
6371 get_json_with(runtime_router(), path).await
6372 }
6373
6374 async fn get_json_with(app: Router, path: &str) -> Value {
6375 let response = app
6376 .oneshot(
6377 Request::builder()
6378 .uri(path)
6379 .body(Body::empty())
6380 .expect("request should build"),
6381 )
6382 .await
6383 .expect("router should respond");
6384 assert_eq!(response.status(), StatusCode::OK);
6385 body_json(response.into_body()).await
6386 }
6387
6388 async fn status_with(app: Router, path: &str) -> StatusCode {
6389 app.oneshot(
6390 Request::builder()
6391 .uri(path)
6392 .body(Body::empty())
6393 .expect("request should build"),
6394 )
6395 .await
6396 .expect("router should respond")
6397 .status()
6398 }
6399
6400 async fn post_json(path: &str, payload: Value) -> Value {
6401 post_json_with(runtime_router(), path, payload).await
6402 }
6403
6404 async fn post_json_with(app: Router, path: &str, payload: Value) -> Value {
6405 let response = app
6406 .oneshot(
6407 Request::builder()
6408 .method("POST")
6409 .uri(path)
6410 .header(CONTENT_TYPE, "application/json")
6411 .body(Body::from(payload.to_string()))
6412 .expect("request should build"),
6413 )
6414 .await
6415 .expect("router should respond");
6416 assert_eq!(response.status(), StatusCode::OK);
6417 body_json(response.into_body()).await
6418 }
6419
6420 async fn post_json_status_with(app: Router, path: &str, payload: Value) -> (StatusCode, Value) {
6421 let response = app
6422 .oneshot(
6423 Request::builder()
6424 .method("POST")
6425 .uri(path)
6426 .header(CONTENT_TYPE, "application/json")
6427 .body(Body::from(payload.to_string()))
6428 .expect("request should build"),
6429 )
6430 .await
6431 .expect("router should respond");
6432 let status = response.status();
6433 (status, body_json(response.into_body()).await)
6434 }
6435
6436 async fn post_status_with(app: Router, path: &str, payload: Value) -> StatusCode {
6437 app.oneshot(
6438 Request::builder()
6439 .method("POST")
6440 .uri(path)
6441 .header(CONTENT_TYPE, "application/json")
6442 .body(Body::from(payload.to_string()))
6443 .expect("request should build"),
6444 )
6445 .await
6446 .expect("router should respond")
6447 .status()
6448 }
6449
6450 async fn post_raw_with(app: Router, path: &str, payload: Vec<u8>) -> Value {
6451 let response = app
6452 .oneshot(
6453 Request::builder()
6454 .method("POST")
6455 .uri(path)
6456 .header(CONTENT_TYPE, "application/json")
6457 .body(Body::from(payload))
6458 .expect("request should build"),
6459 )
6460 .await
6461 .expect("router should respond");
6462 assert_eq!(response.status(), StatusCode::OK);
6463 body_json(response.into_body()).await
6464 }
6465
6466 async fn post_empty_with(app: Router, path: &str) -> Value {
6467 let response = app
6468 .oneshot(
6469 Request::builder()
6470 .method("POST")
6471 .uri(path)
6472 .body(Body::empty())
6473 .expect("request should build"),
6474 )
6475 .await
6476 .expect("router should respond");
6477 assert_eq!(response.status(), StatusCode::OK);
6478 body_json(response.into_body()).await
6479 }
6480
6481 async fn delete_json_with(app: Router, path: &str) -> Value {
6482 let response = app
6483 .oneshot(
6484 Request::builder()
6485 .method("DELETE")
6486 .uri(path)
6487 .body(Body::empty())
6488 .expect("request should build"),
6489 )
6490 .await
6491 .expect("router should respond");
6492 assert_eq!(response.status(), StatusCode::OK);
6493 body_json(response.into_body()).await
6494 }
6495
6496 async fn body_json(body: Body) -> Value {
6497 let bytes = to_bytes(body, usize::MAX)
6498 .await
6499 .expect("body should collect");
6500 serde_json::from_slice(&bytes).expect("body should be json")
6501 }
6502
6503 fn runtime_router_with_dry_preview() -> Router {
6504 runtime_router_with_state(runtime_state_with_dry_preview())
6505 }
6506
6507 fn runtime_state_with_dry_preview() -> RuntimeServerState {
6508 let logs = std::sync::Arc::new(RuntimeLogStore::default());
6509 RuntimeServerState {
6510 sessions: RuntimeSessionRegistry::dry_preview(),
6511 assets: std::sync::Arc::new(std::sync::RwLock::new(RuntimeAssetStore::default())),
6512 io_devices: std::sync::Arc::new(RuntimeIoDeviceManager::new()),
6513 extensions: std::sync::Arc::new(RuntimeExtensionManager::default()),
6514 logs,
6515 endpoint: RuntimeEndpointConfig::new(DEFAULT_HOST.to_owned(), DEFAULT_PORT),
6516 started_at_wall_clock: created_at_now(),
6517 started_at: std::time::Instant::now(),
6518 }
6519 }
6520
6521 fn runtime_router_with_fake_io_devices(devices: Vec<RuntimeIoDeviceDescriptor>) -> Router {
6522 let logs = std::sync::Arc::new(RuntimeLogStore::default());
6523 runtime_router_with_state(RuntimeServerState {
6524 sessions: RuntimeSessionRegistry::dry_preview(),
6525 assets: std::sync::Arc::new(std::sync::RwLock::new(RuntimeAssetStore::default())),
6526 io_devices: std::sync::Arc::new(RuntimeIoDeviceManager::with_device_registry(
6527 Arc::new(ServerFakeIoDeviceRegistry { devices }),
6528 )),
6529 extensions: std::sync::Arc::new(RuntimeExtensionManager::default()),
6530 logs,
6531 endpoint: RuntimeEndpointConfig::new(DEFAULT_HOST.to_owned(), DEFAULT_PORT),
6532 started_at_wall_clock: created_at_now(),
6533 started_at: std::time::Instant::now(),
6534 })
6535 }
6536
6537 fn sample_project() -> Value {
6538 json!({
6539 "graph": {
6540 "schema": "skenion.graph",
6541 "schemaVersion": "0.1.0",
6542 "id": "minimal-value",
6543 "revision": "1",
6544 "nodes": [
6545 {
6546 "id": "value_1",
6547 "kind": "core.float",
6548 "kindVersion": "0.1.0",
6549 "params": {},
6550 "ports": value_f32_ports_json()
6551 },
6552 {
6553 "id": "target_1",
6554 "kind": "core.float",
6555 "kindVersion": "0.1.0",
6556 "params": {},
6557 "ports": value_f32_ports_json()
6558 }
6559 ],
6560 "edges": [
6561 { "from": { "node": "value_1", "port": "value" }, "to": { "node": "target_1", "port": "in" } }
6562 ]
6563 },
6564 "nodes": [
6565 {
6566 "schema": "skenion.node.definition",
6567 "schemaVersion": "0.1.0",
6568 "id": "core.float",
6569 "version": "0.1.0",
6570 "displayName": "Float Value",
6571 "category": "Values",
6572 "ports": value_f32_ports_json(),
6573 "execution": { "model": "value" },
6574 "state": { "persistent": false },
6575 "permissions": [],
6576 "capabilities": []
6577 }
6578 ]
6579 })
6580 }
6581
6582 fn sample_project_document_current() -> Value {
6583 json!({
6584 "schema": "skenion.project",
6585 "schemaVersion": "0.1.0",
6586 "id": "minimal-value-project",
6587 "revision": "1",
6588 "graph": {
6589 "schema": "skenion.graph",
6590 "schemaVersion": "0.1.0",
6591 "id": "minimal-value",
6592 "revision": "1",
6593 "nodes": [
6594 {
6595 "id": "value_1",
6596 "kind": "core.float",
6597 "kindVersion": "0.1.0",
6598 "params": {},
6599 "ports": value_f32_ports_current_json()
6600 },
6601 {
6602 "id": "target_1",
6603 "kind": "core.float",
6604 "kindVersion": "0.1.0",
6605 "params": {},
6606 "ports": value_f32_ports_current_json()
6607 }
6608 ],
6609 "edges": [
6610 {
6611 "id": "edge_value_target",
6612 "source": { "nodeId": "value_1", "portId": "value" },
6613 "target": { "nodeId": "target_1", "portId": "cold" },
6614 "resolvedType": "number.float"
6615 }
6616 ]
6617 },
6618 "viewState": {
6619 "schema": "skenion.view-state",
6620 "schemaVersion": "0.1.0",
6621 "canvas": {
6622 "nodes": {
6623 "value_1": { "x": 96.0, "y": 96.0 },
6624 "target_1": { "x": 260.0, "y": 96.0 }
6625 }
6626 }
6627 },
6628 "patchLibrary": [],
6629 "nodes": [
6630 {
6631 "schema": "skenion.node.definition",
6632 "schemaVersion": "0.1.0",
6633 "id": "core.float",
6634 "version": "0.1.0",
6635 "displayName": "Float Value",
6636 "category": "Values",
6637 "ports": value_f32_ports_current_json(),
6638 "execution": { "model": "value" },
6639 "state": { "persistent": false },
6640 "permissions": [],
6641 "capabilities": []
6642 }
6643 ]
6644 })
6645 }
6646
6647 fn sample_project_request_current() -> ProjectRequestCurrent {
6648 let mut value = sample_project_document_current();
6649 let nodes = value
6650 .as_object_mut()
6651 .and_then(|object| object.remove("nodes"))
6652 .expect("sample project document should carry node definitions");
6653 let nodes = serde_json::from_value::<Vec<NodeDefinitionCurrent>>(nodes)
6654 .expect("nodes should parse");
6655 let document =
6656 serde_json::from_value::<ProjectDocumentCurrent>(value).expect("document should parse");
6657 ProjectRequestCurrent::from_project_document(document, nodes)
6658 }
6659
6660 fn value_f32_ports_json() -> Value {
6661 json!([
6662 {
6663 "id": "in",
6664 "direction": "input",
6665 "label": "In",
6666 "type": { "flow": "event", "dataKind": "message.any" },
6667 "required": false,
6668 "activation": "trigger"
6669 },
6670 {
6671 "id": "cold",
6672 "direction": "input",
6673 "label": "Cold",
6674 "type": { "flow": "value", "dataKind": "number.float" },
6675 "required": false,
6676 "activation": "latched"
6677 },
6678 {
6679 "id": "value",
6680 "direction": "output",
6681 "label": "Value",
6682 "type": { "flow": "value", "dataKind": "number.float" }
6683 }
6684 ])
6685 }
6686
6687 fn sample_shader_project_current() -> Value {
6688 json!({
6689 "graph": {
6690 "schema": "skenion.graph",
6691 "schemaVersion": "0.1.0",
6692 "id": "shader-diagnostics",
6693 "revision": "1",
6694 "nodes": [
6695 {
6696 "id": "shader_1",
6697 "kind": "render.fullscreen-shader",
6698 "kindVersion": "0.1.0",
6699 "params": {
6700 "language": "wgsl",
6701 "source": "// @skenion.uniform speed number.float default=0.5\n@fragment\nfn fs_main() -> @location(0) vec4<f32> { return vec4<f32>(skenion.speed, 0.0, 1.0, 1.0); }"
6702 },
6703 "ports": [
6704 {
6705 "id": "speed",
6706 "direction": "input",
6707 "label": "Speed",
6708 "type": "number.float",
6709 "rate": "control",
6710 "required": false,
6711 "defaultValue": 0.5,
6712 "triggerMode": "latched"
6713 },
6714 {
6715 "id": "out",
6716 "direction": "output",
6717 "label": "Out",
6718 "type": "gpu.texture2d",
6719 "rate": "resource"
6720 }
6721 ]
6722 }
6723 ],
6724 "edges": []
6725 },
6726 "nodes": [
6727 {
6728 "schema": "skenion.node.definition",
6729 "schemaVersion": "0.1.0",
6730 "id": "render.fullscreen-shader",
6731 "version": "0.1.0",
6732 "displayName": "Fullscreen Shader",
6733 "category": "Render",
6734 "ports": [
6735 {
6736 "id": "speed",
6737 "direction": "input",
6738 "label": "Speed",
6739 "type": "number.float",
6740 "rate": "control",
6741 "required": false,
6742 "defaultValue": 0.5,
6743 "triggerMode": "latched"
6744 },
6745 {
6746 "id": "out",
6747 "direction": "output",
6748 "label": "Out",
6749 "type": "gpu.texture2d",
6750 "rate": "resource"
6751 }
6752 ],
6753 "execution": { "model": "gpu_pass", "clock": "frame" },
6754 "state": { "persistent": false },
6755 "permissions": [],
6756 "capabilities": []
6757 }
6758 ]
6759 })
6760 }
6761
6762 fn sample_project_current() -> Value {
6763 json!({
6764 "graph": {
6765 "schema": "skenion.graph",
6766 "schemaVersion": "0.1.0",
6767 "id": "render-output-current",
6768 "revision": "1",
6769 "nodes": [
6770 {
6771 "id": "clear_color",
6772 "kind": "render.clear-color",
6773 "kindVersion": "0.1.0",
6774 "params": { "color": [0.12, 0.2, 0.34, 1] },
6775 "ports": [
6776 {
6777 "id": "out",
6778 "direction": "output",
6779 "type": "render.frame",
6780 "rate": "render"
6781 }
6782 ]
6783 },
6784 {
6785 "id": "output",
6786 "kind": "render.output",
6787 "kindVersion": "0.1.0",
6788 "params": {},
6789 "ports": [
6790 {
6791 "id": "in",
6792 "direction": "input",
6793 "type": "render.frame",
6794 "rate": "render",
6795 "required": true
6796 }
6797 ]
6798 }
6799 ],
6800 "edges": [
6801 {
6802 "id": "edge_clear_output",
6803 "source": { "nodeId": "clear_color", "portId": "out" },
6804 "target": { "nodeId": "output", "portId": "in" },
6805 "resolvedType": "render.frame"
6806 }
6807 ]
6808 },
6809 "nodes": [
6810 {
6811 "schema": "skenion.node.definition",
6812 "schemaVersion": "0.1.0",
6813 "id": "render.clear-color",
6814 "version": "0.1.0",
6815 "displayName": "Clear Color",
6816 "category": "Render",
6817 "ports": [
6818 {
6819 "id": "out",
6820 "direction": "output",
6821 "type": "render.frame",
6822 "rate": "render"
6823 }
6824 ],
6825 "execution": { "model": "gpu_pass", "clock": "frame" },
6826 "state": { "persistent": false },
6827 "permissions": [],
6828 "capabilities": ["render.frame.v0.1"]
6829 },
6830 {
6831 "schema": "skenion.node.definition",
6832 "schemaVersion": "0.1.0",
6833 "id": "render.output",
6834 "version": "0.1.0",
6835 "displayName": "Render Output",
6836 "category": "Render",
6837 "ports": [
6838 {
6839 "id": "in",
6840 "direction": "input",
6841 "type": "render.frame",
6842 "rate": "render",
6843 "required": true
6844 }
6845 ],
6846 "execution": { "model": "gpu_pass", "clock": "frame" },
6847 "state": { "persistent": false },
6848 "permissions": [],
6849 "capabilities": ["render.output.v0.1"]
6850 }
6851 ]
6852 })
6853 }
6854
6855 fn sample_subpatch_project_document_current() -> Value {
6856 json!({
6857 "schema": "skenion.project",
6858 "schemaVersion": "0.1.0",
6859 "id": "subpatch-project",
6860 "revision": "1",
6861 "graph": {
6862 "schema": "skenion.graph",
6863 "schemaVersion": "0.1.0",
6864 "id": "subpatch-project-root",
6865 "revision": "1",
6866 "nodes": [
6867 {
6868 "id": "clear_color",
6869 "kind": "render.clear-color",
6870 "kindVersion": "0.1.0",
6871 "params": { "color": [0.12, 0.2, 0.34, 1] },
6872 "ports": [
6873 { "id": "out", "direction": "output", "type": "render.frame", "rate": "render" }
6874 ]
6875 },
6876 {
6877 "id": "fx",
6878 "kind": "core.subpatch",
6879 "kindVersion": "0.1.0",
6880 "params": { "patchRef": "identity" },
6881 "ports": [
6882 { "id": "in", "direction": "input", "type": "render.frame", "rate": "render", "required": true },
6883 { "id": "out", "direction": "output", "type": "render.frame", "rate": "render" }
6884 ]
6885 },
6886 {
6887 "id": "output",
6888 "kind": "render.output",
6889 "kindVersion": "0.1.0",
6890 "params": {},
6891 "ports": [
6892 { "id": "in", "direction": "input", "type": "render.frame", "rate": "render", "required": true }
6893 ]
6894 }
6895 ],
6896 "edges": [
6897 {
6898 "id": "edge_clear_fx",
6899 "source": { "nodeId": "clear_color", "portId": "out" },
6900 "target": { "nodeId": "fx", "portId": "in" },
6901 "resolvedType": "render.frame"
6902 },
6903 {
6904 "id": "edge_fx_output",
6905 "source": { "nodeId": "fx", "portId": "out" },
6906 "target": { "nodeId": "output", "portId": "in" },
6907 "resolvedType": "render.frame"
6908 }
6909 ]
6910 },
6911 "viewState": {
6912 "schema": "skenion.view-state",
6913 "schemaVersion": "0.1.0",
6914 "canvas": { "nodes": {} }
6915 },
6916 "patchLibrary": [
6917 {
6918 "id": "identity",
6919 "revision": "1",
6920 "metadata": { "title": "Identity Frame" },
6921 "graph": {
6922 "schema": "skenion.graph",
6923 "schemaVersion": "0.1.0",
6924 "id": "identity-frame-patch",
6925 "revision": "1",
6926 "nodes": [
6927 {
6928 "id": "patch_in",
6929 "kind": "core.inlet",
6930 "kindVersion": "0.1.0",
6931 "params": { "portId": "in", "label": "Input" },
6932 "ports": [
6933 { "id": "out", "direction": "output", "type": "render.frame", "rate": "render", "description": "Frame entering the patch" }
6934 ]
6935 },
6936 {
6937 "id": "pass",
6938 "kind": "test.pass",
6939 "kindVersion": "0.1.0",
6940 "params": {},
6941 "ports": [
6942 { "id": "in", "direction": "input", "type": "render.frame", "rate": "render", "required": true },
6943 { "id": "out", "direction": "output", "type": "render.frame", "rate": "render" }
6944 ]
6945 },
6946 {
6947 "id": "patch_out",
6948 "kind": "core.outlet",
6949 "kindVersion": "0.1.0",
6950 "params": { "portId": "out", "label": "Output" },
6951 "ports": [
6952 { "id": "in", "direction": "input", "type": "render.frame", "rate": "render", "required": true, "description": "Frame leaving the patch" }
6953 ]
6954 }
6955 ],
6956 "edges": [
6957 {
6958 "id": "edge_in_pass",
6959 "source": { "nodeId": "patch_in", "portId": "out" },
6960 "target": { "nodeId": "pass", "portId": "in" },
6961 "resolvedType": "render.frame"
6962 },
6963 {
6964 "id": "edge_pass_out",
6965 "source": { "nodeId": "pass", "portId": "out" },
6966 "target": { "nodeId": "patch_out", "portId": "in" },
6967 "resolvedType": "render.frame"
6968 }
6969 ]
6970 }
6971 }
6972 ],
6973 "nodes": [
6974 {
6975 "schema": "skenion.node.definition",
6976 "schemaVersion": "0.1.0",
6977 "id": "render.clear-color",
6978 "version": "0.1.0",
6979 "displayName": "Clear Color",
6980 "category": "Render",
6981 "ports": [
6982 { "id": "out", "direction": "output", "type": "render.frame", "rate": "render" }
6983 ],
6984 "execution": { "model": "gpu_pass", "clock": "frame" },
6985 "state": { "persistent": false },
6986 "permissions": [],
6987 "capabilities": ["render.frame.v0.1"]
6988 },
6989 {
6990 "schema": "skenion.node.definition",
6991 "schemaVersion": "0.1.0",
6992 "id": "render.output",
6993 "version": "0.1.0",
6994 "displayName": "Render Output",
6995 "category": "Render",
6996 "ports": [
6997 { "id": "in", "direction": "input", "type": "render.frame", "rate": "render", "required": true }
6998 ],
6999 "execution": { "model": "gpu_pass", "clock": "frame" },
7000 "state": { "persistent": false },
7001 "permissions": [],
7002 "capabilities": ["render.output.v0.1"]
7003 },
7004 {
7005 "schema": "skenion.node.definition",
7006 "schemaVersion": "0.1.0",
7007 "id": "test.pass",
7008 "version": "0.1.0",
7009 "displayName": "Pass",
7010 "category": "Test",
7011 "ports": [
7012 { "id": "in", "direction": "input", "type": "render.frame", "rate": "render", "required": true },
7013 { "id": "out", "direction": "output", "type": "render.frame", "rate": "render" }
7014 ],
7015 "execution": { "model": "gpu_pass", "clock": "frame" },
7016 "state": { "persistent": false },
7017 "permissions": [],
7018 "capabilities": []
7019 }
7020 ]
7021 })
7022 }
7023
7024 fn sample_ambiguous_loop_project_current() -> Value {
7025 json!({
7026 "graph": {
7027 "schema": "skenion.graph",
7028 "schemaVersion": "0.1.0",
7029 "id": "ambiguous-algebraic-loop-current",
7030 "revision": "1",
7031 "nodes": [
7032 {
7033 "id": "a",
7034 "kind": "core.value-transform",
7035 "kindVersion": "0.1.0",
7036 "params": {},
7037 "ports": [
7038 { "id": "in", "direction": "input", "type": "value.number", "rate": "control" },
7039 { "id": "out", "direction": "output", "type": "value.number", "rate": "control" }
7040 ]
7041 },
7042 {
7043 "id": "b",
7044 "kind": "core.value-transform",
7045 "kindVersion": "0.1.0",
7046 "params": {},
7047 "ports": [
7048 { "id": "in", "direction": "input", "type": "value.number", "rate": "control" },
7049 { "id": "out", "direction": "output", "type": "value.number", "rate": "control" }
7050 ]
7051 }
7052 ],
7053 "edges": [
7054 {
7055 "id": "edge_a_b",
7056 "source": { "nodeId": "a", "portId": "out" },
7057 "target": { "nodeId": "b", "portId": "in" }
7058 },
7059 {
7060 "id": "edge_b_a",
7061 "source": { "nodeId": "b", "portId": "out" },
7062 "target": { "nodeId": "a", "portId": "in" }
7063 }
7064 ]
7065 },
7066 "nodes": [
7067 {
7068 "schema": "skenion.node.definition",
7069 "schemaVersion": "0.1.0",
7070 "id": "core.value-transform",
7071 "version": "0.1.0",
7072 "displayName": "Value Transform",
7073 "category": "Core",
7074 "ports": [
7075 { "id": "in", "direction": "input", "type": "value.number", "rate": "control" },
7076 { "id": "out", "direction": "output", "type": "value.number", "rate": "control" }
7077 ],
7078 "execution": { "model": "value" },
7079 "state": { "persistent": false },
7080 "permissions": [],
7081 "capabilities": ["value.number.v0.1"]
7082 }
7083 ]
7084 })
7085 }
7086
7087 fn set_value_patch(base_revision: &str) -> Value {
7088 json!({
7089 "schema": "skenion.graph.patch",
7090 "schemaVersion": "0.1.0",
7091 "id": "set-value",
7092 "baseRevision": base_revision,
7093 "ops": [
7094 { "op": "setNodeParam", "nodeId": "value_1", "key": "value", "value": 0.75 }
7095 ]
7096 })
7097 }
7098
7099 fn graph_mutation(graph_patch: Value) -> Value {
7100 json!({ "graphPatch": graph_patch })
7101 }
7102
7103 fn paste_operation(base_revision: &str) -> Value {
7104 json!({
7105 "schema": "skenion.runtime.operation",
7106 "schemaVersion": "0.1.0",
7107 "id": "op-paste",
7108 "kind": "pasteGraphFragment",
7109 "request": {
7110 "target": {
7111 "path": { "kind": "root" },
7112 "baseRevision": base_revision
7113 },
7114 "fragment": {
7115 "schema": "skenion.graph.fragment",
7116 "schemaVersion": "0.1.0",
7117 "nodes": [
7118 {
7119 "id": "value_1",
7120 "kind": "core.float",
7121 "kindVersion": "0.1.0",
7122 "params": {},
7123 "ports": value_f32_ports_current_json()
7124 },
7125 {
7126 "id": "pasted_target",
7127 "kind": "core.float",
7128 "kindVersion": "0.1.0",
7129 "params": {},
7130 "ports": value_f32_ports_current_json()
7131 }
7132 ],
7133 "edges": [
7134 {
7135 "id": "edge_value_to_pasted",
7136 "source": { "nodeId": "value_1", "portId": "value" },
7137 "target": { "nodeId": "pasted_target", "portId": "cold" }
7138 }
7139 ]
7140 },
7141 "options": {
7142 "idConflictPolicy": "remap"
7143 }
7144 },
7145 "attribution": {
7146 "clientId": "studio-test",
7147 "label": "Paste test fragment"
7148 }
7149 })
7150 }
7151
7152 fn root_render_paste_operation(base_revision: &str) -> Value {
7153 paste_render_node_operation(base_revision, json!({ "kind": "root" }), "root_debug")
7154 }
7155
7156 fn patch_definition_paste_operation(base_revision: &str) -> Value {
7157 paste_render_node_operation(
7158 base_revision,
7159 json!({ "kind": "project-patch-definition", "patchId": "identity" }),
7160 "patch_debug",
7161 )
7162 }
7163
7164 fn paste_render_node_operation(base_revision: &str, path: Value, node_id: &str) -> Value {
7165 json!({
7166 "schema": "skenion.runtime.operation",
7167 "schemaVersion": "0.1.0",
7168 "id": format!("op-paste-{node_id}"),
7169 "kind": "pasteGraphFragment",
7170 "request": {
7171 "target": {
7172 "path": path,
7173 "baseRevision": base_revision
7174 },
7175 "fragment": {
7176 "schema": "skenion.graph.fragment",
7177 "schemaVersion": "0.1.0",
7178 "nodes": [
7179 render_clear_color_node_current_json(node_id)
7180 ],
7181 "edges": []
7182 },
7183 "options": {
7184 "idConflictPolicy": "remap"
7185 }
7186 },
7187 "attribution": {
7188 "clientId": "studio-test",
7189 "label": "Paste render test node"
7190 }
7191 })
7192 }
7193
7194 fn collaboration_paste_operation(
7195 base_revision: &str,
7196 operation_id: &str,
7197 idempotency_key: &str,
7198 ) -> Value {
7199 collaboration_paste_operation_for(
7200 base_revision,
7201 operation_id,
7202 idempotency_key,
7203 "participant-a",
7204 )
7205 }
7206
7207 fn collaboration_paste_operation_for(
7208 base_revision: &str,
7209 operation_id: &str,
7210 idempotency_key: &str,
7211 participant_id: &str,
7212 ) -> Value {
7213 json!({
7214 "schema": "skenion.runtime.collaboration.operation",
7215 "schemaVersion": "0.1.0",
7216 "operationId": operation_id,
7217 "sessionId": "default",
7218 "participantId": participant_id,
7219 "idempotencyKey": idempotency_key,
7220 "causal": {
7221 "baseRevision": base_revision,
7222 "baseSequence": 0,
7223 "vector": { participant_id: 0 }
7224 },
7225 "payload": {
7226 "kind": "pasteGraphFragment",
7227 "request": {
7228 "target": {
7229 "path": { "kind": "root" },
7230 "baseRevision": base_revision
7231 },
7232 "fragment": {
7233 "schema": "skenion.graph.fragment",
7234 "schemaVersion": "0.1.0",
7235 "nodes": [
7236 {
7237 "id": "value_1",
7238 "kind": "core.float",
7239 "kindVersion": "0.1.0",
7240 "params": {},
7241 "ports": value_f32_ports_current_json()
7242 },
7243 {
7244 "id": "pasted_target",
7245 "kind": "core.float",
7246 "kindVersion": "0.1.0",
7247 "params": {},
7248 "ports": value_f32_ports_current_json()
7249 }
7250 ],
7251 "edges": [
7252 {
7253 "id": "edge_value_to_pasted",
7254 "source": { "nodeId": "value_1", "portId": "value" },
7255 "target": { "nodeId": "pasted_target", "portId": "cold" }
7256 }
7257 ]
7258 },
7259 "options": {
7260 "idConflictPolicy": "remap"
7261 }
7262 },
7263 "description": "Collaborative paste test fragment"
7264 },
7265 "correlationId": "studio-test",
7266 "submittedAt": "2026-06-22T00:00:00.000Z"
7267 })
7268 }
7269
7270 fn collaboration_change_set_operation(
7271 base_revision: &str,
7272 operation_id: &str,
7273 idempotency_key: &str,
7274 participant_id: &str,
7275 changes: Vec<Value>,
7276 ) -> Value {
7277 collaboration_change_set_operation_with_path(
7278 base_revision,
7279 operation_id,
7280 idempotency_key,
7281 participant_id,
7282 json!({ "kind": "root" }),
7283 changes,
7284 )
7285 }
7286
7287 fn collaboration_patch_change_set_operation(
7288 base_revision: &str,
7289 operation_id: &str,
7290 idempotency_key: &str,
7291 participant_id: &str,
7292 changes: Vec<Value>,
7293 ) -> Value {
7294 collaboration_change_set_operation_with_path(
7295 base_revision,
7296 operation_id,
7297 idempotency_key,
7298 participant_id,
7299 json!({ "kind": "project-patch-definition", "patchId": "identity" }),
7300 changes,
7301 )
7302 }
7303
7304 fn collaboration_change_set_operation_with_path(
7305 base_revision: &str,
7306 operation_id: &str,
7307 idempotency_key: &str,
7308 participant_id: &str,
7309 path: Value,
7310 changes: Vec<Value>,
7311 ) -> Value {
7312 json!({
7313 "schema": "skenion.runtime.collaboration.operation",
7314 "schemaVersion": "0.1.0",
7315 "operationId": operation_id,
7316 "sessionId": "default",
7317 "participantId": participant_id,
7318 "idempotencyKey": idempotency_key,
7319 "causal": {
7320 "baseRevision": base_revision,
7321 "baseSequence": 0,
7322 "vector": { participant_id: 0 }
7323 },
7324 "payload": {
7325 "kind": "changeSet",
7326 "target": {
7327 "path": path,
7328 "baseRevision": base_revision
7329 },
7330 "changes": changes,
7331 "description": "Collaborative change-set test"
7332 },
7333 "correlationId": "studio-test",
7334 "submittedAt": "2026-06-22T00:00:00.000Z"
7335 })
7336 }
7337
7338 fn render_clear_color_node_current_json(node_id: &str) -> Value {
7339 json!({
7340 "id": node_id,
7341 "kind": "render.clear-color",
7342 "kindVersion": "0.1.0",
7343 "params": { "color": [0.02, 0.04, 0.08, 1.0] },
7344 "ports": [
7345 { "id": "out", "direction": "output", "type": "render.frame", "rate": "render" }
7346 ]
7347 })
7348 }
7349
7350 fn collaboration_undo_redo_operation(
7351 base_revision: &str,
7352 operation_id: &str,
7353 idempotency_key: &str,
7354 participant_id: &str,
7355 action: &str,
7356 ) -> Value {
7357 json!({
7358 "schema": "skenion.runtime.collaboration.operation",
7359 "schemaVersion": "0.1.0",
7360 "operationId": operation_id,
7361 "sessionId": "default",
7362 "participantId": participant_id,
7363 "idempotencyKey": idempotency_key,
7364 "causal": {
7365 "baseRevision": base_revision,
7366 "baseSequence": 0,
7367 "vector": { participant_id: 0 }
7368 },
7369 "payload": {
7370 "kind": "undoRedo",
7371 "action": action,
7372 "scope": {
7373 "kind": "participant",
7374 "participantId": participant_id
7375 }
7376 },
7377 "correlationId": "studio-test",
7378 "submittedAt": "2026-06-22T00:00:00.000Z"
7379 })
7380 }
7381
7382 fn collaboration_presence(session_id: &str, participant_id: &str) -> Value {
7383 json!({
7384 "schema": "skenion.runtime.collaboration.presence",
7385 "schemaVersion": "0.1.0",
7386 "sessionId": session_id,
7387 "participantId": participant_id,
7388 "presence": {
7389 "state": "active",
7390 "displayName": "Participant A"
7391 },
7392 "updatedAt": "2026-06-22T00:00:00.000Z",
7393 "expiresAt": "2026-06-22T00:05:00.000Z"
7394 })
7395 }
7396
7397 fn collaboration_selection(session_id: &str, participant_id: &str) -> Value {
7398 json!({
7399 "schema": "skenion.runtime.collaboration.selection",
7400 "schemaVersion": "0.1.0",
7401 "sessionId": session_id,
7402 "participantId": participant_id,
7403 "target": {
7404 "path": { "kind": "root" },
7405 "baseRevision": "1"
7406 },
7407 "selection": {
7408 "ranges": [
7409 { "kind": "nodes", "nodeIds": ["value_1"] }
7410 ],
7411 "activeRangeIndex": 0
7412 },
7413 "cursor": {
7414 "kind": "canvas",
7415 "x": 12.0,
7416 "y": 34.0
7417 },
7418 "updatedAt": "2026-06-22T00:00:01.000Z",
7419 "expiresAt": "2026-06-22T00:05:01.000Z"
7420 })
7421 }
7422
7423 fn value_f32_ports_current_json() -> Value {
7424 json!([
7425 {
7426 "id": "in",
7427 "direction": "input",
7428 "label": "In",
7429 "type": "message.any",
7430 "rate": "event",
7431 "required": false,
7432 "triggerMode": "trigger"
7433 },
7434 {
7435 "id": "cold",
7436 "direction": "input",
7437 "label": "Cold",
7438 "type": "number.float",
7439 "rate": "control",
7440 "required": false,
7441 "triggerMode": "latched"
7442 },
7443 {
7444 "id": "value",
7445 "direction": "output",
7446 "label": "Value",
7447 "type": "number.float",
7448 "rate": "control"
7449 }
7450 ])
7451 }
7452}