Skip to main content

skenion_runtime/
server.rs

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, &current_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}