From 4b8545d57d34635730772ddb278e8f81fe0d0f7d Mon Sep 17 00:00:00 2001 From: "sorokin.oleg.edu" Date: Sat, 5 Sep 2026 20:48:39 +0300 Subject: [PATCH] Add reproducible three-participant routing workshop --- crates/oa-core/examples/routing_workshop.rs | 579 ++++ examples/routing-workshop.arcadia | 2043 ++++++++++++ examples/routing-workshop.json | 3165 +++++++++++++++++++ 3 files changed, 5787 insertions(+) create mode 100644 crates/oa-core/examples/routing_workshop.rs create mode 100644 examples/routing-workshop.arcadia create mode 100644 examples/routing-workshop.json diff --git a/crates/oa-core/examples/routing_workshop.rs b/crates/oa-core/examples/routing_workshop.rs new file mode 100644 index 00000000..90bd395a --- /dev/null +++ b/crates/oa-core/examples/routing_workshop.rs @@ -0,0 +1,579 @@ +//! A repeatable native routing exercise built on the complete coastal-rescue model. +//! cargo run --locked -p oa-core --example routing_workshop [output-directory] +use oa_core::*; +use std::{collections::BTreeMap, path::PathBuf}; + +fn identity(alias: &str) -> Id { + Id::new_v5( + &Id::NAMESPACE_URL, + format!("urn:arcadia-studio:routing-workshop:{alias}").as_bytes(), + ) +} +fn find(p: &Project, alias: &str) -> Id { + p.identities() + .into_iter() + .find(|(_, name)| *name == alias) + .unwrap_or_else(|| panic!("Missing example object: {alias}")) + .0 +} +fn stable_identities(p: &Project) -> Project { + // Demo placement aliases otherwise use random suffixes when an element is + // shown in several views. Their diagram + element pair is the durable key. + let mut commands = vec![]; + for d in p.diagrams.values() { + for n in d.nodes.values() { + commands.push(Command::SetAlias( + n.id, + format!("{}_{}", d.alias, p.elements[&n.element].alias), + )); + } + } + let mut stable = execute_batch(p, &commands).unwrap(); + let ids: Vec<_> = stable + .identities() + .into_iter() + .map(|(id, alias)| (id, identity(alias))) + .filter(|(old, new)| old != new) + .collect(); + for (old, new) in ids { + stable = execute_batch(&stable, &[Command::Reidentify(old, new)]).unwrap(); + } + stable +} +fn add( + p: &mut Project, + kind: Kind, + layer: Layer, + alias: &str, + name: &str, + parent: Option, +) -> Id { + let mut element = p.make_element(kind, layer, name, parent).unwrap(); + element.id = identity(alias); + element.alias = alias.into(); + p.elements.insert(element.id, element); + identity(alias) +} +fn relation( + p: &mut Project, + kind: RelationKind, + alias: &str, + name: &str, + source: Id, + target: Id, +) -> Id { + let id = identity(alias); + p.relations.insert( + id, + Relation { + id, + alias: alias.into(), + name: name.into(), + description: String::new(), + body: RelationBody::new(kind, source, target), + }, + ); + id +} +fn group( + p: &mut Project, + layer: Layer, + owner: Id, + parent: Id, + existing: Option, + prefix: &str, + names: [&str; 3], +) -> [Id; 3] { + let kind = if layer == Layer::Oa { + Kind::Activity + } else { + Kind::Function + }; + let root = add( + p, + kind, + layer, + &format!("{prefix}_work"), + names[0], + Some(parent), + ); + let first = existing.unwrap_or_else(|| { + add( + p, + kind, + layer, + &format!("{prefix}_first"), + names[1], + Some(root), + ) + }); + let first_element = p.elements.get_mut(&first).unwrap(); + first_element.parent = Some(root); + first_element.name = names[1].into(); + let second = add( + p, + kind, + layer, + &format!("{prefix}_second"), + names[2], + Some(root), + ); + for (index, work) in [first, second].into_iter().enumerate() { + if !p.relations.values().any(|r| { + r.kind() == RelationKind::Allocation && r.source() == owner && r.target() == work + }) { + relation( + p, + RelationKind::Allocation, + &format!("{prefix}_allocation_{index}"), + &format!("{} performs {}", p.named(owner), p.named(work)), + owner, + work, + ); + } + } + [root, first, second] +} +fn interaction(p: &mut Project, alias: &str, name: &str, source: Id, target: Id, item: Id) -> Id { + let id = relation(p, RelationKind::Interaction, alias, name, source, target); + p.relations.get_mut(&id).unwrap().body = RelationBody::Interaction { + source, + target, + items: vec![item], + }; + id +} +fn functional(p: &mut Project, alias: &str, name: &str, source: Id, target: Id, item: Id) -> Id { + let request = FunctionalExchangeRequest { + id: identity(alias), + alias: alias.into(), + name: name.into(), + description: String::new(), + source, + target, + source_port: PortChoice::Auto, + target_port: PortChoice::Auto, + items: vec![item], + }; + *p = execute_batch(p, &plan_functional_exchange(p, &request).unwrap()).unwrap(); + request.id +} +fn boundary(p: &mut Project, fe: Id, alias: &str, name: &str, kind: ComponentPortKind) { + let request = ComponentExchangeRequest { + functional_exchange: fe, + boundary: ComponentExchangeChoice::Create { + id: identity(alias), alias: alias.into(), name: name.into(), + description: "Component exchange explicitly implements its function exchange through allocated typed ports.".into(), + port_kind: kind, oriented: kind == ComponentPortKind::Flow, + source_port: PortChoice::Create, target_port: PortChoice::Create, + }, + }; + *p = execute_batch(p, &plan_component_exchange(p, &request).unwrap()).unwrap(); +} +fn architecture(p: &mut Project, layer: Layer, participants: [Id; 3], groups: [[Id; 3]; 3]) { + let diagram = p + .diagrams + .values() + .find(|d| d.layer == layer && d.projection == ProjectionKind::Allocation) + .unwrap() + .id; + let d = p.diagrams.get_mut(&diagram).unwrap(); + d.name = format!("{layer} routing workshop"); + d.description = "Three participants: vessel, coastal relay, rescue team. Direct vessel-to-rescue exchanges pass around the relay. Select an exchange and drag a segment to add a bend; move its label, then undo. The incident decision stays inside Rescue: move the whole container to carry both endpoint pins. Fold/unfold and save/reopen to check preservation. Allocation summaries are nested inside participants; semantic decomposition remains separate.".into(); + d.nodes.clear(); + d.routes.clear(); + for (index, (participant, works)) in participants.into_iter().zip(groups).enumerate() { + let x = 40. + index as f32 * 340.; + for (element, position, size) in [ + ( + participant, + Position { x, y: 40. }, + Size { + width: 272., + height: 600., + }, + ), + ( + works[0], + Position { + x: x + 24., + y: 112., + }, + Size { + width: 224., + height: 384., + }, + ), + ( + works[1], + Position { + x: x + 48., + y: 184., + }, + Size { + width: 176., + height: 132., + }, + ), + ( + works[2], + Position { + x: x + 48., + y: 344., + }, + Size { + width: 176., + height: 132., + }, + ), + ] { + let id = p.place(diagram, element, position); + p.diagrams + .get_mut(&diagram) + .unwrap() + .nodes + .get_mut(&id) + .unwrap() + .size = size; + } + } +} +fn trace(p: &mut Project, oa: Id, sa: Id, alias: &str, kind: TraceKind) { + let id = identity(alias); + p.traces.insert( + id, + Trace { + id, + alias: alias.into(), + name: format!("{} ↔ {}", p.named(oa), p.named(sa)), + description: "OA/SA correspondence in the routing workshop.".into(), + oa, + sa, + kind, + baseline: None, + }, + ); +} +fn workshop() -> Project { + let mut p = stable_identities(&Project::demo()); + p.name = "Coastal rescue · Routing workshop".into(); + p.description = "A three-participant OA/SA exercise for readable connection routing. Begin in an allocation view. Direct exchanges detour around the coastal relay; nested work belongs to its actual performer. SA includes typed functional endpoints, Flow and Standard component exchanges, explicit port/exchange allocations and an internal incident-decision exchange. Add bends and move labels, drag one endpoint or the entire Rescue container, fold/unfold, undo, and save/reopen. Other original engineering views and behavior remain available.".into(); + let oa_root = find(&p, "respond_to_distress"); + let sa_root = find(&p, "manage_distress_response"); + let oa_vessel = find(&p, "vessel_in_distress"); + let oa_rescue = find(&p, "rescue_coordination"); + let sa_vessel = find(&p, "vessel_communication_service"); + let sa_rescue = find(&p, "rescue_coordination_system"); + let oa_report = find(&p, "report_distress"); + let oa_assess = find(&p, "assess_incident"); + let sa_report = find(&p, "transmit_distress_report"); + let sa_assess = find(&p, "classify_incident_and_alert_operator"); + let oa_report_item = find(&p, "distress_report"); + let sa_report_item = find(&p, "digital_distress_report"); + let oa_relay = add( + &mut p, + Kind::Entity, + Layer::Oa, + "oa_coastal_relay", + "Coastal relay", + None, + ); + let sa_relay = add( + &mut p, + Kind::SystemActor, + Layer::Sa, + "sa_coastal_relay", + "Coastal relay", + None, + ); + for (id, name) in [ + (oa_vessel, "Vessel"), + (oa_rescue, "Rescue team"), + (sa_vessel, "Vessel service"), + (sa_rescue, "Rescue system"), + ] { + p.elements.get_mut(&id).unwrap().name = name.into(); + } + let ov = group( + &mut p, + Layer::Oa, + oa_vessel, + oa_root, + Some(oa_report), + "oa_vessel", + ["Vessel contact", "Report distress", "Confirm advice"], + ); + let or = group( + &mut p, + Layer::Oa, + oa_relay, + oa_root, + None, + "oa_relay", + ["Coastal traffic", "Forward report", "Forward advice"], + ); + let oc = group( + &mut p, + Layer::Oa, + oa_rescue, + oa_root, + Some(oa_assess), + "oa_rescue", + ["Rescue response", "Assess incident", "Send advice"], + ); + let sv = group( + &mut p, + Layer::Sa, + sa_vessel, + sa_root, + Some(sa_report), + "sa_vessel", + ["Vessel contact", "Send distress", "Confirm advice"], + ); + let sr = group( + &mut p, + Layer::Sa, + sa_relay, + sa_root, + None, + "sa_relay", + ["Coastal traffic", "Forward report", "Forward advice"], + ); + let sc = group( + &mut p, + Layer::Sa, + sa_rescue, + sa_root, + Some(sa_assess), + "sa_rescue", + ["Rescue response", "Assess incident", "Send advice"], + ); + let oa_advice = add( + &mut p, + Kind::ExchangeItem, + Layer::Oa, + "oa_safety_advice", + "Safety advice", + None, + ); + let sa_advice = add( + &mut p, + Kind::ExchangeItem, + Layer::Sa, + "sa_safety_advice", + "Safety advice", + None, + ); + let mut mapped_exchanges = vec![]; + let pairs = [ + ( + "report_to_relay", + "Report to relay", + ov[1], + or[1], + sv[1], + sr[1], + oa_report_item, + sa_report_item, + ), + ( + "relay_to_rescue", + "Relayed report", + or[1], + oc[1], + sr[1], + sc[1], + oa_report_item, + sa_report_item, + ), + ( + "incident_decision", + "Incident decision", + oc[1], + oc[2], + sc[1], + sc[2], + oa_advice, + sa_advice, + ), + ( + "advice_to_relay", + "Advice to relay", + oc[2], + or[2], + sc[2], + sr[2], + oa_advice, + sa_advice, + ), + ( + "advice_to_vessel", + "Relayed advice", + or[2], + ov[2], + sr[2], + sv[2], + oa_advice, + sa_advice, + ), + ( + "direct_advice", + "Direct advice", + oc[2], + ov[2], + sc[2], + sv[2], + oa_advice, + sa_advice, + ), + ]; + for (key, name, oa_source, oa_target, sa_source, sa_target, oa_item, sa_item) in pairs { + let oa = interaction( + &mut p, + &format!("oa_{key}"), + name, + oa_source, + oa_target, + oa_item, + ); + let sa = functional( + &mut p, + &format!("sa_{key}"), + name, + sa_source, + sa_target, + sa_item, + ); + mapped_exchanges.push((oa, sa, format!("trace_{key}"))); + } + for (fe, alias, name, kind) in [ + ( + identity("sa_report_to_relay"), + "vessel_relay_channel", + "Vessel relay channel", + ComponentPortKind::Flow, + ), + ( + identity("sa_relay_to_rescue"), + "relay_rescue_service", + "Relay rescue service", + ComponentPortKind::Standard, + ), + ( + identity("sa_advice_to_relay"), + "rescue_advice_service", + "Rescue advice service", + ComponentPortKind::Standard, + ), + ( + identity("sa_advice_to_vessel"), + "relay_vessel_channel", + "Relay vessel channel", + ComponentPortKind::Flow, + ), + ] { + boundary(&mut p, fe, alias, name, kind); + } + trace( + &mut p, + oa_relay, + sa_relay, + "trace_coastal_relay", + TraceKind::Participant, + ); + trace( + &mut p, + oa_advice, + sa_advice, + "trace_safety_advice", + TraceKind::Item, + ); + for (oa, sa, key) in mapped_exchanges { + trace(&mut p, oa, sa, &key, TraceKind::Exchange); + } + for (oa, sa) in ov + .into_iter() + .zip(sv) + .chain(or.into_iter().zip(sr)) + .chain(oc.into_iter().zip(sc)) + { + if !p.traces.values().any(|t| t.oa == oa && t.sa == sa) { + let key = format!("trace_workshop_{}", p.elements[&oa].alias); + trace(&mut p, oa, sa, &key, TraceKind::Refinement); + } + } + for id in p.traces.keys().copied().collect::>() { + let t = &p.traces[&id]; + let baseline = TraceBaseline { + oa: p.properties(t.oa).unwrap(), + sa: p.properties(t.sa).unwrap(), + }; + p.traces.get_mut(&id).unwrap().baseline = Some(baseline); + } + architecture( + &mut p, + Layer::Oa, + [oa_vessel, oa_relay, oa_rescue], + [ov, or, oc], + ); + architecture( + &mut p, + Layer::Sa, + [sa_vessel, sa_relay, sa_rescue], + [sv, sr, sc], + ); + p = stable_identities(&p); + let layouts: Vec<_> = p + .diagrams + .values() + .filter(|d| d.projection != ProjectionKind::Allocation) + .map(|d| Command::Layout(d.id)) + .collect(); + execute_batch(&p, &layouts).unwrap() +} +fn main() -> Result<(), Box> { + let directory = std::env::args_os() + .nth(1) + .map(PathBuf::from) + .unwrap_or_else(|| PathBuf::from("examples")); + let p = workshop(); + assert_eq!( + p, + workshop(), + "Workshop identities, aliases and layout must be reproducible" + ); + let issues = validation::validate(&p); + assert!(issues.is_empty(), "Workshop model diagnostics: {issues:?}"); + for layer in [Layer::Oa, Layer::Sa] { + let d = p + .diagrams + .values() + .find(|d| d.layer == layer && d.projection == ProjectionKind::Allocation) + .unwrap(); + let view = projection::project_view(&p, d.id); + let routed = routing::route_diagram(&p, d, &view); + let warnings: BTreeMap<_, _> = routed + .edges + .values() + .filter(|r| !r.warnings.is_empty()) + .map(|r| (p.named(r.id), &r.warnings)) + .collect(); + println!( + "{layer}: {} nested cards, {} exchanges, route warnings: {warnings:?}", + view.nodes.len(), + routed.edges.len() + ); + } + let source = directory.join("routing-workshop.arcadia"); + let json = directory.join("routing-workshop.json"); + persistence::save(&source, &p)?; + persistence::save(&json, &p)?; + assert_eq!(persistence::load(&source)?, p); + assert_eq!(persistence::load(&json)?, p); + println!( + "Wrote and verified {} and {}", + source.display(), + json.display() + ); + Ok(()) +} diff --git a/examples/routing-workshop.arcadia b/examples/routing-workshop.arcadia new file mode 100644 index 00000000..d136d37e --- /dev/null +++ b/examples/routing-workshop.arcadia @@ -0,0 +1,2043 @@ +arcadia 3; +project mission "Coastal rescue · Routing workshop" id "11a78443-e910-5631-99ff-f8c7b56dbc78" { + description "A three-participant OA/SA exercise for readable connection routing. Begin in an allocation view. Direct exchanges detour around the coastal relay; nested work belongs to its actual performer. SA includes typed functional endpoints, Flow and Standard component exchanges, explicit port/exchange allocations and an internal incident-decision exchange. Add bends and move labels, drag one endpoint or the entire Rescue container, fold/unfold, undo, and save/reopen. Other original engineering views and behavior remain available."; + + sa_lifeline coordination_system_lifeline "Coordination system lifeline" id "01c7e1ab-5889-5bcb-a028-e678cec2673b" { + description ""; + parent @repeated_distress_reports; + represented @rescue_coordination_system; + } + + sa_port relayed_report_output "Relayed report output" id "042ae2f7-cc3f-557e-bb1f-4179c57f9314" { + contract { + FunctionOutput { + outgoing_items [@digital_distress_report]; + }; + }; + description ""; + legacy none; + parent @sa_relay_first; + } + + sa_occurrence report_handled "Report handled" id "04dd0e11-8ec8-5abf-869e-8d718b587b63" { + body { + Exchange { + exchange @validated_distress_report; + message_kind Asynchronous; + receiver none; + reply_to none; + sender none; + values []; + }; + }; + description ""; + parent @digital_distress_handling; + postcondition ""; + precondition ""; + } + + oa_occurrence distress_received "Distress received" id "06355b22-2b30-561c-8cfe-6eb5eccefec6" { + body { + Exchange { + exchange @distress_signal; + message_kind Asynchronous; + receiver none; + reply_to none; + sender none; + values []; + }; + }; + description ""; + parent @distress_to_response; + postcondition ""; + precondition ""; + } + + sa_exchange_item digital_distress_report "Digital distress report" id "080677b3-a619-5da3-906b-bfe69327eb57" { + description ""; + kind Information; + parent none; + } + + sa_state_machine reporting_operation_modes "Reporting operation modes" id "08559968-aff0-5c3b-8694-9320a82d71a8" { + description ""; + parent @rescue_coordination_system; + } + + sa_actor sa_coastal_relay "Coastal relay" id "0aa33dc1-57eb-5307-9dcc-c566682c99f7" { + description ""; + parent none; + } + + sa_port incident_decision_output "Incident decision output" id "0e32a460-aa56-543b-a3db-e7711c3fcd38" { + contract { + FunctionOutput { + outgoing_items [@sa_safety_advice]; + }; + }; + description ""; + legacy none; + parent @classify_incident_and_alert_operator; + } + + sa_port relayed_advice_input "Relayed advice input" id "11869f64-77ae-512c-b8f5-5a0789585462" { + contract { + FunctionInput { + incoming_items [@sa_safety_advice]; + }; + }; + description ""; + legacy none; + parent @sa_vessel_second; + } + + sa_function sa_rescue_work "Rescue response" id "14f31813-a548-595b-a217-34412c1692ab" { + description ""; + parent @manage_distress_response; + } + + oa_activity report_distress "Report distress" id "184a46a3-9695-5b47-a736-880e18775e09" { + description ""; + parent @oa_vessel_work; + } + + sa_port system_reporting_input "System reporting input" id "1ccd767f-b813-5884-a5ba-59bdc92b6f87" { + contract { + Component { + kind Flow; + orientation In; + }; + }; + description ""; + legacy none; + parent @rescue_coordination_system; + } + + sa_port relay_rescue_service_target_port "Relay rescue service target port" id "1d5347b0-b75d-5c49-b523-0a4629cc941c" { + contract { + Component { + kind Standard; + orientation Unset; + }; + }; + description ""; + legacy none; + parent @rescue_coordination_system; + } + + sa_port incident_decision_input "Incident decision input" id "26a15868-7fc7-5397-b7db-b2ad77c19080" { + contract { + FunctionInput { + incoming_items [@sa_safety_advice]; + }; + }; + description ""; + legacy none; + parent @sa_rescue_second; + } + + sa_port relay_vessel_channel_target_port "Relay vessel channel target port" id "2c578ec2-025a-501c-a555-0fdc5be20a84" { + contract { + Component { + kind Flow; + orientation In; + }; + }; + description ""; + legacy none; + parent @vessel_communication_service; + } + + sa_mission support_timely_rescue_decisions "Support timely rescue decisions" id "2fbbd555-56c5-5bf9-83a3-ca137a9961a8" { + description ""; + parent none; + } + + sa_system rescue_coordination_system "Rescue system" id "30fc41ea-fc3d-5b57-9a05-67b14425fad9" { + description ""; + parent none; + } + + sa_port rescue_advice_service_target_port "Rescue advice service target port" id "3437906b-93a6-54a7-a0ef-b1169efec392" { + contract { + Component { + kind Standard; + orientation Unset; + }; + }; + description ""; + legacy none; + parent @sa_coastal_relay; + } + + oa_activity oa_rescue_second "Send advice" id "36164305-7318-5777-bb37-1b69796bba35" { + description ""; + parent @oa_rescue_work; + } + + sa_interface distress_reporting_interface "Distress reporting interface" id "38ff891a-d2a0-5b4a-8801-2ce08f9d3ff3" { + description ""; + items [@digital_distress_report]; + parent none; + } + + sa_actor vessel_communication_service "Vessel service" id "3eafabe6-d6ca-5127-a660-d81213347de0" { + description ""; + parent none; + } + + sa_function sa_relay_work "Coastal traffic" id "3fc7b01b-75f4-53bf-bd31-b9840efe36fb" { + description ""; + parent @manage_distress_response; + } + + oa_activity respond_to_distress "Respond to distress" id "40078074-1925-5b68-8640-ecca13bd3c32" { + description ""; + parent none; + } + + sa_function manage_distress_response "Manage distress response" id "4099917c-0e9c-5535-8b89-6dc614a2f0c9" { + description ""; + parent none; + } + + oa_exchange_item oa_safety_advice "Safety advice" id "435cc548-f6f7-5fdb-bfb6-0bb68a8deb04" { + description ""; + kind Information; + parent none; + } + + sa_event validated_report_received "Validated report received" id "44358153-d6d0-594c-a81e-23df696e97f2" { + body { + Signal { + items [@digital_distress_report]; + }; + }; + description ""; + parent none; + } + + sa_function sa_relay_second "Forward advice" id "4656d08f-158b-53eb-b368-e53083dfaed5" { + description ""; + parent @sa_relay_work; + } + + sa_port report_to_relay_input "Report to relay input" id "478467e4-5449-51ca-a766-bff105ebcf60" { + contract { + FunctionInput { + incoming_items [@digital_distress_report]; + }; + }; + description ""; + legacy none; + parent @sa_relay_first; + } + + sa_port report_function_output "Report function output" id "580030e9-a2b7-5b45-b6c1-f201e73cf0fd" { + contract { + FunctionOutput { + outgoing_items [@digital_distress_report]; + }; + }; + description ""; + legacy none; + parent @transmit_distress_report; + } + + sa_port vessel_relay_channel_source_port "Vessel relay channel source port" id "59ed66a8-3cee-521f-91b1-c8e75b521ebc" { + contract { + Component { + kind Flow; + orientation Out; + }; + }; + description ""; + legacy none; + parent @vessel_communication_service; + } + + oa_activity oa_relay_work "Coastal traffic" id "5c84fe4d-b5a7-5dd2-a4da-3ee03803c138" { + description ""; + parent @respond_to_distress; + } + + oa_activity oa_vessel_work "Vessel contact" id "5cf70948-ec50-5caf-bca9-fedaeb5f971c" { + description ""; + parent @respond_to_distress; + } + + sa_constraint response_time_budget "Response time budget" id "604d15ea-3f36-5ee1-9792-755e9e745be1" { + constrained [@classify_incident_and_alert_operator, @validated_distress_report]; + description ""; + expression "incident_alert_latency <= 120 s"; + parent none; + } + + oa_entity oa_coastal_relay "Coastal relay" id "606b870d-be72-5f5b-8067-bcaea1b3e70e" { + description ""; + parent none; + } + + sa_functional_chain digital_distress_handling "Digital distress handling" id "608fdf4f-e596-5b7e-aa79-2c6656cb2970" { + description ""; + parent none; + steps [@report_handled]; + } + + sa_occurrence updated_distress_report "Updated distress report" id "65ab9712-85cc-533a-8307-1dced5ac3806" { + body { + Exchange { + exchange @validated_distress_report; + message_kind Asynchronous; + receiver @coordination_system_lifeline; + reply_to none; + sender @vessel_service_lifeline; + values []; + }; + }; + description ""; + parent @repeated_distress_reports; + postcondition "The incident position is refreshed without creating a second incident."; + precondition "The vessel has more recent position information."; + } + + sa_port rescue_advice_service_source_port "Rescue advice service source port" id "6709bf44-4abe-5999-838f-4b34ac15af65" { + contract { + Component { + kind Standard; + orientation Unset; + }; + }; + description ""; + legacy none; + parent @rescue_coordination_system; + } + + oa_activity oa_relay_second "Forward advice" id "69295b0a-afb4-503c-b98e-783f2429802a" { + description ""; + parent @oa_relay_work; + } + + oa_role incident_coordinator "Incident coordinator" id "7480cf74-67aa-5772-957a-1ba8f1b45918" { + description ""; + parent none; + } + + sa_port advice_to_relay_input "Advice to relay input" id "7742a141-0dfa-57b5-9aa7-9c94f81c8e7c" { + contract { + FunctionInput { + incoming_items [@sa_safety_advice]; + }; + }; + description ""; + legacy none; + parent @sa_relay_second; + } + + sa_scenario repeated_distress_reports "Repeated distress reports" id "7837308c-b1d3-5002-877d-52a14c9d8403" { + context @coordinate_rescue_response; + description ""; + parent none; + postcondition "The operator has a classified incident with the latest vessel report."; + precondition "A vessel has detected an emergency and the reporting service is available."; + steps [@initial_distress_report, @updated_distress_report]; + viewpoint BoundaryInterface; + } + + sa_port relay_vessel_channel_source_port "Relay vessel channel source port" id "78c1dd6d-9755-5ed5-ba9b-39d17a397631" { + contract { + Component { + kind Flow; + orientation Out; + }; + }; + description ""; + legacy none; + parent @sa_coastal_relay; + } + + sa_port relayed_advice_output "Relayed advice output" id "7a42b274-3f40-592e-a499-33256bb10d10" { + contract { + FunctionOutput { + outgoing_items [@sa_safety_advice]; + }; + }; + description ""; + legacy none; + parent @sa_relay_second; + } + + oa_process distress_to_response "Distress to response" id "7ef353cf-a4e3-56d2-bd3d-9d86cf2885a7" { + description ""; + parent none; + steps [@distress_received]; + } + + sa_data_field reported_latitude "Reported latitude" id "875e6bbe-6b1f-5fc2-a2e4-82858053010b" { + description ""; + maximum 1; + minimum 1; + parent @digital_distress_report; + type_ref Real; + unit "degrees north"; + } + + sa_function sa_relay_first "Forward report" id "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436" { + description ""; + parent @sa_relay_work; + } + + oa_capability protect_life_at_sea "Protect life at sea" id "8c1deb44-f362-56d5-9297-8ec84dd3cb4d" { + description ""; + parent none; + } + + sa_function sa_vessel_work "Vessel contact" id "95fcc41c-81c3-5183-8b7d-f6d7e2a0f67c" { + description ""; + parent @manage_distress_response; + } + + oa_activity oa_rescue_work "Rescue response" id "97f7bcde-b8d8-56b2-ac5c-740506c38166" { + description ""; + parent @respond_to_distress; + } + + sa_port assessment_function_input "Assessment function input" id "a470347f-e342-5e82-9610-8b86b5997c7d" { + contract { + FunctionInput { + incoming_items [@digital_distress_report]; + }; + }; + description ""; + legacy none; + parent @classify_incident_and_alert_operator; + } + + sa_function classify_incident_and_alert_operator "Assess incident" id "b05744bd-4dce-54b7-a9ff-8861d11dc1e0" { + description ""; + parent @sa_rescue_work; + } + + oa_activity assess_incident "Assess incident" id "b065b859-8b5e-5295-b214-69a2e7c3d4bb" { + description ""; + parent @oa_rescue_work; + } + + sa_function sa_rescue_second "Send advice" id "b8896811-d893-50fc-b695-d2ee07dae9e3" { + description ""; + parent @sa_rescue_work; + } + + sa_mode degraded_reporting "Degraded reporting" id "ba2543c5-4160-5412-a542-5910cac0239f" { + description ""; + do_activity ""; + entry ""; + exit ""; + kind Mode; + parent @reporting_quality_region; + } + + sa_port advice_to_relay_output "Advice to relay output" id "bdbab719-3b60-5e1b-90be-3904630081b6" { + contract { + FunctionOutput { + outgoing_items [@sa_safety_advice]; + }; + }; + description ""; + legacy none; + parent @sa_rescue_second; + } + + sa_port vessel_relay_channel_target_port "Vessel relay channel target port" id "c0460c14-0b7e-58fb-aa77-a39f504b70b0" { + contract { + Component { + kind Flow; + orientation In; + }; + }; + description ""; + legacy none; + parent @sa_coastal_relay; + } + + sa_port vessel_reporting_output "Vessel reporting output" id "c385285d-5541-53b2-bb2d-17b643c2c19c" { + contract { + Component { + kind Flow; + orientation Out; + }; + }; + description ""; + legacy none; + parent @vessel_communication_service; + } + + sa_exchange_item sa_safety_advice "Safety advice" id "c53454d5-4cb3-53ee-bfaa-8506795fd89c" { + description ""; + kind Information; + parent none; + } + + sa_occurrence initial_distress_report "Initial distress report" id "c86b3ac8-e147-50f8-a9f5-09798ac062a5" { + body { + Exchange { + exchange @validated_distress_report; + message_kind Asynchronous; + receiver @coordination_system_lifeline; + reply_to none; + sender @vessel_service_lifeline; + values []; + }; + }; + description ""; + parent @repeated_distress_reports; + postcondition ""; + precondition ""; + } + + sa_exchange_item rescue_supply_package "Rescue supply package" id "cca50e54-6d10-5dbe-b587-8456c44f1423" { + description ""; + kind Material; + parent none; + } + + oa_activity oa_vessel_second "Confirm advice" id "cd43dcb2-d417-5f7c-a065-2f79b7759b6d" { + description ""; + parent @oa_vessel_work; + } + + oa_entity rescue_coordination "Rescue team" id "ddb01361-5d9e-5a45-87be-58ac4755ef03" { + description ""; + parent none; + } + + sa_initial start_reporting "Start reporting" id "ddb29f91-7994-597d-a5a0-1b4fccbae98d" { + description ""; + do_activity ""; + entry ""; + exit ""; + kind Initial; + parent @reporting_quality_region; + } + + oa_exchange_item distress_report "Distress report" id "e545eb5b-109f-5862-8a15-ed40cc564035" { + description ""; + kind Information; + parent none; + } + + sa_event report_timeout "Report timeout" id "e67467e4-2f3a-51e3-9a3b-4b66cad4e864" { + body { + Time { + expression "30 s"; + kind After; + }; + }; + description ""; + parent none; + } + + sa_capability coordinate_rescue_response "Coordinate rescue response" id "e6832e4f-9352-5a22-87b6-0c06b3140d50" { + description ""; + parent none; + } + + sa_region reporting_quality_region "Reporting quality region" id "eb386aca-837a-5da8-8d4b-a8d625a929ce" { + description ""; + parent @reporting_operation_modes; + } + + oa_activity oa_relay_first "Forward report" id "eb85c896-ed8f-5eb4-a9ad-3f3a817c3f2e" { + description ""; + parent @oa_relay_work; + } + + sa_lifeline vessel_service_lifeline "Vessel service lifeline" id "f2a19487-09d4-5ccc-989f-2df128779d97" { + description ""; + parent @repeated_distress_reports; + represented @vessel_communication_service; + } + + oa_actor vessel_in_distress "Vessel" id "f2bb5075-31b6-586c-8e53-7df0d7478cf4" { + description ""; + parent none; + } + + sa_function transmit_distress_report "Send distress" id "f5497540-43a7-5573-826b-61eb7e4760a9" { + description ""; + parent @sa_vessel_work; + } + + sa_port relay_rescue_service_source_port "Relay rescue service source port" id "f62cad4b-5205-5722-8242-a217f78deb6e" { + contract { + Component { + kind Standard; + orientation Unset; + }; + }; + description ""; + legacy none; + parent @sa_coastal_relay; + } + + sa_mode normal_reporting "Normal reporting" id "fc058344-b767-53e3-9cbc-dca4cb62a189" { + description ""; + do_activity ""; + entry ""; + exit ""; + kind Mode; + parent @reporting_quality_region; + } + + sa_exchange_item backup_electrical_energy "Backup electrical energy" id "fd38ab55-4a4d-5fce-9fe8-3fcb068a2fd1" { + description ""; + kind Energy; + parent none; + } + + sa_function sa_vessel_second "Confirm advice" id "febf00a2-efed-5faf-b8c2-5d4bc77ddb53" { + description ""; + parent @sa_vessel_work; + } + + allocation sa_relay_allocation_0 "Coastal relay performs Forward report" id "05bd56e5-ffd0-574f-a02a-ad3826195c8f" { + description ""; + source @sa_coastal_relay; + target @sa_relay_first; + } + + boundary_exchange vessel_relay_channel "Vessel relay channel" id "06cd50be-286d-51d5-8828-1adf6d51d61c" { + description "Component exchange explicitly implements its function exchange through allocated typed ports."; + items [@digital_distress_report]; + oriented true; + source @vessel_relay_channel_source_port; + target @vessel_relay_channel_target_port; + } + + exchange_allocation report_carried_by_connection "Report carried by connection" id "072c7c4c-d44c-5bf5-9b9f-6db0bd31ece8" { + description ""; + source @distress_reporting_connection; + target @validated_distress_report; + } + + functional_exchange sa_advice_to_vessel "Relayed advice" id "076628bf-719a-52f1-a30f-e479e057b4e9" { + description ""; + items [@sa_safety_advice]; + source @sa_relay_second; + source_port @relayed_advice_output; + target @sa_vessel_second; + target_port @relayed_advice_input; + } + + port_allocation vessel_relay_channel_target_port_report_to_relay_input "Vessel relay channel target port / Report to relay input" id "0769b6ae-cc70-580e-aa81-8725dce8cbdb" { + description ""; + source @vessel_relay_channel_target_port; + target @report_to_relay_input; + } + + port_allocation relay_vessel_channel_target_port_relayed_advice_input "Relay vessel channel target port / Relayed advice input" id "0782ac98-8c77-5e31-89ff-b7a98cf0e63e" { + description ""; + source @relay_vessel_channel_target_port; + target @relayed_advice_input; + } + + exchange_allocation vessel_relay_channel_report_to_relay "Vessel relay channel / Report to relay" id "11e2d27e-7379-5998-9bb3-44a2806c4dec" { + description ""; + source @vessel_relay_channel; + target @sa_report_to_relay; + } + + allocation oa_relay_allocation_0 "Coastal relay performs Forward report" id "128cb779-a76a-508d-a63b-f9555cc6d1f0" { + description ""; + source @oa_coastal_relay; + target @oa_relay_first; + } + + allocation oa_vessel_allocation_1 "Vessel performs Confirm advice" id "186f8744-39ea-554e-ada8-fa582e0d4555" { + description ""; + source @vessel_in_distress; + target @oa_vessel_second; + } + + exchange_allocation relay_rescue_service_relayed_report "Relay rescue service / Relayed report" id "1c6fc775-9bfd-5f95-b6e6-7858b9bb183f" { + description ""; + source @relay_rescue_service; + target @sa_relay_to_rescue; + } + + interface_requirement reporting_service_required "Reporting service required" id "2053a89e-136e-547b-b722-5757cf4a53f2" { + description ""; + source @system_reporting_input; + target @distress_reporting_interface; + } + + boundary_exchange relay_rescue_service "Relay rescue service" id "22c7011d-b559-5df8-aadd-851002904ba0" { + description "Component exchange explicitly implements its function exchange through allocated typed ports."; + items [@digital_distress_report]; + oriented false; + source @relay_rescue_service_source_port; + target @relay_rescue_service_target_port; + } + + state_action review_on_degraded_entry "Review on degraded entry" id "292c88e4-389c-5074-aa66-85a09752c31d" { + description ""; + phase Entry; + source @degraded_reporting; + target @classify_incident_and_alert_operator; + } + + port_allocation relay_rescue_service_source_port_relayed_report_output "Relay rescue service source port / Relayed report output" id "2c68a11d-1866-5aec-8544-9f2eeb3e90f9" { + description ""; + source @relay_rescue_service_source_port; + target @relayed_report_output; + } + + allocation oa_rescue_allocation_1 "Rescue team performs Send advice" id "30004dfe-8205-5c98-bcd1-af1fe5b086f9" { + description ""; + source @rescue_coordination; + target @oa_rescue_second; + } + + port_allocation vessel_output_represents_report_output "Vessel output represents report output" id "3c6d8af1-7f55-5700-81a6-65bf29df5156" { + description ""; + source @vessel_reporting_output; + target @report_function_output; + } + + functional_exchange sa_report_to_relay "Report to relay" id "4678335a-04ae-5a19-a302-ea583bdd6c65" { + description ""; + items [@digital_distress_report]; + source @transmit_distress_report; + source_port @report_function_output; + target @sa_relay_first; + target_port @report_to_relay_input; + } + + allocation sa_vessel_allocation_1 "Vessel service performs Confirm advice" id "4c081c59-b875-558f-9858-49f56f364c60" { + description ""; + source @vessel_communication_service; + target @sa_vessel_second; + } + + functional_exchange sa_incident_decision "Incident decision" id "526753bc-88b0-5322-bffc-1b36376becf1" { + description ""; + items [@sa_safety_advice]; + source @classify_incident_and_alert_operator; + source_port @incident_decision_output; + target @sa_rescue_second; + target_port @incident_decision_input; + } + + functional_exchange sa_relay_to_rescue "Relayed report" id "61782ac2-5817-5705-8cfc-baa1be5d6cb0" { + description ""; + items [@digital_distress_report]; + source @sa_relay_first; + source_port @relayed_report_output; + target @classify_incident_and_alert_operator; + target_port @assessment_function_input; + } + + boundary_exchange relay_vessel_channel "Relay vessel channel" id "61f2c220-ba4c-5b37-b728-43bba1a677c6" { + description "Component exchange explicitly implements its function exchange through allocated typed ports."; + items [@sa_safety_advice]; + oriented true; + source @relay_vessel_channel_source_port; + target @relay_vessel_channel_target_port; + } + + allocation reports_distress "Reports distress" id "6465eab2-4ca5-5a85-9b0a-efaaf9a0dfb5" { + description ""; + source @vessel_in_distress; + target @report_distress; + } + + interaction oa_advice_to_vessel "Relayed advice" id "659fe810-36bb-50d8-bc55-f761ef1c02d3" { + description ""; + items [@oa_safety_advice]; + source @oa_relay_second; + target @oa_vessel_second; + } + + exchange_allocation relay_vessel_channel_relayed_advice "Relay vessel channel / Relayed advice" id "69bd6da5-f9f9-532c-bab7-621a937204a7" { + description ""; + source @relay_vessel_channel; + target @sa_advice_to_vessel; + } + + chain_involvement operational_realization "Operational realization" id "6a6c76c2-b1e3-5552-83a2-f3526de1cb92" { + description ""; + source @distress_to_response; + target @protect_life_at_sea; + } + + port_allocation vessel_relay_channel_source_port_report_function_output "Vessel relay channel source port / Report function output" id "7415ad08-0c14-540d-a7a2-b191956af2bf" { + description ""; + source @vessel_relay_channel_source_port; + target @report_function_output; + } + + interface_provision reporting_service_provided "Reporting service provided" id "74e6cfd2-aaf2-5112-86d9-dd9885e3ebf6" { + description ""; + source @vessel_reporting_output; + target @distress_reporting_interface; + } + + boundary_exchange rescue_advice_service "Rescue advice service" id "7e39bb6e-c062-54f9-be7d-da1e38327633" { + description "Component exchange explicitly implements its function exchange through allocated typed ports."; + items [@sa_safety_advice]; + oriented false; + source @rescue_advice_service_source_port; + target @rescue_advice_service_target_port; + } + + interaction oa_direct_advice "Direct advice" id "844bdfbe-c481-5055-98b8-ec38a1603769" { + description ""; + items [@oa_safety_advice]; + source @oa_rescue_second; + target @oa_vessel_second; + } + + capability_involvement operational_contribution "Operational contribution" id "86d74a9b-eb32-5cb5-bbf2-8ce043fb0848" { + description ""; + source @assess_incident; + target @protect_life_at_sea; + } + + state_transition signal_restored "Signal restored" id "877ef9bd-0a24-5c5b-9627-0e6de4576655" { + description ""; + effect "Clear the degraded-reporting alert."; + effects []; + guard "position_is_current"; + source @degraded_reporting; + target @normal_reporting; + transition_kind External; + trigger "validated_report_received"; + triggers [@validated_report_received]; + } + + state_transition signal_degraded "Signal degraded" id "8902ac83-cbcd-5e2e-a239-396d93536706" { + description ""; + effect "Flag the incident and request an operator review."; + effects []; + guard "seconds_since_last_report > 30"; + source @normal_reporting; + target @degraded_reporting; + transition_kind External; + trigger "report_timeout"; + triggers [@report_timeout]; + } + + port_allocation relay_rescue_service_target_port_assessment_function_input "Relay rescue service target port / Assessment function input" id "8e23aa50-1e32-5d8c-a93e-f84ffcc95b6f" { + description ""; + source @relay_rescue_service_target_port; + target @assessment_function_input; + } + + boundary_exchange distress_reporting_connection "Distress reporting connection" id "94246bbd-90a5-5c54-a6b3-337013bedc9c" { + description ""; + items [@digital_distress_report]; + oriented true; + source @vessel_reporting_output; + target @system_reporting_input; + } + + functional_exchange sa_direct_advice "Direct advice" id "956d5b0a-1e34-518f-b46d-425751998bbc" { + description ""; + items [@sa_safety_advice]; + source @sa_rescue_second; + source_port @advice_to_relay_output; + target @sa_vessel_second; + target_port @relayed_advice_input; + } + + port_allocation relay_vessel_channel_source_port_relayed_advice_output "Relay vessel channel source port / Relayed advice output" id "9905a581-8457-5ed0-bc19-d9732764796f" { + description ""; + source @relay_vessel_channel_source_port; + target @relayed_advice_output; + } + + chain_involvement functional_chain_support "Functional chain support" id "9a640271-1e5f-5bf1-b208-ce5bb5769341" { + description ""; + source @digital_distress_handling; + target @coordinate_rescue_response; + } + + interaction oa_advice_to_relay "Advice to relay" id "9b930e28-6a0f-5b25-98f0-5aec4f542d90" { + description ""; + items [@oa_safety_advice]; + source @oa_rescue_second; + target @oa_relay_second; + } + + state_transition initialize_reporting "Initialize reporting" id "9c88c83c-f219-5038-890a-da6cf28da5af" { + description ""; + effect ""; + effects []; + guard ""; + source @start_reporting; + target @normal_reporting; + transition_kind External; + trigger ""; + triggers []; + } + + interaction oa_report_to_relay "Report to relay" id "9eaa1fc3-44e0-5091-b117-1358fd8e2a05" { + description ""; + items [@distress_report]; + source @report_distress; + target @oa_relay_first; + } + + allocation system_assessment "System assessment" id "9ffdda44-d7bc-500b-bc5c-dc285e5afc03" { + description ""; + source @rescue_coordination_system; + target @classify_incident_and_alert_operator; + } + + functional_exchange validated_distress_report "Validated distress report" id "a15f7dfd-ac0b-562a-a633-fadc9fb64176" { + description ""; + items [@digital_distress_report]; + source @transmit_distress_report; + source_port @report_function_output; + target @classify_incident_and_alert_operator; + target_port @assessment_function_input; + } + + interaction oa_relay_to_rescue "Relayed report" id "a33b68f1-c297-5bd5-96ab-75bab66b92b1" { + description ""; + items [@distress_report]; + source @oa_relay_first; + target @assess_incident; + } + + allocation oa_relay_allocation_1 "Coastal relay performs Forward advice" id "a4dd4c80-1caf-5a1a-9bcd-e57fa1855706" { + description ""; + source @oa_coastal_relay; + target @oa_relay_second; + } + + allocation vessel_transmission "Vessel transmission" id "aecc4aa0-5345-54ea-82d2-b0e1470e835e" { + description ""; + source @vessel_communication_service; + target @transmit_distress_report; + } + + exchange_allocation rescue_advice_service_advice_to_relay "Rescue advice service / Advice to relay" id "b344b56e-8d5c-54db-97ff-1c9ffde8b210" { + description ""; + source @rescue_advice_service; + target @sa_advice_to_relay; + } + + port_allocation rescue_advice_service_source_port_advice_to_relay_output "Rescue advice service source port / Advice to relay output" id "b6a24785-a891-536d-9636-a0881c2569ad" { + description ""; + source @rescue_advice_service_source_port; + target @advice_to_relay_output; + } + + interaction oa_incident_decision "Incident decision" id "bc6da29f-91fb-5e86-ad07-f714805f344c" { + description ""; + items [@oa_safety_advice]; + source @assess_incident; + target @oa_rescue_second; + } + + functional_exchange sa_advice_to_relay "Advice to relay" id "c89e57d4-c77e-5f29-8000-b1d9182a4596" { + description ""; + items [@sa_safety_advice]; + source @sa_rescue_second; + source_port @advice_to_relay_output; + target @sa_relay_second; + target_port @advice_to_relay_input; + } + + mission_capability mission_capability "Mission capability" id "cff93e92-642d-5b73-aebc-960f18067542" { + description ""; + source @support_timely_rescue_decisions; + target @coordinate_rescue_response; + } + + role_assignment coordinates_assessment "Coordinates assessment" id "dab6c523-5d3a-51c3-be5d-296f0a0b4277" { + description ""; + source @incident_coordinator; + target @assess_incident; + } + + allocation sa_rescue_allocation_1 "Rescue system performs Send advice" id "e0aec6ca-d234-5500-b4e7-698b7cd02603" { + description ""; + source @rescue_coordination_system; + target @sa_rescue_second; + } + + role_realization fulfils_coordinator_role "Fulfils coordinator role" id "e407a34e-1a11-5203-8c88-2901fe7225f5" { + description ""; + source @rescue_coordination; + target @incident_coordinator; + } + + allocation assesses_incident "Assesses incident" id "e6de7ebb-09dd-506b-b667-09eccd00636d" { + description ""; + source @rescue_coordination; + target @assess_incident; + } + + port_allocation rescue_advice_service_target_port_advice_to_relay_input "Rescue advice service target port / Advice to relay input" id "e82d6057-862d-5013-a526-d8c792cd7b49" { + description ""; + source @rescue_advice_service_target_port; + target @advice_to_relay_input; + } + + port_allocation system_input_represents_assessment_input "System input represents assessment input" id "ee172486-6729-51b4-b0f4-61bbf4366ea5" { + description ""; + source @system_reporting_input; + target @assessment_function_input; + } + + interaction distress_signal "Distress signal" id "f6d8f4b9-8ac8-58e6-bf04-c446f9722b33" { + description ""; + items [@distress_report]; + source @report_distress; + target @assess_incident; + } + + allocation sa_relay_allocation_1 "Coastal relay performs Forward advice" id "fadca792-82d1-5907-a3f8-554e048d160f" { + description ""; + source @sa_coastal_relay; + target @sa_relay_second; + } + + capability_involvement system_capability_support "System capability support" id "faf853d4-0a93-51b6-b2e2-a9eab048c4e1" { + description ""; + source @classify_incident_and_alert_operator; + target @coordinate_rescue_response; + } + + availability assessment_in_normal_mode "Assessment in normal mode" id "fcbc569b-a7e0-53fb-884d-5444945ac6bc" { + description ""; + source @classify_incident_and_alert_operator; + target @normal_reporting; + } + + availability assessment_in_degraded_mode "Assessment in degraded mode" id "ffc4942b-1646-5b8c-b1f3-3861624ce2ce" { + description ""; + source @classify_incident_and_alert_operator; + target @degraded_reporting; + } + + diagram oa_capabilities_and_participants "OA capabilities and participants" id "7fdebc03-c35a-5da7-bba9-95fa33483766" { + description "A focused projection of the shared engineering model."; + layer Oa; + projection Capabilities; + routes []; + } + + node oa_capabilities_and_participants_protect_life_at_sea id "4ebf1808-6018-50a5-9c40-ca3421ebeed5" { + collapsed false; + diagram @oa_capabilities_and_participants; + element @protect_life_at_sea; + position { + x 524.0; + y 60.0; + }; + size { + height 94.0; + width 224.0; + }; + } + + node oa_capabilities_and_participants_rescue_coordination id "8202f482-f5ff-5f10-91da-a17ec75b6cc1" { + collapsed false; + diagram @oa_capabilities_and_participants; + element @rescue_coordination; + position { + x 988.0; + y 60.0; + }; + size { + height 94.0; + width 224.0; + }; + } + + node oa_capabilities_and_participants_vessel_in_distress id "b2f2c068-9db6-5cd9-a013-39b1f9c527ec" { + collapsed false; + diagram @oa_capabilities_and_participants; + element @vessel_in_distress; + position { + x 1452.0; + y 60.0; + }; + size { + height 94.0; + width 224.0; + }; + } + + node oa_capabilities_and_participants_incident_coordinator id "d26c2ef6-9862-5baa-9712-61f2b41904df" { + collapsed false; + diagram @oa_capabilities_and_participants; + element @incident_coordinator; + position { + x 60.0; + y 60.0; + }; + size { + height 94.0; + width 224.0; + }; + } + + diagram oa_participants_and_activities "OA routing workshop" id "945a7c88-a352-5028-b808-73d852e5abe6" { + description "Three participants: vessel, coastal relay, rescue team. Direct vessel-to-rescue exchanges pass around the relay. Select an exchange and drag a segment to add a bend; move its label, then undo. The incident decision stays inside Rescue: move the whole container to carry both endpoint pins. Fold/unfold and save/reopen to check preservation. Allocation summaries are nested inside participants; semantic decomposition remains separate."; + layer Oa; + projection Allocation; + routes []; + } + + node oa_participants_and_activities_oa_vessel_second id "04fb2936-f1fa-565f-a589-e5a4c4510c06" { + collapsed false; + diagram @oa_participants_and_activities; + element @oa_vessel_second; + position { + x 88.0; + y 344.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node oa_participants_and_activities_oa_rescue_second id "0ffbb06f-ca83-51a5-bf7c-38790a804ca7" { + collapsed false; + diagram @oa_participants_and_activities; + element @oa_rescue_second; + position { + x 768.0; + y 344.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node oa_participants_and_activities_oa_relay_first id "3dea7001-3384-54d4-b92b-19c9ceda81fc" { + collapsed false; + diagram @oa_participants_and_activities; + element @oa_relay_first; + position { + x 428.0; + y 184.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node oa_participants_and_activities_vessel_in_distress id "47cffe17-4dbf-5693-92c2-765af01547f2" { + collapsed false; + diagram @oa_participants_and_activities; + element @vessel_in_distress; + position { + x 40.0; + y 40.0; + }; + size { + height 600.0; + width 272.0; + }; + } + + node oa_participants_and_activities_report_distress id "64bfefd5-de63-52cb-bc61-628af1e836f4" { + collapsed false; + diagram @oa_participants_and_activities; + element @report_distress; + position { + x 88.0; + y 184.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node oa_participants_and_activities_oa_relay_work id "6e9924c9-ffd3-5ab0-a95a-9d801cfa0c27" { + collapsed false; + diagram @oa_participants_and_activities; + element @oa_relay_work; + position { + x 404.0; + y 112.0; + }; + size { + height 384.0; + width 224.0; + }; + } + + node oa_participants_and_activities_oa_relay_second id "7168d9d1-dffd-53c1-bf62-573a2bc5d598" { + collapsed false; + diagram @oa_participants_and_activities; + element @oa_relay_second; + position { + x 428.0; + y 344.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node oa_participants_and_activities_oa_vessel_work id "99be55b7-02ec-5a6a-a340-bba0d8d7ecc4" { + collapsed false; + diagram @oa_participants_and_activities; + element @oa_vessel_work; + position { + x 64.0; + y 112.0; + }; + size { + height 384.0; + width 224.0; + }; + } + + node oa_participants_and_activities_rescue_coordination id "b3d3bab8-ac67-57d4-bc08-5f614e86caeb" { + collapsed false; + diagram @oa_participants_and_activities; + element @rescue_coordination; + position { + x 720.0; + y 40.0; + }; + size { + height 600.0; + width 272.0; + }; + } + + node oa_participants_and_activities_oa_coastal_relay id "b8dc966b-bd50-5381-afe1-98362357b4eb" { + collapsed false; + diagram @oa_participants_and_activities; + element @oa_coastal_relay; + position { + x 380.0; + y 40.0; + }; + size { + height 600.0; + width 272.0; + }; + } + + node oa_participants_and_activities_oa_rescue_work id "e3f547f2-158e-51c1-9b54-d774c4e75697" { + collapsed false; + diagram @oa_participants_and_activities; + element @oa_rescue_work; + position { + x 744.0; + y 112.0; + }; + size { + height 384.0; + width 224.0; + }; + } + + node oa_participants_and_activities_assess_incident id "e6e08b0d-6edf-5d4f-84aa-f9a7ec74a861" { + collapsed false; + diagram @oa_participants_and_activities; + element @assess_incident; + position { + x 768.0; + y 184.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + diagram oa_activity_dataflow "OA activity dataflow" id "960b2a55-56a2-50f7-95fd-2f83be511afa" { + description "A focused projection of the shared engineering model."; + layer Oa; + projection FunctionalDataflow; + routes []; + } + + node oa_activity_dataflow_report_distress id "01fba338-889a-55a4-9828-8406ffc7dc99" { + collapsed false; + diagram @oa_activity_dataflow; + element @report_distress; + position { + x 84.0; + y 124.0; + }; + size { + height 94.0; + width 224.0; + }; + } + + node oa_activity_dataflow_assess_incident id "816989fc-840e-5ad3-b6c8-3ab911f9d214" { + collapsed false; + diagram @oa_activity_dataflow; + element @assess_incident; + position { + x 84.0; + y 234.0; + }; + size { + height 94.0; + width 224.0; + }; + } + + node oa_activity_dataflow_respond_to_distress id "ecafda1e-5ae2-5afe-af70-51867a01c7c9" { + collapsed false; + diagram @oa_activity_dataflow; + element @respond_to_distress; + position { + x 60.0; + y 60.0; + }; + size { + height 292.0; + width 272.0; + }; + } + + diagram sa_missions_and_capabilities "SA missions and capabilities" id "a275a15e-ce9f-5c91-a66f-17ddf371d6e8" { + description "A focused projection of the shared engineering model."; + layer Sa; + projection Capabilities; + routes []; + } + + node sa_missions_and_capabilities_vessel_communication_service id "28a23a96-c5f2-5d83-bce6-e062c172e6e1" { + collapsed false; + diagram @sa_missions_and_capabilities; + element @vessel_communication_service; + position { + x 1452.0; + y 60.0; + }; + size { + height 160.0; + width 224.0; + }; + } + + node sa_missions_and_capabilities_coordinate_rescue_response id "45c1757d-c9b7-5821-a6bd-6d1cfcce5059" { + collapsed false; + diagram @sa_missions_and_capabilities; + element @coordinate_rescue_response; + position { + x 988.0; + y 60.0; + }; + size { + height 94.0; + width 224.0; + }; + } + + node sa_missions_and_capabilities_rescue_coordination_system id "60a81f21-e6a1-5156-9e92-e991b1b08805" { + collapsed false; + diagram @sa_missions_and_capabilities; + element @rescue_coordination_system; + position { + x 60.0; + y 60.0; + }; + size { + height 132.0; + width 224.0; + }; + } + + node sa_missions_and_capabilities_support_timely_rescue_decisions id "775b6a0b-0785-5b8a-9e77-df944495dcd0" { + collapsed false; + diagram @sa_missions_and_capabilities; + element @support_timely_rescue_decisions; + position { + x 524.0; + y 60.0; + }; + size { + height 94.0; + width 224.0; + }; + } + + diagram sa_functional_decomposition "SA functional decomposition" id "c2686816-a37e-5d21-b99c-b306f6af60dd" { + description "A focused projection of the shared engineering model."; + layer Sa; + projection FunctionalDataflow; + routes []; + } + + node sa_functional_decomposition_classify_incident_and_alert_operator id "207eb637-1231-5f48-8c72-956592c04407" { + collapsed false; + diagram @sa_functional_decomposition; + element @classify_incident_and_alert_operator; + position { + x 84.0; + y 124.0; + }; + size { + height 132.0; + width 224.0; + }; + } + + node sa_functional_decomposition_manage_distress_response id "aa947537-8eb6-54d4-9752-13ea522ced94" { + collapsed false; + diagram @sa_functional_decomposition; + element @manage_distress_response; + position { + x 60.0; + y 60.0; + }; + size { + height 368.0; + width 272.0; + }; + } + + node sa_functional_decomposition_transmit_distress_report id "ab53224d-4fa2-5029-89a0-2e6d91bd30fa" { + collapsed false; + diagram @sa_functional_decomposition; + element @transmit_distress_report; + position { + x 84.0; + y 272.0; + }; + size { + height 132.0; + width 224.0; + }; + } + + diagram sa_system_boundary_and_functions "SA routing workshop" id "cb21862d-79e1-5a9d-bdf0-ee344c2fb219" { + description "Three participants: vessel, coastal relay, rescue team. Direct vessel-to-rescue exchanges pass around the relay. Select an exchange and drag a segment to add a bend; move its label, then undo. The incident decision stays inside Rescue: move the whole container to carry both endpoint pins. Fold/unfold and save/reopen to check preservation. Allocation summaries are nested inside participants; semantic decomposition remains separate."; + layer Sa; + projection Allocation; + routes []; + } + + node sa_system_boundary_and_functions_sa_rescue_second id "0d6b53ad-ac87-543d-930c-4609b61cef07" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @sa_rescue_second; + position { + x 768.0; + y 344.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node sa_system_boundary_and_functions_sa_rescue_work id "2794a0c8-15b9-5d6e-92e0-306e14ef0eef" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @sa_rescue_work; + position { + x 744.0; + y 112.0; + }; + size { + height 384.0; + width 224.0; + }; + } + + node sa_system_boundary_and_functions_sa_relay_work id "5035459a-2b6e-535d-a68b-ba06ebfbbe99" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @sa_relay_work; + position { + x 404.0; + y 112.0; + }; + size { + height 384.0; + width 224.0; + }; + } + + node sa_system_boundary_and_functions_sa_relay_second id "72553e3a-6e2d-5bee-b2d6-1f3a1b8c70ba" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @sa_relay_second; + position { + x 428.0; + y 344.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node sa_system_boundary_and_functions_rescue_coordination_system id "75920e7a-4586-58b7-9eb2-7e0a3d8a1825" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @rescue_coordination_system; + position { + x 720.0; + y 40.0; + }; + size { + height 600.0; + width 272.0; + }; + } + + node sa_system_boundary_and_functions_sa_coastal_relay id "794f31c9-3acf-5437-921c-2e1687c95bf7" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @sa_coastal_relay; + position { + x 380.0; + y 40.0; + }; + size { + height 600.0; + width 272.0; + }; + } + + node sa_system_boundary_and_functions_sa_relay_first id "8d19f1de-2a28-57de-b214-fec91490669d" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @sa_relay_first; + position { + x 428.0; + y 184.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node sa_system_boundary_and_functions_sa_vessel_second id "8ea19a3f-6de3-5f68-a774-13e3fbb2ca1b" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @sa_vessel_second; + position { + x 88.0; + y 344.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node sa_system_boundary_and_functions_sa_vessel_work id "923dad5a-8849-525c-865f-39e26d0ecf36" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @sa_vessel_work; + position { + x 64.0; + y 112.0; + }; + size { + height 384.0; + width 224.0; + }; + } + + node sa_system_boundary_and_functions_transmit_distress_report id "cda20386-a3c2-5f88-8d84-2966d9655e2e" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @transmit_distress_report; + position { + x 88.0; + y 184.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + node sa_system_boundary_and_functions_vessel_communication_service id "fd95388c-dc7e-54cf-9005-0a087dcbab52" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @vessel_communication_service; + position { + x 40.0; + y 40.0; + }; + size { + height 600.0; + width 272.0; + }; + } + + node sa_system_boundary_and_functions_classify_incident_and_alert_operator id "ffe8645d-8eea-5b41-95e6-6384b83e2641" { + collapsed false; + diagram @sa_system_boundary_and_functions; + element @classify_incident_and_alert_operator; + position { + x 768.0; + y 184.0; + }; + size { + height 132.0; + width 176.0; + }; + } + + artifact console_enclosure_cad "Console enclosure CAD" id "c1da9a6c-abd3-53be-9129-bf6daa83b288" { + description "Illustrative external engineering reference; opening a model does not fetch it."; + fragment none; + owner @rescue_coordination_system; + relation References; + revision "B.3"; + uri "cad://rescue-console/enclosure.step"; + } + + artifact response_implementation "Response implementation" id "da671f6a-a673-5ae8-85e6-41f39ffded6a" { + description "Illustrative external engineering reference; opening a model does not fetch it."; + fragment none; + owner @classify_incident_and_alert_operator; + relation Implements; + revision "design-v2"; + uri "git+https://example.org/rescue/control?path=src/response.rs"; + } + + trace trace_advice_to_relay "Advice to relay ↔ Advice to relay" id "0fd7b637-5acf-5b8b-8cc1-3115c31ed995" { + baseline { + oa { + description ""; + name "Advice to relay"; + }; + sa { + description ""; + name "Advice to relay"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Exchange; + oa @oa_advice_to_relay; + sa @sa_advice_to_relay; + } + + trace trace_rescue_coordination "Rescue coordination ↔ Rescue coordination system" id "1012eb71-7412-5a60-a3bd-f0e285347f02" { + baseline { + oa { + description ""; + name "Rescue team"; + }; + sa { + description ""; + name "Rescue system"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Participant; + oa @rescue_coordination; + sa @rescue_coordination_system; + } + + trace trace_protect_life_at_sea "Protect life at sea ↔ Coordinate rescue response" id "1eb80c6e-21a3-5d26-b0ef-c865d913cf14" { + baseline { + oa { + description ""; + name "Protect life at sea"; + }; + sa { + description ""; + name "Coordinate rescue response"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Capability; + oa @protect_life_at_sea; + sa @coordinate_rescue_response; + } + + trace trace_assess_incident "Assess incident ↔ Classify incident and alert operator" id "202a189f-cd85-50a4-a6ca-7990907cdfe2" { + baseline { + oa { + description ""; + name "Assess incident"; + }; + sa { + description ""; + name "Assess incident"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Refinement; + oa @assess_incident; + sa @classify_incident_and_alert_operator; + } + + trace trace_vessel_in_distress "Vessel in distress ↔ Vessel communication service" id "23d3cc11-532d-595e-8acb-c9cca7d17eea" { + baseline { + oa { + description ""; + name "Vessel"; + }; + sa { + description ""; + name "Vessel service"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Participant; + oa @vessel_in_distress; + sa @vessel_communication_service; + } + + trace trace_direct_advice "Direct advice ↔ Direct advice" id "2f53a69c-d13a-5eb5-abe0-cdd0c704e777" { + baseline { + oa { + description ""; + name "Direct advice"; + }; + sa { + description ""; + name "Direct advice"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Exchange; + oa @oa_direct_advice; + sa @sa_direct_advice; + } + + trace trace_workshop_oa_rescue_second "Send advice ↔ Send advice" id "35c86a52-4bb2-5c42-83ea-cd4e94a348d6" { + baseline { + oa { + description ""; + name "Send advice"; + }; + sa { + description ""; + name "Send advice"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Refinement; + oa @oa_rescue_second; + sa @sa_rescue_second; + } + + trace trace_distress_report "Distress report ↔ Digital distress report" id "3ce04971-d8f5-52e8-8e84-7cbc560aab15" { + baseline { + oa { + description ""; + name "Distress report"; + }; + sa { + description ""; + name "Digital distress report"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Item; + oa @distress_report; + sa @digital_distress_report; + } + + trace trace_advice_to_vessel "Relayed advice ↔ Relayed advice" id "3e8a9d77-06a1-59ec-9989-695b9b13fc25" { + baseline { + oa { + description ""; + name "Relayed advice"; + }; + sa { + description ""; + name "Relayed advice"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Exchange; + oa @oa_advice_to_vessel; + sa @sa_advice_to_vessel; + } + + trace trace_workshop_oa_relay_first "Forward report ↔ Forward report" id "3f1465d7-3438-5f3d-b50c-443d19cf4e75" { + baseline { + oa { + description ""; + name "Forward report"; + }; + sa { + description ""; + name "Forward report"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Refinement; + oa @oa_relay_first; + sa @sa_relay_first; + } + + trace trace_workshop_oa_vessel_work "Vessel contact ↔ Vessel contact" id "4522228a-dde5-5b4b-8c24-a08c3ac3f986" { + baseline { + oa { + description ""; + name "Vessel contact"; + }; + sa { + description ""; + name "Vessel contact"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Refinement; + oa @oa_vessel_work; + sa @sa_vessel_work; + } + + trace trace_workshop_oa_rescue_work "Rescue response ↔ Rescue response" id "5445c826-bb54-5d13-9de6-0c758dac8dac" { + baseline { + oa { + description ""; + name "Rescue response"; + }; + sa { + description ""; + name "Rescue response"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Refinement; + oa @oa_rescue_work; + sa @sa_rescue_work; + } + + trace trace_workshop_oa_relay_work "Coastal traffic ↔ Coastal traffic" id "59db4085-d057-560d-866e-0436b156aa3b" { + baseline { + oa { + description ""; + name "Coastal traffic"; + }; + sa { + description ""; + name "Coastal traffic"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Refinement; + oa @oa_relay_work; + sa @sa_relay_work; + } + + trace trace_incident_decision "Incident decision ↔ Incident decision" id "59dc3949-de08-56d9-a24f-e1906ee39d3d" { + baseline { + oa { + description ""; + name "Incident decision"; + }; + sa { + description ""; + name "Incident decision"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Exchange; + oa @oa_incident_decision; + sa @sa_incident_decision; + } + + trace trace_workshop_oa_vessel_second "Confirm advice ↔ Confirm advice" id "7d789667-96c6-5538-9afb-768c43fcee84" { + baseline { + oa { + description ""; + name "Confirm advice"; + }; + sa { + description ""; + name "Confirm advice"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Refinement; + oa @oa_vessel_second; + sa @sa_vessel_second; + } + + trace trace_coastal_relay "Coastal relay ↔ Coastal relay" id "8450368f-3f6b-5fe1-99a7-ac266c65b4f4" { + baseline { + oa { + description ""; + name "Coastal relay"; + }; + sa { + description ""; + name "Coastal relay"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Participant; + oa @oa_coastal_relay; + sa @sa_coastal_relay; + } + + trace trace_distress_received "Distress received ↔ Report handled" id "a5ca123c-e79a-5897-ba7e-9bfe41dd8f26" { + baseline { + oa { + description ""; + name "Distress received"; + }; + sa { + description ""; + name "Report handled"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Scenario; + oa @distress_received; + sa @report_handled; + } + + trace trace_respond_to_distress "Respond to distress ↔ Manage distress response" id "ab075c48-de3e-5254-9fc5-3d05aeaa2967" { + baseline { + oa { + description ""; + name "Respond to distress"; + }; + sa { + description ""; + name "Manage distress response"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Refinement; + oa @respond_to_distress; + sa @manage_distress_response; + } + + trace trace_workshop_oa_relay_second "Forward advice ↔ Forward advice" id "be0dc087-1905-5be2-bcbd-cc3538a2271b" { + baseline { + oa { + description ""; + name "Forward advice"; + }; + sa { + description ""; + name "Forward advice"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Refinement; + oa @oa_relay_second; + sa @sa_relay_second; + } + + trace trace_distress_signal "Distress signal ↔ Validated distress report" id "d6fba43a-a420-5438-b095-bcee2e2e0936" { + baseline { + oa { + description ""; + name "Distress signal"; + }; + sa { + description ""; + name "Validated distress report"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Exchange; + oa @distress_signal; + sa @validated_distress_report; + } + + trace trace_relay_to_rescue "Relayed report ↔ Relayed report" id "e065f9ce-83b9-5af8-b3a6-9542b55328bf" { + baseline { + oa { + description ""; + name "Relayed report"; + }; + sa { + description ""; + name "Relayed report"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Exchange; + oa @oa_relay_to_rescue; + sa @sa_relay_to_rescue; + } + + trace trace_report_to_relay "Report to relay ↔ Report to relay" id "e795d325-7f3d-5c6f-aadf-0506a7146ce9" { + baseline { + oa { + description ""; + name "Report to relay"; + }; + sa { + description ""; + name "Report to relay"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Exchange; + oa @oa_report_to_relay; + sa @sa_report_to_relay; + } + + trace trace_report_distress "Report distress ↔ Transmit distress report" id "fcb6f83b-4c2f-580d-bcc5-25a11ac0b53d" { + baseline { + oa { + description ""; + name "Report distress"; + }; + sa { + description ""; + name "Send distress"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Refinement; + oa @report_distress; + sa @transmit_distress_report; + } + + trace trace_distress_to_response "Distress to response ↔ Digital distress handling" id "fcc38192-797a-5fa7-a63a-bc5778ec5d4f" { + baseline { + oa { + description ""; + name "Distress to response"; + }; + sa { + description ""; + name "Digital distress handling"; + }; + }; + description "Reviewed OA/SA correspondence in the coastal rescue example."; + kind Sequence; + oa @distress_to_response; + sa @digital_distress_handling; + } + + trace trace_safety_advice "Safety advice ↔ Safety advice" id "fdaff816-20ea-5eeb-8a6d-a75ac456771b" { + baseline { + oa { + description ""; + name "Safety advice"; + }; + sa { + description ""; + name "Safety advice"; + }; + }; + description "OA/SA correspondence in the routing workshop."; + kind Item; + oa @oa_safety_advice; + sa @sa_safety_advice; + } + +} diff --git a/examples/routing-workshop.json b/examples/routing-workshop.json new file mode 100644 index 00000000..f67fa011 --- /dev/null +++ b/examples/routing-workshop.json @@ -0,0 +1,3165 @@ +{ + "schema_version": 3, + "id": "11a78443-e910-5631-99ff-f8c7b56dbc78", + "alias": "mission", + "name": "Coastal rescue · Routing workshop", + "description": "A three-participant OA/SA exercise for readable connection routing. Begin in an allocation view. Direct exchanges detour around the coastal relay; nested work belongs to its actual performer. SA includes typed functional endpoints, Flow and Standard component exchanges, explicit port/exchange allocations and an internal incident-decision exchange. Add bends and move labels, drag one endpoint or the entire Rescue container, fold/unfold, undo, and save/reopen. Other original engineering views and behavior remain available.", + "elements": { + "01c7e1ab-5889-5bcb-a028-e678cec2673b": { + "id": "01c7e1ab-5889-5bcb-a028-e678cec2673b", + "alias": "coordination_system_lifeline", + "name": "Coordination system lifeline", + "description": "", + "parent": "7837308c-b1d3-5002-877d-52a14c9d8403", + "body": { + "Sa": { + "Shared": { + "Lifeline": { + "represented": "30fc41ea-fc3d-5b57-9a05-67b14425fad9" + } + } + } + } + }, + "042ae2f7-cc3f-557e-bb1f-4179c57f9314": { + "id": "042ae2f7-cc3f-557e-bb1f-4179c57f9314", + "alias": "relayed_report_output", + "name": "Relayed report output", + "description": "", + "parent": "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionOutput": { + "outgoing_items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + }, + "legacy": null + } + } + } + } + }, + "04dd0e11-8ec8-5abf-869e-8d718b587b63": { + "id": "04dd0e11-8ec8-5abf-869e-8d718b587b63", + "alias": "report_handled", + "name": "Report handled", + "description": "", + "parent": "608fdf4f-e596-5b7e-aa79-2c6656cb2970", + "body": { + "Sa": { + "Shared": { + "Occurrence": { + "body": { + "Exchange": { + "exchange": "a15f7dfd-ac0b-562a-a633-fadc9fb64176", + "sender": null, + "receiver": null, + "message_kind": "Asynchronous", + "reply_to": null, + "values": [] + } + }, + "precondition": "", + "postcondition": "" + } + } + } + } + }, + "06355b22-2b30-561c-8cfe-6eb5eccefec6": { + "id": "06355b22-2b30-561c-8cfe-6eb5eccefec6", + "alias": "distress_received", + "name": "Distress received", + "description": "", + "parent": "7ef353cf-a4e3-56d2-bd3d-9d86cf2885a7", + "body": { + "Oa": { + "Shared": { + "Occurrence": { + "body": { + "Exchange": { + "exchange": "f6d8f4b9-8ac8-58e6-bf04-c446f9722b33", + "sender": null, + "receiver": null, + "message_kind": "Asynchronous", + "reply_to": null, + "values": [] + } + }, + "precondition": "", + "postcondition": "" + } + } + } + } + }, + "080677b3-a619-5da3-906b-bfe69327eb57": { + "id": "080677b3-a619-5da3-906b-bfe69327eb57", + "alias": "digital_distress_report", + "name": "Digital distress report", + "description": "", + "parent": null, + "body": { + "Sa": { + "Shared": { + "ExchangeItem": { + "kind": "Information" + } + } + } + } + }, + "08559968-aff0-5c3b-8694-9320a82d71a8": { + "id": "08559968-aff0-5c3b-8694-9320a82d71a8", + "alias": "reporting_operation_modes", + "name": "Reporting operation modes", + "description": "", + "parent": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "body": { + "Sa": { + "Shared": "StateMachine" + } + } + }, + "0aa33dc1-57eb-5307-9dcc-c566682c99f7": { + "id": "0aa33dc1-57eb-5307-9dcc-c566682c99f7", + "alias": "sa_coastal_relay", + "name": "Coastal relay", + "description": "", + "parent": null, + "body": { + "Sa": "Actor" + } + }, + "0e32a460-aa56-543b-a3db-e7711c3fcd38": { + "id": "0e32a460-aa56-543b-a3db-e7711c3fcd38", + "alias": "incident_decision_output", + "name": "Incident decision output", + "description": "", + "parent": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionOutput": { + "outgoing_items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + }, + "legacy": null + } + } + } + } + }, + "11869f64-77ae-512c-b8f5-5a0789585462": { + "id": "11869f64-77ae-512c-b8f5-5a0789585462", + "alias": "relayed_advice_input", + "name": "Relayed advice input", + "description": "", + "parent": "febf00a2-efed-5faf-b8c2-5d4bc77ddb53", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionInput": { + "incoming_items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + }, + "legacy": null + } + } + } + } + }, + "14f31813-a548-595b-a217-34412c1692ab": { + "id": "14f31813-a548-595b-a217-34412c1692ab", + "alias": "sa_rescue_work", + "name": "Rescue response", + "description": "", + "parent": "4099917c-0e9c-5535-8b89-6dc614a2f0c9", + "body": { + "Sa": "Function" + } + }, + "184a46a3-9695-5b47-a736-880e18775e09": { + "id": "184a46a3-9695-5b47-a736-880e18775e09", + "alias": "report_distress", + "name": "Report distress", + "description": "", + "parent": "5cf70948-ec50-5caf-bca9-fedaeb5f971c", + "body": { + "Oa": "Activity" + } + }, + "1ccd767f-b813-5884-a5ba-59bdc92b6f87": { + "id": "1ccd767f-b813-5884-a5ba-59bdc92b6f87", + "alias": "system_reporting_input", + "name": "System reporting input", + "description": "", + "parent": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Flow", + "orientation": "In" + } + }, + "legacy": null + } + } + } + } + }, + "1d5347b0-b75d-5c49-b523-0a4629cc941c": { + "id": "1d5347b0-b75d-5c49-b523-0a4629cc941c", + "alias": "relay_rescue_service_target_port", + "name": "Relay rescue service target port", + "description": "", + "parent": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Standard", + "orientation": "Unset" + } + }, + "legacy": null + } + } + } + } + }, + "26a15868-7fc7-5397-b7db-b2ad77c19080": { + "id": "26a15868-7fc7-5397-b7db-b2ad77c19080", + "alias": "incident_decision_input", + "name": "Incident decision input", + "description": "", + "parent": "b8896811-d893-50fc-b695-d2ee07dae9e3", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionInput": { + "incoming_items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + }, + "legacy": null + } + } + } + } + }, + "2c578ec2-025a-501c-a555-0fdc5be20a84": { + "id": "2c578ec2-025a-501c-a555-0fdc5be20a84", + "alias": "relay_vessel_channel_target_port", + "name": "Relay vessel channel target port", + "description": "", + "parent": "3eafabe6-d6ca-5127-a660-d81213347de0", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Flow", + "orientation": "In" + } + }, + "legacy": null + } + } + } + } + }, + "2fbbd555-56c5-5bf9-83a3-ca137a9961a8": { + "id": "2fbbd555-56c5-5bf9-83a3-ca137a9961a8", + "alias": "support_timely_rescue_decisions", + "name": "Support timely rescue decisions", + "description": "", + "parent": null, + "body": { + "Sa": "Mission" + } + }, + "30fc41ea-fc3d-5b57-9a05-67b14425fad9": { + "id": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "alias": "rescue_coordination_system", + "name": "Rescue system", + "description": "", + "parent": null, + "body": { + "Sa": "System" + } + }, + "3437906b-93a6-54a7-a0ef-b1169efec392": { + "id": "3437906b-93a6-54a7-a0ef-b1169efec392", + "alias": "rescue_advice_service_target_port", + "name": "Rescue advice service target port", + "description": "", + "parent": "0aa33dc1-57eb-5307-9dcc-c566682c99f7", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Standard", + "orientation": "Unset" + } + }, + "legacy": null + } + } + } + } + }, + "36164305-7318-5777-bb37-1b69796bba35": { + "id": "36164305-7318-5777-bb37-1b69796bba35", + "alias": "oa_rescue_second", + "name": "Send advice", + "description": "", + "parent": "97f7bcde-b8d8-56b2-ac5c-740506c38166", + "body": { + "Oa": "Activity" + } + }, + "38ff891a-d2a0-5b4a-8801-2ce08f9d3ff3": { + "id": "38ff891a-d2a0-5b4a-8801-2ce08f9d3ff3", + "alias": "distress_reporting_interface", + "name": "Distress reporting interface", + "description": "", + "parent": null, + "body": { + "Sa": { + "Shared": { + "Interface": { + "items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + } + } + } + }, + "3eafabe6-d6ca-5127-a660-d81213347de0": { + "id": "3eafabe6-d6ca-5127-a660-d81213347de0", + "alias": "vessel_communication_service", + "name": "Vessel service", + "description": "", + "parent": null, + "body": { + "Sa": "Actor" + } + }, + "3fc7b01b-75f4-53bf-bd31-b9840efe36fb": { + "id": "3fc7b01b-75f4-53bf-bd31-b9840efe36fb", + "alias": "sa_relay_work", + "name": "Coastal traffic", + "description": "", + "parent": "4099917c-0e9c-5535-8b89-6dc614a2f0c9", + "body": { + "Sa": "Function" + } + }, + "40078074-1925-5b68-8640-ecca13bd3c32": { + "id": "40078074-1925-5b68-8640-ecca13bd3c32", + "alias": "respond_to_distress", + "name": "Respond to distress", + "description": "", + "parent": null, + "body": { + "Oa": "Activity" + } + }, + "4099917c-0e9c-5535-8b89-6dc614a2f0c9": { + "id": "4099917c-0e9c-5535-8b89-6dc614a2f0c9", + "alias": "manage_distress_response", + "name": "Manage distress response", + "description": "", + "parent": null, + "body": { + "Sa": "Function" + } + }, + "435cc548-f6f7-5fdb-bfb6-0bb68a8deb04": { + "id": "435cc548-f6f7-5fdb-bfb6-0bb68a8deb04", + "alias": "oa_safety_advice", + "name": "Safety advice", + "description": "", + "parent": null, + "body": { + "Oa": { + "Shared": { + "ExchangeItem": { + "kind": "Information" + } + } + } + } + }, + "44358153-d6d0-594c-a81e-23df696e97f2": { + "id": "44358153-d6d0-594c-a81e-23df696e97f2", + "alias": "validated_report_received", + "name": "Validated report received", + "description": "", + "parent": null, + "body": { + "Sa": { + "Shared": { + "Event": { + "body": { + "Signal": { + "items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + } + } + } + } + } + }, + "4656d08f-158b-53eb-b368-e53083dfaed5": { + "id": "4656d08f-158b-53eb-b368-e53083dfaed5", + "alias": "sa_relay_second", + "name": "Forward advice", + "description": "", + "parent": "3fc7b01b-75f4-53bf-bd31-b9840efe36fb", + "body": { + "Sa": "Function" + } + }, + "478467e4-5449-51ca-a766-bff105ebcf60": { + "id": "478467e4-5449-51ca-a766-bff105ebcf60", + "alias": "report_to_relay_input", + "name": "Report to relay input", + "description": "", + "parent": "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionInput": { + "incoming_items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + }, + "legacy": null + } + } + } + } + }, + "580030e9-a2b7-5b45-b6c1-f201e73cf0fd": { + "id": "580030e9-a2b7-5b45-b6c1-f201e73cf0fd", + "alias": "report_function_output", + "name": "Report function output", + "description": "", + "parent": "f5497540-43a7-5573-826b-61eb7e4760a9", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionOutput": { + "outgoing_items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + }, + "legacy": null + } + } + } + } + }, + "59ed66a8-3cee-521f-91b1-c8e75b521ebc": { + "id": "59ed66a8-3cee-521f-91b1-c8e75b521ebc", + "alias": "vessel_relay_channel_source_port", + "name": "Vessel relay channel source port", + "description": "", + "parent": "3eafabe6-d6ca-5127-a660-d81213347de0", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Flow", + "orientation": "Out" + } + }, + "legacy": null + } + } + } + } + }, + "5c84fe4d-b5a7-5dd2-a4da-3ee03803c138": { + "id": "5c84fe4d-b5a7-5dd2-a4da-3ee03803c138", + "alias": "oa_relay_work", + "name": "Coastal traffic", + "description": "", + "parent": "40078074-1925-5b68-8640-ecca13bd3c32", + "body": { + "Oa": "Activity" + } + }, + "5cf70948-ec50-5caf-bca9-fedaeb5f971c": { + "id": "5cf70948-ec50-5caf-bca9-fedaeb5f971c", + "alias": "oa_vessel_work", + "name": "Vessel contact", + "description": "", + "parent": "40078074-1925-5b68-8640-ecca13bd3c32", + "body": { + "Oa": "Activity" + } + }, + "604d15ea-3f36-5ee1-9792-755e9e745be1": { + "id": "604d15ea-3f36-5ee1-9792-755e9e745be1", + "alias": "response_time_budget", + "name": "Response time budget", + "description": "", + "parent": null, + "body": { + "Sa": { + "Shared": { + "Constraint": { + "expression": "incident_alert_latency <= 120 s", + "constrained": [ + "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "a15f7dfd-ac0b-562a-a633-fadc9fb64176" + ] + } + } + } + } + }, + "606b870d-be72-5f5b-8067-bcaea1b3e70e": { + "id": "606b870d-be72-5f5b-8067-bcaea1b3e70e", + "alias": "oa_coastal_relay", + "name": "Coastal relay", + "description": "", + "parent": null, + "body": { + "Oa": "Entity" + } + }, + "608fdf4f-e596-5b7e-aa79-2c6656cb2970": { + "id": "608fdf4f-e596-5b7e-aa79-2c6656cb2970", + "alias": "digital_distress_handling", + "name": "Digital distress handling", + "description": "", + "parent": null, + "body": { + "Sa": { + "FunctionalChain": { + "steps": [ + "04dd0e11-8ec8-5abf-869e-8d718b587b63" + ] + } + } + } + }, + "65ab9712-85cc-533a-8307-1dced5ac3806": { + "id": "65ab9712-85cc-533a-8307-1dced5ac3806", + "alias": "updated_distress_report", + "name": "Updated distress report", + "description": "", + "parent": "7837308c-b1d3-5002-877d-52a14c9d8403", + "body": { + "Sa": { + "Shared": { + "Occurrence": { + "body": { + "Exchange": { + "exchange": "a15f7dfd-ac0b-562a-a633-fadc9fb64176", + "sender": "f2a19487-09d4-5ccc-989f-2df128779d97", + "receiver": "01c7e1ab-5889-5bcb-a028-e678cec2673b", + "message_kind": "Asynchronous", + "reply_to": null, + "values": [] + } + }, + "precondition": "The vessel has more recent position information.", + "postcondition": "The incident position is refreshed without creating a second incident." + } + } + } + } + }, + "6709bf44-4abe-5999-838f-4b34ac15af65": { + "id": "6709bf44-4abe-5999-838f-4b34ac15af65", + "alias": "rescue_advice_service_source_port", + "name": "Rescue advice service source port", + "description": "", + "parent": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Standard", + "orientation": "Unset" + } + }, + "legacy": null + } + } + } + } + }, + "69295b0a-afb4-503c-b98e-783f2429802a": { + "id": "69295b0a-afb4-503c-b98e-783f2429802a", + "alias": "oa_relay_second", + "name": "Forward advice", + "description": "", + "parent": "5c84fe4d-b5a7-5dd2-a4da-3ee03803c138", + "body": { + "Oa": "Activity" + } + }, + "7480cf74-67aa-5772-957a-1ba8f1b45918": { + "id": "7480cf74-67aa-5772-957a-1ba8f1b45918", + "alias": "incident_coordinator", + "name": "Incident coordinator", + "description": "", + "parent": null, + "body": { + "Oa": "Role" + } + }, + "7742a141-0dfa-57b5-9aa7-9c94f81c8e7c": { + "id": "7742a141-0dfa-57b5-9aa7-9c94f81c8e7c", + "alias": "advice_to_relay_input", + "name": "Advice to relay input", + "description": "", + "parent": "4656d08f-158b-53eb-b368-e53083dfaed5", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionInput": { + "incoming_items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + }, + "legacy": null + } + } + } + } + }, + "7837308c-b1d3-5002-877d-52a14c9d8403": { + "id": "7837308c-b1d3-5002-877d-52a14c9d8403", + "alias": "repeated_distress_reports", + "name": "Repeated distress reports", + "description": "", + "parent": null, + "body": { + "Sa": { + "Shared": { + "Scenario": { + "viewpoint": "BoundaryInterface", + "context": "e6832e4f-9352-5a22-87b6-0c06b3140d50", + "precondition": "A vessel has detected an emergency and the reporting service is available.", + "postcondition": "The operator has a classified incident with the latest vessel report.", + "steps": [ + "c86b3ac8-e147-50f8-a9f5-09798ac062a5", + "65ab9712-85cc-533a-8307-1dced5ac3806" + ] + } + } + } + } + }, + "78c1dd6d-9755-5ed5-ba9b-39d17a397631": { + "id": "78c1dd6d-9755-5ed5-ba9b-39d17a397631", + "alias": "relay_vessel_channel_source_port", + "name": "Relay vessel channel source port", + "description": "", + "parent": "0aa33dc1-57eb-5307-9dcc-c566682c99f7", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Flow", + "orientation": "Out" + } + }, + "legacy": null + } + } + } + } + }, + "7a42b274-3f40-592e-a499-33256bb10d10": { + "id": "7a42b274-3f40-592e-a499-33256bb10d10", + "alias": "relayed_advice_output", + "name": "Relayed advice output", + "description": "", + "parent": "4656d08f-158b-53eb-b368-e53083dfaed5", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionOutput": { + "outgoing_items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + }, + "legacy": null + } + } + } + } + }, + "7ef353cf-a4e3-56d2-bd3d-9d86cf2885a7": { + "id": "7ef353cf-a4e3-56d2-bd3d-9d86cf2885a7", + "alias": "distress_to_response", + "name": "Distress to response", + "description": "", + "parent": null, + "body": { + "Oa": { + "Process": { + "steps": [ + "06355b22-2b30-561c-8cfe-6eb5eccefec6" + ] + } + } + } + }, + "875e6bbe-6b1f-5fc2-a2e4-82858053010b": { + "id": "875e6bbe-6b1f-5fc2-a2e4-82858053010b", + "alias": "reported_latitude", + "name": "Reported latitude", + "description": "", + "parent": "080677b3-a619-5da3-906b-bfe69327eb57", + "body": { + "Sa": { + "Shared": { + "DataField": { + "type_ref": "Real", + "minimum": 1, + "maximum": 1, + "unit": "degrees north" + } + } + } + } + }, + "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436": { + "id": "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436", + "alias": "sa_relay_first", + "name": "Forward report", + "description": "", + "parent": "3fc7b01b-75f4-53bf-bd31-b9840efe36fb", + "body": { + "Sa": "Function" + } + }, + "8c1deb44-f362-56d5-9297-8ec84dd3cb4d": { + "id": "8c1deb44-f362-56d5-9297-8ec84dd3cb4d", + "alias": "protect_life_at_sea", + "name": "Protect life at sea", + "description": "", + "parent": null, + "body": { + "Oa": "Capability" + } + }, + "95fcc41c-81c3-5183-8b7d-f6d7e2a0f67c": { + "id": "95fcc41c-81c3-5183-8b7d-f6d7e2a0f67c", + "alias": "sa_vessel_work", + "name": "Vessel contact", + "description": "", + "parent": "4099917c-0e9c-5535-8b89-6dc614a2f0c9", + "body": { + "Sa": "Function" + } + }, + "97f7bcde-b8d8-56b2-ac5c-740506c38166": { + "id": "97f7bcde-b8d8-56b2-ac5c-740506c38166", + "alias": "oa_rescue_work", + "name": "Rescue response", + "description": "", + "parent": "40078074-1925-5b68-8640-ecca13bd3c32", + "body": { + "Oa": "Activity" + } + }, + "a470347f-e342-5e82-9610-8b86b5997c7d": { + "id": "a470347f-e342-5e82-9610-8b86b5997c7d", + "alias": "assessment_function_input", + "name": "Assessment function input", + "description": "", + "parent": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionInput": { + "incoming_items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + }, + "legacy": null + } + } + } + } + }, + "b05744bd-4dce-54b7-a9ff-8861d11dc1e0": { + "id": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "alias": "classify_incident_and_alert_operator", + "name": "Assess incident", + "description": "", + "parent": "14f31813-a548-595b-a217-34412c1692ab", + "body": { + "Sa": "Function" + } + }, + "b065b859-8b5e-5295-b214-69a2e7c3d4bb": { + "id": "b065b859-8b5e-5295-b214-69a2e7c3d4bb", + "alias": "assess_incident", + "name": "Assess incident", + "description": "", + "parent": "97f7bcde-b8d8-56b2-ac5c-740506c38166", + "body": { + "Oa": "Activity" + } + }, + "b8896811-d893-50fc-b695-d2ee07dae9e3": { + "id": "b8896811-d893-50fc-b695-d2ee07dae9e3", + "alias": "sa_rescue_second", + "name": "Send advice", + "description": "", + "parent": "14f31813-a548-595b-a217-34412c1692ab", + "body": { + "Sa": "Function" + } + }, + "ba2543c5-4160-5412-a542-5910cac0239f": { + "id": "ba2543c5-4160-5412-a542-5910cac0239f", + "alias": "degraded_reporting", + "name": "Degraded reporting", + "description": "", + "parent": "eb386aca-837a-5da8-8d4b-a8d625a929ce", + "body": { + "Sa": { + "Shared": { + "State": { + "kind": "Mode", + "entry": "", + "exit": "", + "do_activity": "" + } + } + } + } + }, + "bdbab719-3b60-5e1b-90be-3904630081b6": { + "id": "bdbab719-3b60-5e1b-90be-3904630081b6", + "alias": "advice_to_relay_output", + "name": "Advice to relay output", + "description": "", + "parent": "b8896811-d893-50fc-b695-d2ee07dae9e3", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "FunctionOutput": { + "outgoing_items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + }, + "legacy": null + } + } + } + } + }, + "c0460c14-0b7e-58fb-aa77-a39f504b70b0": { + "id": "c0460c14-0b7e-58fb-aa77-a39f504b70b0", + "alias": "vessel_relay_channel_target_port", + "name": "Vessel relay channel target port", + "description": "", + "parent": "0aa33dc1-57eb-5307-9dcc-c566682c99f7", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Flow", + "orientation": "In" + } + }, + "legacy": null + } + } + } + } + }, + "c385285d-5541-53b2-bb2d-17b643c2c19c": { + "id": "c385285d-5541-53b2-bb2d-17b643c2c19c", + "alias": "vessel_reporting_output", + "name": "Vessel reporting output", + "description": "", + "parent": "3eafabe6-d6ca-5127-a660-d81213347de0", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Flow", + "orientation": "Out" + } + }, + "legacy": null + } + } + } + } + }, + "c53454d5-4cb3-53ee-bfaa-8506795fd89c": { + "id": "c53454d5-4cb3-53ee-bfaa-8506795fd89c", + "alias": "sa_safety_advice", + "name": "Safety advice", + "description": "", + "parent": null, + "body": { + "Sa": { + "Shared": { + "ExchangeItem": { + "kind": "Information" + } + } + } + } + }, + "c86b3ac8-e147-50f8-a9f5-09798ac062a5": { + "id": "c86b3ac8-e147-50f8-a9f5-09798ac062a5", + "alias": "initial_distress_report", + "name": "Initial distress report", + "description": "", + "parent": "7837308c-b1d3-5002-877d-52a14c9d8403", + "body": { + "Sa": { + "Shared": { + "Occurrence": { + "body": { + "Exchange": { + "exchange": "a15f7dfd-ac0b-562a-a633-fadc9fb64176", + "sender": "f2a19487-09d4-5ccc-989f-2df128779d97", + "receiver": "01c7e1ab-5889-5bcb-a028-e678cec2673b", + "message_kind": "Asynchronous", + "reply_to": null, + "values": [] + } + }, + "precondition": "", + "postcondition": "" + } + } + } + } + }, + "cca50e54-6d10-5dbe-b587-8456c44f1423": { + "id": "cca50e54-6d10-5dbe-b587-8456c44f1423", + "alias": "rescue_supply_package", + "name": "Rescue supply package", + "description": "", + "parent": null, + "body": { + "Sa": { + "Shared": { + "ExchangeItem": { + "kind": "Material" + } + } + } + } + }, + "cd43dcb2-d417-5f7c-a065-2f79b7759b6d": { + "id": "cd43dcb2-d417-5f7c-a065-2f79b7759b6d", + "alias": "oa_vessel_second", + "name": "Confirm advice", + "description": "", + "parent": "5cf70948-ec50-5caf-bca9-fedaeb5f971c", + "body": { + "Oa": "Activity" + } + }, + "ddb01361-5d9e-5a45-87be-58ac4755ef03": { + "id": "ddb01361-5d9e-5a45-87be-58ac4755ef03", + "alias": "rescue_coordination", + "name": "Rescue team", + "description": "", + "parent": null, + "body": { + "Oa": "Entity" + } + }, + "ddb29f91-7994-597d-a5a0-1b4fccbae98d": { + "id": "ddb29f91-7994-597d-a5a0-1b4fccbae98d", + "alias": "start_reporting", + "name": "Start reporting", + "description": "", + "parent": "eb386aca-837a-5da8-8d4b-a8d625a929ce", + "body": { + "Sa": { + "Shared": { + "State": { + "kind": "Initial", + "entry": "", + "exit": "", + "do_activity": "" + } + } + } + } + }, + "e545eb5b-109f-5862-8a15-ed40cc564035": { + "id": "e545eb5b-109f-5862-8a15-ed40cc564035", + "alias": "distress_report", + "name": "Distress report", + "description": "", + "parent": null, + "body": { + "Oa": { + "Shared": { + "ExchangeItem": { + "kind": "Information" + } + } + } + } + }, + "e67467e4-2f3a-51e3-9a3b-4b66cad4e864": { + "id": "e67467e4-2f3a-51e3-9a3b-4b66cad4e864", + "alias": "report_timeout", + "name": "Report timeout", + "description": "", + "parent": null, + "body": { + "Sa": { + "Shared": { + "Event": { + "body": { + "Time": { + "kind": "After", + "expression": "30 s" + } + } + } + } + } + } + }, + "e6832e4f-9352-5a22-87b6-0c06b3140d50": { + "id": "e6832e4f-9352-5a22-87b6-0c06b3140d50", + "alias": "coordinate_rescue_response", + "name": "Coordinate rescue response", + "description": "", + "parent": null, + "body": { + "Sa": "Capability" + } + }, + "eb386aca-837a-5da8-8d4b-a8d625a929ce": { + "id": "eb386aca-837a-5da8-8d4b-a8d625a929ce", + "alias": "reporting_quality_region", + "name": "Reporting quality region", + "description": "", + "parent": "08559968-aff0-5c3b-8694-9320a82d71a8", + "body": { + "Sa": { + "Shared": "Region" + } + } + }, + "eb85c896-ed8f-5eb4-a9ad-3f3a817c3f2e": { + "id": "eb85c896-ed8f-5eb4-a9ad-3f3a817c3f2e", + "alias": "oa_relay_first", + "name": "Forward report", + "description": "", + "parent": "5c84fe4d-b5a7-5dd2-a4da-3ee03803c138", + "body": { + "Oa": "Activity" + } + }, + "f2a19487-09d4-5ccc-989f-2df128779d97": { + "id": "f2a19487-09d4-5ccc-989f-2df128779d97", + "alias": "vessel_service_lifeline", + "name": "Vessel service lifeline", + "description": "", + "parent": "7837308c-b1d3-5002-877d-52a14c9d8403", + "body": { + "Sa": { + "Shared": { + "Lifeline": { + "represented": "3eafabe6-d6ca-5127-a660-d81213347de0" + } + } + } + } + }, + "f2bb5075-31b6-586c-8e53-7df0d7478cf4": { + "id": "f2bb5075-31b6-586c-8e53-7df0d7478cf4", + "alias": "vessel_in_distress", + "name": "Vessel", + "description": "", + "parent": null, + "body": { + "Oa": "Actor" + } + }, + "f5497540-43a7-5573-826b-61eb7e4760a9": { + "id": "f5497540-43a7-5573-826b-61eb7e4760a9", + "alias": "transmit_distress_report", + "name": "Send distress", + "description": "", + "parent": "95fcc41c-81c3-5183-8b7d-f6d7e2a0f67c", + "body": { + "Sa": "Function" + } + }, + "f62cad4b-5205-5722-8242-a217f78deb6e": { + "id": "f62cad4b-5205-5722-8242-a217f78deb6e", + "alias": "relay_rescue_service_source_port", + "name": "Relay rescue service source port", + "description": "", + "parent": "0aa33dc1-57eb-5307-9dcc-c566682c99f7", + "body": { + "Sa": { + "Shared": { + "Port": { + "contract": { + "Component": { + "kind": "Standard", + "orientation": "Unset" + } + }, + "legacy": null + } + } + } + } + }, + "fc058344-b767-53e3-9cbc-dca4cb62a189": { + "id": "fc058344-b767-53e3-9cbc-dca4cb62a189", + "alias": "normal_reporting", + "name": "Normal reporting", + "description": "", + "parent": "eb386aca-837a-5da8-8d4b-a8d625a929ce", + "body": { + "Sa": { + "Shared": { + "State": { + "kind": "Mode", + "entry": "", + "exit": "", + "do_activity": "" + } + } + } + } + }, + "fd38ab55-4a4d-5fce-9fe8-3fcb068a2fd1": { + "id": "fd38ab55-4a4d-5fce-9fe8-3fcb068a2fd1", + "alias": "backup_electrical_energy", + "name": "Backup electrical energy", + "description": "", + "parent": null, + "body": { + "Sa": { + "Shared": { + "ExchangeItem": { + "kind": "Energy" + } + } + } + } + }, + "febf00a2-efed-5faf-b8c2-5d4bc77ddb53": { + "id": "febf00a2-efed-5faf-b8c2-5d4bc77ddb53", + "alias": "sa_vessel_second", + "name": "Confirm advice", + "description": "", + "parent": "95fcc41c-81c3-5183-8b7d-f6d7e2a0f67c", + "body": { + "Sa": "Function" + } + } + }, + "relations": { + "05bd56e5-ffd0-574f-a02a-ad3826195c8f": { + "id": "05bd56e5-ffd0-574f-a02a-ad3826195c8f", + "alias": "sa_relay_allocation_0", + "name": "Coastal relay performs Forward report", + "description": "", + "body": { + "Allocation": { + "source": "0aa33dc1-57eb-5307-9dcc-c566682c99f7", + "target": "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436" + } + } + }, + "06cd50be-286d-51d5-8828-1adf6d51d61c": { + "id": "06cd50be-286d-51d5-8828-1adf6d51d61c", + "alias": "vessel_relay_channel", + "name": "Vessel relay channel", + "description": "Component exchange explicitly implements its function exchange through allocated typed ports.", + "body": { + "BoundaryExchange": { + "source": "59ed66a8-3cee-521f-91b1-c8e75b521ebc", + "target": "c0460c14-0b7e-58fb-aa77-a39f504b70b0", + "oriented": true, + "items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + } + }, + "072c7c4c-d44c-5bf5-9b9f-6db0bd31ece8": { + "id": "072c7c4c-d44c-5bf5-9b9f-6db0bd31ece8", + "alias": "report_carried_by_connection", + "name": "Report carried by connection", + "description": "", + "body": { + "ExchangeAllocation": { + "source": "94246bbd-90a5-5c54-a6b3-337013bedc9c", + "target": "a15f7dfd-ac0b-562a-a633-fadc9fb64176" + } + } + }, + "076628bf-719a-52f1-a30f-e479e057b4e9": { + "id": "076628bf-719a-52f1-a30f-e479e057b4e9", + "alias": "sa_advice_to_vessel", + "name": "Relayed advice", + "description": "", + "body": { + "FunctionalExchange": { + "source": "4656d08f-158b-53eb-b368-e53083dfaed5", + "target": "febf00a2-efed-5faf-b8c2-5d4bc77ddb53", + "source_port": "7a42b274-3f40-592e-a499-33256bb10d10", + "target_port": "11869f64-77ae-512c-b8f5-5a0789585462", + "items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + } + }, + "0769b6ae-cc70-580e-aa81-8725dce8cbdb": { + "id": "0769b6ae-cc70-580e-aa81-8725dce8cbdb", + "alias": "vessel_relay_channel_target_port_report_to_relay_input", + "name": "Vessel relay channel target port / Report to relay input", + "description": "", + "body": { + "PortAllocation": { + "source": "c0460c14-0b7e-58fb-aa77-a39f504b70b0", + "target": "478467e4-5449-51ca-a766-bff105ebcf60" + } + } + }, + "0782ac98-8c77-5e31-89ff-b7a98cf0e63e": { + "id": "0782ac98-8c77-5e31-89ff-b7a98cf0e63e", + "alias": "relay_vessel_channel_target_port_relayed_advice_input", + "name": "Relay vessel channel target port / Relayed advice input", + "description": "", + "body": { + "PortAllocation": { + "source": "2c578ec2-025a-501c-a555-0fdc5be20a84", + "target": "11869f64-77ae-512c-b8f5-5a0789585462" + } + } + }, + "11e2d27e-7379-5998-9bb3-44a2806c4dec": { + "id": "11e2d27e-7379-5998-9bb3-44a2806c4dec", + "alias": "vessel_relay_channel_report_to_relay", + "name": "Vessel relay channel / Report to relay", + "description": "", + "body": { + "ExchangeAllocation": { + "source": "06cd50be-286d-51d5-8828-1adf6d51d61c", + "target": "4678335a-04ae-5a19-a302-ea583bdd6c65" + } + } + }, + "128cb779-a76a-508d-a63b-f9555cc6d1f0": { + "id": "128cb779-a76a-508d-a63b-f9555cc6d1f0", + "alias": "oa_relay_allocation_0", + "name": "Coastal relay performs Forward report", + "description": "", + "body": { + "Allocation": { + "source": "606b870d-be72-5f5b-8067-bcaea1b3e70e", + "target": "eb85c896-ed8f-5eb4-a9ad-3f3a817c3f2e" + } + } + }, + "186f8744-39ea-554e-ada8-fa582e0d4555": { + "id": "186f8744-39ea-554e-ada8-fa582e0d4555", + "alias": "oa_vessel_allocation_1", + "name": "Vessel performs Confirm advice", + "description": "", + "body": { + "Allocation": { + "source": "f2bb5075-31b6-586c-8e53-7df0d7478cf4", + "target": "cd43dcb2-d417-5f7c-a065-2f79b7759b6d" + } + } + }, + "1c6fc775-9bfd-5f95-b6e6-7858b9bb183f": { + "id": "1c6fc775-9bfd-5f95-b6e6-7858b9bb183f", + "alias": "relay_rescue_service_relayed_report", + "name": "Relay rescue service / Relayed report", + "description": "", + "body": { + "ExchangeAllocation": { + "source": "22c7011d-b559-5df8-aadd-851002904ba0", + "target": "61782ac2-5817-5705-8cfc-baa1be5d6cb0" + } + } + }, + "2053a89e-136e-547b-b722-5757cf4a53f2": { + "id": "2053a89e-136e-547b-b722-5757cf4a53f2", + "alias": "reporting_service_required", + "name": "Reporting service required", + "description": "", + "body": { + "InterfaceRequirement": { + "source": "1ccd767f-b813-5884-a5ba-59bdc92b6f87", + "target": "38ff891a-d2a0-5b4a-8801-2ce08f9d3ff3" + } + } + }, + "22c7011d-b559-5df8-aadd-851002904ba0": { + "id": "22c7011d-b559-5df8-aadd-851002904ba0", + "alias": "relay_rescue_service", + "name": "Relay rescue service", + "description": "Component exchange explicitly implements its function exchange through allocated typed ports.", + "body": { + "BoundaryExchange": { + "source": "f62cad4b-5205-5722-8242-a217f78deb6e", + "target": "1d5347b0-b75d-5c49-b523-0a4629cc941c", + "oriented": false, + "items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + } + }, + "292c88e4-389c-5074-aa66-85a09752c31d": { + "id": "292c88e4-389c-5074-aa66-85a09752c31d", + "alias": "review_on_degraded_entry", + "name": "Review on degraded entry", + "description": "", + "body": { + "StateAction": { + "source": "ba2543c5-4160-5412-a542-5910cac0239f", + "target": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "phase": "Entry" + } + } + }, + "2c68a11d-1866-5aec-8544-9f2eeb3e90f9": { + "id": "2c68a11d-1866-5aec-8544-9f2eeb3e90f9", + "alias": "relay_rescue_service_source_port_relayed_report_output", + "name": "Relay rescue service source port / Relayed report output", + "description": "", + "body": { + "PortAllocation": { + "source": "f62cad4b-5205-5722-8242-a217f78deb6e", + "target": "042ae2f7-cc3f-557e-bb1f-4179c57f9314" + } + } + }, + "30004dfe-8205-5c98-bcd1-af1fe5b086f9": { + "id": "30004dfe-8205-5c98-bcd1-af1fe5b086f9", + "alias": "oa_rescue_allocation_1", + "name": "Rescue team performs Send advice", + "description": "", + "body": { + "Allocation": { + "source": "ddb01361-5d9e-5a45-87be-58ac4755ef03", + "target": "36164305-7318-5777-bb37-1b69796bba35" + } + } + }, + "3c6d8af1-7f55-5700-81a6-65bf29df5156": { + "id": "3c6d8af1-7f55-5700-81a6-65bf29df5156", + "alias": "vessel_output_represents_report_output", + "name": "Vessel output represents report output", + "description": "", + "body": { + "PortAllocation": { + "source": "c385285d-5541-53b2-bb2d-17b643c2c19c", + "target": "580030e9-a2b7-5b45-b6c1-f201e73cf0fd" + } + } + }, + "4678335a-04ae-5a19-a302-ea583bdd6c65": { + "id": "4678335a-04ae-5a19-a302-ea583bdd6c65", + "alias": "sa_report_to_relay", + "name": "Report to relay", + "description": "", + "body": { + "FunctionalExchange": { + "source": "f5497540-43a7-5573-826b-61eb7e4760a9", + "target": "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436", + "source_port": "580030e9-a2b7-5b45-b6c1-f201e73cf0fd", + "target_port": "478467e4-5449-51ca-a766-bff105ebcf60", + "items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + } + }, + "4c081c59-b875-558f-9858-49f56f364c60": { + "id": "4c081c59-b875-558f-9858-49f56f364c60", + "alias": "sa_vessel_allocation_1", + "name": "Vessel service performs Confirm advice", + "description": "", + "body": { + "Allocation": { + "source": "3eafabe6-d6ca-5127-a660-d81213347de0", + "target": "febf00a2-efed-5faf-b8c2-5d4bc77ddb53" + } + } + }, + "526753bc-88b0-5322-bffc-1b36376becf1": { + "id": "526753bc-88b0-5322-bffc-1b36376becf1", + "alias": "sa_incident_decision", + "name": "Incident decision", + "description": "", + "body": { + "FunctionalExchange": { + "source": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "target": "b8896811-d893-50fc-b695-d2ee07dae9e3", + "source_port": "0e32a460-aa56-543b-a3db-e7711c3fcd38", + "target_port": "26a15868-7fc7-5397-b7db-b2ad77c19080", + "items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + } + }, + "61782ac2-5817-5705-8cfc-baa1be5d6cb0": { + "id": "61782ac2-5817-5705-8cfc-baa1be5d6cb0", + "alias": "sa_relay_to_rescue", + "name": "Relayed report", + "description": "", + "body": { + "FunctionalExchange": { + "source": "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436", + "target": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "source_port": "042ae2f7-cc3f-557e-bb1f-4179c57f9314", + "target_port": "a470347f-e342-5e82-9610-8b86b5997c7d", + "items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + } + }, + "61f2c220-ba4c-5b37-b728-43bba1a677c6": { + "id": "61f2c220-ba4c-5b37-b728-43bba1a677c6", + "alias": "relay_vessel_channel", + "name": "Relay vessel channel", + "description": "Component exchange explicitly implements its function exchange through allocated typed ports.", + "body": { + "BoundaryExchange": { + "source": "78c1dd6d-9755-5ed5-ba9b-39d17a397631", + "target": "2c578ec2-025a-501c-a555-0fdc5be20a84", + "oriented": true, + "items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + } + }, + "6465eab2-4ca5-5a85-9b0a-efaaf9a0dfb5": { + "id": "6465eab2-4ca5-5a85-9b0a-efaaf9a0dfb5", + "alias": "reports_distress", + "name": "Reports distress", + "description": "", + "body": { + "Allocation": { + "source": "f2bb5075-31b6-586c-8e53-7df0d7478cf4", + "target": "184a46a3-9695-5b47-a736-880e18775e09" + } + } + }, + "659fe810-36bb-50d8-bc55-f761ef1c02d3": { + "id": "659fe810-36bb-50d8-bc55-f761ef1c02d3", + "alias": "oa_advice_to_vessel", + "name": "Relayed advice", + "description": "", + "body": { + "Interaction": { + "source": "69295b0a-afb4-503c-b98e-783f2429802a", + "target": "cd43dcb2-d417-5f7c-a065-2f79b7759b6d", + "items": [ + "435cc548-f6f7-5fdb-bfb6-0bb68a8deb04" + ] + } + } + }, + "69bd6da5-f9f9-532c-bab7-621a937204a7": { + "id": "69bd6da5-f9f9-532c-bab7-621a937204a7", + "alias": "relay_vessel_channel_relayed_advice", + "name": "Relay vessel channel / Relayed advice", + "description": "", + "body": { + "ExchangeAllocation": { + "source": "61f2c220-ba4c-5b37-b728-43bba1a677c6", + "target": "076628bf-719a-52f1-a30f-e479e057b4e9" + } + } + }, + "6a6c76c2-b1e3-5552-83a2-f3526de1cb92": { + "id": "6a6c76c2-b1e3-5552-83a2-f3526de1cb92", + "alias": "operational_realization", + "name": "Operational realization", + "description": "", + "body": { + "ChainInvolvement": { + "source": "7ef353cf-a4e3-56d2-bd3d-9d86cf2885a7", + "target": "8c1deb44-f362-56d5-9297-8ec84dd3cb4d" + } + } + }, + "7415ad08-0c14-540d-a7a2-b191956af2bf": { + "id": "7415ad08-0c14-540d-a7a2-b191956af2bf", + "alias": "vessel_relay_channel_source_port_report_function_output", + "name": "Vessel relay channel source port / Report function output", + "description": "", + "body": { + "PortAllocation": { + "source": "59ed66a8-3cee-521f-91b1-c8e75b521ebc", + "target": "580030e9-a2b7-5b45-b6c1-f201e73cf0fd" + } + } + }, + "74e6cfd2-aaf2-5112-86d9-dd9885e3ebf6": { + "id": "74e6cfd2-aaf2-5112-86d9-dd9885e3ebf6", + "alias": "reporting_service_provided", + "name": "Reporting service provided", + "description": "", + "body": { + "InterfaceProvision": { + "source": "c385285d-5541-53b2-bb2d-17b643c2c19c", + "target": "38ff891a-d2a0-5b4a-8801-2ce08f9d3ff3" + } + } + }, + "7e39bb6e-c062-54f9-be7d-da1e38327633": { + "id": "7e39bb6e-c062-54f9-be7d-da1e38327633", + "alias": "rescue_advice_service", + "name": "Rescue advice service", + "description": "Component exchange explicitly implements its function exchange through allocated typed ports.", + "body": { + "BoundaryExchange": { + "source": "6709bf44-4abe-5999-838f-4b34ac15af65", + "target": "3437906b-93a6-54a7-a0ef-b1169efec392", + "oriented": false, + "items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + } + }, + "844bdfbe-c481-5055-98b8-ec38a1603769": { + "id": "844bdfbe-c481-5055-98b8-ec38a1603769", + "alias": "oa_direct_advice", + "name": "Direct advice", + "description": "", + "body": { + "Interaction": { + "source": "36164305-7318-5777-bb37-1b69796bba35", + "target": "cd43dcb2-d417-5f7c-a065-2f79b7759b6d", + "items": [ + "435cc548-f6f7-5fdb-bfb6-0bb68a8deb04" + ] + } + } + }, + "86d74a9b-eb32-5cb5-bbf2-8ce043fb0848": { + "id": "86d74a9b-eb32-5cb5-bbf2-8ce043fb0848", + "alias": "operational_contribution", + "name": "Operational contribution", + "description": "", + "body": { + "CapabilityInvolvement": { + "source": "b065b859-8b5e-5295-b214-69a2e7c3d4bb", + "target": "8c1deb44-f362-56d5-9297-8ec84dd3cb4d" + } + } + }, + "877ef9bd-0a24-5c5b-9627-0e6de4576655": { + "id": "877ef9bd-0a24-5c5b-9627-0e6de4576655", + "alias": "signal_restored", + "name": "Signal restored", + "description": "", + "body": { + "StateTransition": { + "source": "ba2543c5-4160-5412-a542-5910cac0239f", + "target": "fc058344-b767-53e3-9cbc-dca4cb62a189", + "transition_kind": "External", + "triggers": [ + "44358153-d6d0-594c-a81e-23df696e97f2" + ], + "effects": [], + "trigger": "validated_report_received", + "guard": "position_is_current", + "effect": "Clear the degraded-reporting alert." + } + } + }, + "8902ac83-cbcd-5e2e-a239-396d93536706": { + "id": "8902ac83-cbcd-5e2e-a239-396d93536706", + "alias": "signal_degraded", + "name": "Signal degraded", + "description": "", + "body": { + "StateTransition": { + "source": "fc058344-b767-53e3-9cbc-dca4cb62a189", + "target": "ba2543c5-4160-5412-a542-5910cac0239f", + "transition_kind": "External", + "triggers": [ + "e67467e4-2f3a-51e3-9a3b-4b66cad4e864" + ], + "effects": [], + "trigger": "report_timeout", + "guard": "seconds_since_last_report > 30", + "effect": "Flag the incident and request an operator review." + } + } + }, + "8e23aa50-1e32-5d8c-a93e-f84ffcc95b6f": { + "id": "8e23aa50-1e32-5d8c-a93e-f84ffcc95b6f", + "alias": "relay_rescue_service_target_port_assessment_function_input", + "name": "Relay rescue service target port / Assessment function input", + "description": "", + "body": { + "PortAllocation": { + "source": "1d5347b0-b75d-5c49-b523-0a4629cc941c", + "target": "a470347f-e342-5e82-9610-8b86b5997c7d" + } + } + }, + "94246bbd-90a5-5c54-a6b3-337013bedc9c": { + "id": "94246bbd-90a5-5c54-a6b3-337013bedc9c", + "alias": "distress_reporting_connection", + "name": "Distress reporting connection", + "description": "", + "body": { + "BoundaryExchange": { + "source": "c385285d-5541-53b2-bb2d-17b643c2c19c", + "target": "1ccd767f-b813-5884-a5ba-59bdc92b6f87", + "oriented": true, + "items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + } + }, + "956d5b0a-1e34-518f-b46d-425751998bbc": { + "id": "956d5b0a-1e34-518f-b46d-425751998bbc", + "alias": "sa_direct_advice", + "name": "Direct advice", + "description": "", + "body": { + "FunctionalExchange": { + "source": "b8896811-d893-50fc-b695-d2ee07dae9e3", + "target": "febf00a2-efed-5faf-b8c2-5d4bc77ddb53", + "source_port": "bdbab719-3b60-5e1b-90be-3904630081b6", + "target_port": "11869f64-77ae-512c-b8f5-5a0789585462", + "items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + } + }, + "9905a581-8457-5ed0-bc19-d9732764796f": { + "id": "9905a581-8457-5ed0-bc19-d9732764796f", + "alias": "relay_vessel_channel_source_port_relayed_advice_output", + "name": "Relay vessel channel source port / Relayed advice output", + "description": "", + "body": { + "PortAllocation": { + "source": "78c1dd6d-9755-5ed5-ba9b-39d17a397631", + "target": "7a42b274-3f40-592e-a499-33256bb10d10" + } + } + }, + "9a640271-1e5f-5bf1-b208-ce5bb5769341": { + "id": "9a640271-1e5f-5bf1-b208-ce5bb5769341", + "alias": "functional_chain_support", + "name": "Functional chain support", + "description": "", + "body": { + "ChainInvolvement": { + "source": "608fdf4f-e596-5b7e-aa79-2c6656cb2970", + "target": "e6832e4f-9352-5a22-87b6-0c06b3140d50" + } + } + }, + "9b930e28-6a0f-5b25-98f0-5aec4f542d90": { + "id": "9b930e28-6a0f-5b25-98f0-5aec4f542d90", + "alias": "oa_advice_to_relay", + "name": "Advice to relay", + "description": "", + "body": { + "Interaction": { + "source": "36164305-7318-5777-bb37-1b69796bba35", + "target": "69295b0a-afb4-503c-b98e-783f2429802a", + "items": [ + "435cc548-f6f7-5fdb-bfb6-0bb68a8deb04" + ] + } + } + }, + "9c88c83c-f219-5038-890a-da6cf28da5af": { + "id": "9c88c83c-f219-5038-890a-da6cf28da5af", + "alias": "initialize_reporting", + "name": "Initialize reporting", + "description": "", + "body": { + "StateTransition": { + "source": "ddb29f91-7994-597d-a5a0-1b4fccbae98d", + "target": "fc058344-b767-53e3-9cbc-dca4cb62a189", + "transition_kind": "External", + "triggers": [], + "effects": [], + "trigger": "", + "guard": "", + "effect": "" + } + } + }, + "9eaa1fc3-44e0-5091-b117-1358fd8e2a05": { + "id": "9eaa1fc3-44e0-5091-b117-1358fd8e2a05", + "alias": "oa_report_to_relay", + "name": "Report to relay", + "description": "", + "body": { + "Interaction": { + "source": "184a46a3-9695-5b47-a736-880e18775e09", + "target": "eb85c896-ed8f-5eb4-a9ad-3f3a817c3f2e", + "items": [ + "e545eb5b-109f-5862-8a15-ed40cc564035" + ] + } + } + }, + "9ffdda44-d7bc-500b-bc5c-dc285e5afc03": { + "id": "9ffdda44-d7bc-500b-bc5c-dc285e5afc03", + "alias": "system_assessment", + "name": "System assessment", + "description": "", + "body": { + "Allocation": { + "source": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "target": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0" + } + } + }, + "a15f7dfd-ac0b-562a-a633-fadc9fb64176": { + "id": "a15f7dfd-ac0b-562a-a633-fadc9fb64176", + "alias": "validated_distress_report", + "name": "Validated distress report", + "description": "", + "body": { + "FunctionalExchange": { + "source": "f5497540-43a7-5573-826b-61eb7e4760a9", + "target": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "source_port": "580030e9-a2b7-5b45-b6c1-f201e73cf0fd", + "target_port": "a470347f-e342-5e82-9610-8b86b5997c7d", + "items": [ + "080677b3-a619-5da3-906b-bfe69327eb57" + ] + } + } + }, + "a33b68f1-c297-5bd5-96ab-75bab66b92b1": { + "id": "a33b68f1-c297-5bd5-96ab-75bab66b92b1", + "alias": "oa_relay_to_rescue", + "name": "Relayed report", + "description": "", + "body": { + "Interaction": { + "source": "eb85c896-ed8f-5eb4-a9ad-3f3a817c3f2e", + "target": "b065b859-8b5e-5295-b214-69a2e7c3d4bb", + "items": [ + "e545eb5b-109f-5862-8a15-ed40cc564035" + ] + } + } + }, + "a4dd4c80-1caf-5a1a-9bcd-e57fa1855706": { + "id": "a4dd4c80-1caf-5a1a-9bcd-e57fa1855706", + "alias": "oa_relay_allocation_1", + "name": "Coastal relay performs Forward advice", + "description": "", + "body": { + "Allocation": { + "source": "606b870d-be72-5f5b-8067-bcaea1b3e70e", + "target": "69295b0a-afb4-503c-b98e-783f2429802a" + } + } + }, + "aecc4aa0-5345-54ea-82d2-b0e1470e835e": { + "id": "aecc4aa0-5345-54ea-82d2-b0e1470e835e", + "alias": "vessel_transmission", + "name": "Vessel transmission", + "description": "", + "body": { + "Allocation": { + "source": "3eafabe6-d6ca-5127-a660-d81213347de0", + "target": "f5497540-43a7-5573-826b-61eb7e4760a9" + } + } + }, + "b344b56e-8d5c-54db-97ff-1c9ffde8b210": { + "id": "b344b56e-8d5c-54db-97ff-1c9ffde8b210", + "alias": "rescue_advice_service_advice_to_relay", + "name": "Rescue advice service / Advice to relay", + "description": "", + "body": { + "ExchangeAllocation": { + "source": "7e39bb6e-c062-54f9-be7d-da1e38327633", + "target": "c89e57d4-c77e-5f29-8000-b1d9182a4596" + } + } + }, + "b6a24785-a891-536d-9636-a0881c2569ad": { + "id": "b6a24785-a891-536d-9636-a0881c2569ad", + "alias": "rescue_advice_service_source_port_advice_to_relay_output", + "name": "Rescue advice service source port / Advice to relay output", + "description": "", + "body": { + "PortAllocation": { + "source": "6709bf44-4abe-5999-838f-4b34ac15af65", + "target": "bdbab719-3b60-5e1b-90be-3904630081b6" + } + } + }, + "bc6da29f-91fb-5e86-ad07-f714805f344c": { + "id": "bc6da29f-91fb-5e86-ad07-f714805f344c", + "alias": "oa_incident_decision", + "name": "Incident decision", + "description": "", + "body": { + "Interaction": { + "source": "b065b859-8b5e-5295-b214-69a2e7c3d4bb", + "target": "36164305-7318-5777-bb37-1b69796bba35", + "items": [ + "435cc548-f6f7-5fdb-bfb6-0bb68a8deb04" + ] + } + } + }, + "c89e57d4-c77e-5f29-8000-b1d9182a4596": { + "id": "c89e57d4-c77e-5f29-8000-b1d9182a4596", + "alias": "sa_advice_to_relay", + "name": "Advice to relay", + "description": "", + "body": { + "FunctionalExchange": { + "source": "b8896811-d893-50fc-b695-d2ee07dae9e3", + "target": "4656d08f-158b-53eb-b368-e53083dfaed5", + "source_port": "bdbab719-3b60-5e1b-90be-3904630081b6", + "target_port": "7742a141-0dfa-57b5-9aa7-9c94f81c8e7c", + "items": [ + "c53454d5-4cb3-53ee-bfaa-8506795fd89c" + ] + } + } + }, + "cff93e92-642d-5b73-aebc-960f18067542": { + "id": "cff93e92-642d-5b73-aebc-960f18067542", + "alias": "mission_capability", + "name": "Mission capability", + "description": "", + "body": { + "MissionCapability": { + "source": "2fbbd555-56c5-5bf9-83a3-ca137a9961a8", + "target": "e6832e4f-9352-5a22-87b6-0c06b3140d50" + } + } + }, + "dab6c523-5d3a-51c3-be5d-296f0a0b4277": { + "id": "dab6c523-5d3a-51c3-be5d-296f0a0b4277", + "alias": "coordinates_assessment", + "name": "Coordinates assessment", + "description": "", + "body": { + "RoleAssignment": { + "source": "7480cf74-67aa-5772-957a-1ba8f1b45918", + "target": "b065b859-8b5e-5295-b214-69a2e7c3d4bb" + } + } + }, + "e0aec6ca-d234-5500-b4e7-698b7cd02603": { + "id": "e0aec6ca-d234-5500-b4e7-698b7cd02603", + "alias": "sa_rescue_allocation_1", + "name": "Rescue system performs Send advice", + "description": "", + "body": { + "Allocation": { + "source": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "target": "b8896811-d893-50fc-b695-d2ee07dae9e3" + } + } + }, + "e407a34e-1a11-5203-8c88-2901fe7225f5": { + "id": "e407a34e-1a11-5203-8c88-2901fe7225f5", + "alias": "fulfils_coordinator_role", + "name": "Fulfils coordinator role", + "description": "", + "body": { + "RoleRealization": { + "source": "ddb01361-5d9e-5a45-87be-58ac4755ef03", + "target": "7480cf74-67aa-5772-957a-1ba8f1b45918" + } + } + }, + "e6de7ebb-09dd-506b-b667-09eccd00636d": { + "id": "e6de7ebb-09dd-506b-b667-09eccd00636d", + "alias": "assesses_incident", + "name": "Assesses incident", + "description": "", + "body": { + "Allocation": { + "source": "ddb01361-5d9e-5a45-87be-58ac4755ef03", + "target": "b065b859-8b5e-5295-b214-69a2e7c3d4bb" + } + } + }, + "e82d6057-862d-5013-a526-d8c792cd7b49": { + "id": "e82d6057-862d-5013-a526-d8c792cd7b49", + "alias": "rescue_advice_service_target_port_advice_to_relay_input", + "name": "Rescue advice service target port / Advice to relay input", + "description": "", + "body": { + "PortAllocation": { + "source": "3437906b-93a6-54a7-a0ef-b1169efec392", + "target": "7742a141-0dfa-57b5-9aa7-9c94f81c8e7c" + } + } + }, + "ee172486-6729-51b4-b0f4-61bbf4366ea5": { + "id": "ee172486-6729-51b4-b0f4-61bbf4366ea5", + "alias": "system_input_represents_assessment_input", + "name": "System input represents assessment input", + "description": "", + "body": { + "PortAllocation": { + "source": "1ccd767f-b813-5884-a5ba-59bdc92b6f87", + "target": "a470347f-e342-5e82-9610-8b86b5997c7d" + } + } + }, + "f6d8f4b9-8ac8-58e6-bf04-c446f9722b33": { + "id": "f6d8f4b9-8ac8-58e6-bf04-c446f9722b33", + "alias": "distress_signal", + "name": "Distress signal", + "description": "", + "body": { + "Interaction": { + "source": "184a46a3-9695-5b47-a736-880e18775e09", + "target": "b065b859-8b5e-5295-b214-69a2e7c3d4bb", + "items": [ + "e545eb5b-109f-5862-8a15-ed40cc564035" + ] + } + } + }, + "fadca792-82d1-5907-a3f8-554e048d160f": { + "id": "fadca792-82d1-5907-a3f8-554e048d160f", + "alias": "sa_relay_allocation_1", + "name": "Coastal relay performs Forward advice", + "description": "", + "body": { + "Allocation": { + "source": "0aa33dc1-57eb-5307-9dcc-c566682c99f7", + "target": "4656d08f-158b-53eb-b368-e53083dfaed5" + } + } + }, + "faf853d4-0a93-51b6-b2e2-a9eab048c4e1": { + "id": "faf853d4-0a93-51b6-b2e2-a9eab048c4e1", + "alias": "system_capability_support", + "name": "System capability support", + "description": "", + "body": { + "CapabilityInvolvement": { + "source": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "target": "e6832e4f-9352-5a22-87b6-0c06b3140d50" + } + } + }, + "fcbc569b-a7e0-53fb-884d-5444945ac6bc": { + "id": "fcbc569b-a7e0-53fb-884d-5444945ac6bc", + "alias": "assessment_in_normal_mode", + "name": "Assessment in normal mode", + "description": "", + "body": { + "Availability": { + "source": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "target": "fc058344-b767-53e3-9cbc-dca4cb62a189" + } + } + }, + "ffc4942b-1646-5b8c-b1f3-3861624ce2ce": { + "id": "ffc4942b-1646-5b8c-b1f3-3861624ce2ce", + "alias": "assessment_in_degraded_mode", + "name": "Assessment in degraded mode", + "description": "", + "body": { + "Availability": { + "source": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "target": "ba2543c5-4160-5412-a542-5910cac0239f" + } + } + } + }, + "diagrams": { + "7fdebc03-c35a-5da7-bba9-95fa33483766": { + "id": "7fdebc03-c35a-5da7-bba9-95fa33483766", + "alias": "oa_capabilities_and_participants", + "name": "OA capabilities and participants", + "description": "A focused projection of the shared engineering model.", + "layer": "Oa", + "projection": "Capabilities", + "nodes": { + "4ebf1808-6018-50a5-9c40-ca3421ebeed5": { + "id": "4ebf1808-6018-50a5-9c40-ca3421ebeed5", + "alias": "oa_capabilities_and_participants_protect_life_at_sea", + "element": "8c1deb44-f362-56d5-9297-8ec84dd3cb4d", + "position": { + "x": 524.0, + "y": 60.0 + }, + "size": { + "width": 224.0, + "height": 94.0 + }, + "collapsed": false + }, + "8202f482-f5ff-5f10-91da-a17ec75b6cc1": { + "id": "8202f482-f5ff-5f10-91da-a17ec75b6cc1", + "alias": "oa_capabilities_and_participants_rescue_coordination", + "element": "ddb01361-5d9e-5a45-87be-58ac4755ef03", + "position": { + "x": 988.0, + "y": 60.0 + }, + "size": { + "width": 224.0, + "height": 94.0 + }, + "collapsed": false + }, + "b2f2c068-9db6-5cd9-a013-39b1f9c527ec": { + "id": "b2f2c068-9db6-5cd9-a013-39b1f9c527ec", + "alias": "oa_capabilities_and_participants_vessel_in_distress", + "element": "f2bb5075-31b6-586c-8e53-7df0d7478cf4", + "position": { + "x": 1452.0, + "y": 60.0 + }, + "size": { + "width": 224.0, + "height": 94.0 + }, + "collapsed": false + }, + "d26c2ef6-9862-5baa-9712-61f2b41904df": { + "id": "d26c2ef6-9862-5baa-9712-61f2b41904df", + "alias": "oa_capabilities_and_participants_incident_coordinator", + "element": "7480cf74-67aa-5772-957a-1ba8f1b45918", + "position": { + "x": 60.0, + "y": 60.0 + }, + "size": { + "width": 224.0, + "height": 94.0 + }, + "collapsed": false + } + }, + "routes": [] + }, + "945a7c88-a352-5028-b808-73d852e5abe6": { + "id": "945a7c88-a352-5028-b808-73d852e5abe6", + "alias": "oa_participants_and_activities", + "name": "OA routing workshop", + "description": "Three participants: vessel, coastal relay, rescue team. Direct vessel-to-rescue exchanges pass around the relay. Select an exchange and drag a segment to add a bend; move its label, then undo. The incident decision stays inside Rescue: move the whole container to carry both endpoint pins. Fold/unfold and save/reopen to check preservation. Allocation summaries are nested inside participants; semantic decomposition remains separate.", + "layer": "Oa", + "projection": "Allocation", + "nodes": { + "04fb2936-f1fa-565f-a589-e5a4c4510c06": { + "id": "04fb2936-f1fa-565f-a589-e5a4c4510c06", + "alias": "oa_participants_and_activities_oa_vessel_second", + "element": "cd43dcb2-d417-5f7c-a065-2f79b7759b6d", + "position": { + "x": 88.0, + "y": 344.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "0ffbb06f-ca83-51a5-bf7c-38790a804ca7": { + "id": "0ffbb06f-ca83-51a5-bf7c-38790a804ca7", + "alias": "oa_participants_and_activities_oa_rescue_second", + "element": "36164305-7318-5777-bb37-1b69796bba35", + "position": { + "x": 768.0, + "y": 344.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "3dea7001-3384-54d4-b92b-19c9ceda81fc": { + "id": "3dea7001-3384-54d4-b92b-19c9ceda81fc", + "alias": "oa_participants_and_activities_oa_relay_first", + "element": "eb85c896-ed8f-5eb4-a9ad-3f3a817c3f2e", + "position": { + "x": 428.0, + "y": 184.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "47cffe17-4dbf-5693-92c2-765af01547f2": { + "id": "47cffe17-4dbf-5693-92c2-765af01547f2", + "alias": "oa_participants_and_activities_vessel_in_distress", + "element": "f2bb5075-31b6-586c-8e53-7df0d7478cf4", + "position": { + "x": 40.0, + "y": 40.0 + }, + "size": { + "width": 272.0, + "height": 600.0 + }, + "collapsed": false + }, + "64bfefd5-de63-52cb-bc61-628af1e836f4": { + "id": "64bfefd5-de63-52cb-bc61-628af1e836f4", + "alias": "oa_participants_and_activities_report_distress", + "element": "184a46a3-9695-5b47-a736-880e18775e09", + "position": { + "x": 88.0, + "y": 184.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "6e9924c9-ffd3-5ab0-a95a-9d801cfa0c27": { + "id": "6e9924c9-ffd3-5ab0-a95a-9d801cfa0c27", + "alias": "oa_participants_and_activities_oa_relay_work", + "element": "5c84fe4d-b5a7-5dd2-a4da-3ee03803c138", + "position": { + "x": 404.0, + "y": 112.0 + }, + "size": { + "width": 224.0, + "height": 384.0 + }, + "collapsed": false + }, + "7168d9d1-dffd-53c1-bf62-573a2bc5d598": { + "id": "7168d9d1-dffd-53c1-bf62-573a2bc5d598", + "alias": "oa_participants_and_activities_oa_relay_second", + "element": "69295b0a-afb4-503c-b98e-783f2429802a", + "position": { + "x": 428.0, + "y": 344.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "99be55b7-02ec-5a6a-a340-bba0d8d7ecc4": { + "id": "99be55b7-02ec-5a6a-a340-bba0d8d7ecc4", + "alias": "oa_participants_and_activities_oa_vessel_work", + "element": "5cf70948-ec50-5caf-bca9-fedaeb5f971c", + "position": { + "x": 64.0, + "y": 112.0 + }, + "size": { + "width": 224.0, + "height": 384.0 + }, + "collapsed": false + }, + "b3d3bab8-ac67-57d4-bc08-5f614e86caeb": { + "id": "b3d3bab8-ac67-57d4-bc08-5f614e86caeb", + "alias": "oa_participants_and_activities_rescue_coordination", + "element": "ddb01361-5d9e-5a45-87be-58ac4755ef03", + "position": { + "x": 720.0, + "y": 40.0 + }, + "size": { + "width": 272.0, + "height": 600.0 + }, + "collapsed": false + }, + "b8dc966b-bd50-5381-afe1-98362357b4eb": { + "id": "b8dc966b-bd50-5381-afe1-98362357b4eb", + "alias": "oa_participants_and_activities_oa_coastal_relay", + "element": "606b870d-be72-5f5b-8067-bcaea1b3e70e", + "position": { + "x": 380.0, + "y": 40.0 + }, + "size": { + "width": 272.0, + "height": 600.0 + }, + "collapsed": false + }, + "e3f547f2-158e-51c1-9b54-d774c4e75697": { + "id": "e3f547f2-158e-51c1-9b54-d774c4e75697", + "alias": "oa_participants_and_activities_oa_rescue_work", + "element": "97f7bcde-b8d8-56b2-ac5c-740506c38166", + "position": { + "x": 744.0, + "y": 112.0 + }, + "size": { + "width": 224.0, + "height": 384.0 + }, + "collapsed": false + }, + "e6e08b0d-6edf-5d4f-84aa-f9a7ec74a861": { + "id": "e6e08b0d-6edf-5d4f-84aa-f9a7ec74a861", + "alias": "oa_participants_and_activities_assess_incident", + "element": "b065b859-8b5e-5295-b214-69a2e7c3d4bb", + "position": { + "x": 768.0, + "y": 184.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + } + }, + "routes": [] + }, + "960b2a55-56a2-50f7-95fd-2f83be511afa": { + "id": "960b2a55-56a2-50f7-95fd-2f83be511afa", + "alias": "oa_activity_dataflow", + "name": "OA activity dataflow", + "description": "A focused projection of the shared engineering model.", + "layer": "Oa", + "projection": "FunctionalDataflow", + "nodes": { + "01fba338-889a-55a4-9828-8406ffc7dc99": { + "id": "01fba338-889a-55a4-9828-8406ffc7dc99", + "alias": "oa_activity_dataflow_report_distress", + "element": "184a46a3-9695-5b47-a736-880e18775e09", + "position": { + "x": 84.0, + "y": 124.0 + }, + "size": { + "width": 224.0, + "height": 94.0 + }, + "collapsed": false + }, + "816989fc-840e-5ad3-b6c8-3ab911f9d214": { + "id": "816989fc-840e-5ad3-b6c8-3ab911f9d214", + "alias": "oa_activity_dataflow_assess_incident", + "element": "b065b859-8b5e-5295-b214-69a2e7c3d4bb", + "position": { + "x": 84.0, + "y": 234.0 + }, + "size": { + "width": 224.0, + "height": 94.0 + }, + "collapsed": false + }, + "ecafda1e-5ae2-5afe-af70-51867a01c7c9": { + "id": "ecafda1e-5ae2-5afe-af70-51867a01c7c9", + "alias": "oa_activity_dataflow_respond_to_distress", + "element": "40078074-1925-5b68-8640-ecca13bd3c32", + "position": { + "x": 60.0, + "y": 60.0 + }, + "size": { + "width": 272.0, + "height": 292.0 + }, + "collapsed": false + } + }, + "routes": [] + }, + "a275a15e-ce9f-5c91-a66f-17ddf371d6e8": { + "id": "a275a15e-ce9f-5c91-a66f-17ddf371d6e8", + "alias": "sa_missions_and_capabilities", + "name": "SA missions and capabilities", + "description": "A focused projection of the shared engineering model.", + "layer": "Sa", + "projection": "Capabilities", + "nodes": { + "28a23a96-c5f2-5d83-bce6-e062c172e6e1": { + "id": "28a23a96-c5f2-5d83-bce6-e062c172e6e1", + "alias": "sa_missions_and_capabilities_vessel_communication_service", + "element": "3eafabe6-d6ca-5127-a660-d81213347de0", + "position": { + "x": 1452.0, + "y": 60.0 + }, + "size": { + "width": 224.0, + "height": 160.0 + }, + "collapsed": false + }, + "45c1757d-c9b7-5821-a6bd-6d1cfcce5059": { + "id": "45c1757d-c9b7-5821-a6bd-6d1cfcce5059", + "alias": "sa_missions_and_capabilities_coordinate_rescue_response", + "element": "e6832e4f-9352-5a22-87b6-0c06b3140d50", + "position": { + "x": 988.0, + "y": 60.0 + }, + "size": { + "width": 224.0, + "height": 94.0 + }, + "collapsed": false + }, + "60a81f21-e6a1-5156-9e92-e991b1b08805": { + "id": "60a81f21-e6a1-5156-9e92-e991b1b08805", + "alias": "sa_missions_and_capabilities_rescue_coordination_system", + "element": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "position": { + "x": 60.0, + "y": 60.0 + }, + "size": { + "width": 224.0, + "height": 132.0 + }, + "collapsed": false + }, + "775b6a0b-0785-5b8a-9e77-df944495dcd0": { + "id": "775b6a0b-0785-5b8a-9e77-df944495dcd0", + "alias": "sa_missions_and_capabilities_support_timely_rescue_decisions", + "element": "2fbbd555-56c5-5bf9-83a3-ca137a9961a8", + "position": { + "x": 524.0, + "y": 60.0 + }, + "size": { + "width": 224.0, + "height": 94.0 + }, + "collapsed": false + } + }, + "routes": [] + }, + "c2686816-a37e-5d21-b99c-b306f6af60dd": { + "id": "c2686816-a37e-5d21-b99c-b306f6af60dd", + "alias": "sa_functional_decomposition", + "name": "SA functional decomposition", + "description": "A focused projection of the shared engineering model.", + "layer": "Sa", + "projection": "FunctionalDataflow", + "nodes": { + "207eb637-1231-5f48-8c72-956592c04407": { + "id": "207eb637-1231-5f48-8c72-956592c04407", + "alias": "sa_functional_decomposition_classify_incident_and_alert_operator", + "element": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "position": { + "x": 84.0, + "y": 124.0 + }, + "size": { + "width": 224.0, + "height": 132.0 + }, + "collapsed": false + }, + "aa947537-8eb6-54d4-9752-13ea522ced94": { + "id": "aa947537-8eb6-54d4-9752-13ea522ced94", + "alias": "sa_functional_decomposition_manage_distress_response", + "element": "4099917c-0e9c-5535-8b89-6dc614a2f0c9", + "position": { + "x": 60.0, + "y": 60.0 + }, + "size": { + "width": 272.0, + "height": 368.0 + }, + "collapsed": false + }, + "ab53224d-4fa2-5029-89a0-2e6d91bd30fa": { + "id": "ab53224d-4fa2-5029-89a0-2e6d91bd30fa", + "alias": "sa_functional_decomposition_transmit_distress_report", + "element": "f5497540-43a7-5573-826b-61eb7e4760a9", + "position": { + "x": 84.0, + "y": 272.0 + }, + "size": { + "width": 224.0, + "height": 132.0 + }, + "collapsed": false + } + }, + "routes": [] + }, + "cb21862d-79e1-5a9d-bdf0-ee344c2fb219": { + "id": "cb21862d-79e1-5a9d-bdf0-ee344c2fb219", + "alias": "sa_system_boundary_and_functions", + "name": "SA routing workshop", + "description": "Three participants: vessel, coastal relay, rescue team. Direct vessel-to-rescue exchanges pass around the relay. Select an exchange and drag a segment to add a bend; move its label, then undo. The incident decision stays inside Rescue: move the whole container to carry both endpoint pins. Fold/unfold and save/reopen to check preservation. Allocation summaries are nested inside participants; semantic decomposition remains separate.", + "layer": "Sa", + "projection": "Allocation", + "nodes": { + "0d6b53ad-ac87-543d-930c-4609b61cef07": { + "id": "0d6b53ad-ac87-543d-930c-4609b61cef07", + "alias": "sa_system_boundary_and_functions_sa_rescue_second", + "element": "b8896811-d893-50fc-b695-d2ee07dae9e3", + "position": { + "x": 768.0, + "y": 344.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "2794a0c8-15b9-5d6e-92e0-306e14ef0eef": { + "id": "2794a0c8-15b9-5d6e-92e0-306e14ef0eef", + "alias": "sa_system_boundary_and_functions_sa_rescue_work", + "element": "14f31813-a548-595b-a217-34412c1692ab", + "position": { + "x": 744.0, + "y": 112.0 + }, + "size": { + "width": 224.0, + "height": 384.0 + }, + "collapsed": false + }, + "5035459a-2b6e-535d-a68b-ba06ebfbbe99": { + "id": "5035459a-2b6e-535d-a68b-ba06ebfbbe99", + "alias": "sa_system_boundary_and_functions_sa_relay_work", + "element": "3fc7b01b-75f4-53bf-bd31-b9840efe36fb", + "position": { + "x": 404.0, + "y": 112.0 + }, + "size": { + "width": 224.0, + "height": 384.0 + }, + "collapsed": false + }, + "72553e3a-6e2d-5bee-b2d6-1f3a1b8c70ba": { + "id": "72553e3a-6e2d-5bee-b2d6-1f3a1b8c70ba", + "alias": "sa_system_boundary_and_functions_sa_relay_second", + "element": "4656d08f-158b-53eb-b368-e53083dfaed5", + "position": { + "x": 428.0, + "y": 344.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "75920e7a-4586-58b7-9eb2-7e0a3d8a1825": { + "id": "75920e7a-4586-58b7-9eb2-7e0a3d8a1825", + "alias": "sa_system_boundary_and_functions_rescue_coordination_system", + "element": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "position": { + "x": 720.0, + "y": 40.0 + }, + "size": { + "width": 272.0, + "height": 600.0 + }, + "collapsed": false + }, + "794f31c9-3acf-5437-921c-2e1687c95bf7": { + "id": "794f31c9-3acf-5437-921c-2e1687c95bf7", + "alias": "sa_system_boundary_and_functions_sa_coastal_relay", + "element": "0aa33dc1-57eb-5307-9dcc-c566682c99f7", + "position": { + "x": 380.0, + "y": 40.0 + }, + "size": { + "width": 272.0, + "height": 600.0 + }, + "collapsed": false + }, + "8d19f1de-2a28-57de-b214-fec91490669d": { + "id": "8d19f1de-2a28-57de-b214-fec91490669d", + "alias": "sa_system_boundary_and_functions_sa_relay_first", + "element": "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436", + "position": { + "x": 428.0, + "y": 184.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "8ea19a3f-6de3-5f68-a774-13e3fbb2ca1b": { + "id": "8ea19a3f-6de3-5f68-a774-13e3fbb2ca1b", + "alias": "sa_system_boundary_and_functions_sa_vessel_second", + "element": "febf00a2-efed-5faf-b8c2-5d4bc77ddb53", + "position": { + "x": 88.0, + "y": 344.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "923dad5a-8849-525c-865f-39e26d0ecf36": { + "id": "923dad5a-8849-525c-865f-39e26d0ecf36", + "alias": "sa_system_boundary_and_functions_sa_vessel_work", + "element": "95fcc41c-81c3-5183-8b7d-f6d7e2a0f67c", + "position": { + "x": 64.0, + "y": 112.0 + }, + "size": { + "width": 224.0, + "height": 384.0 + }, + "collapsed": false + }, + "cda20386-a3c2-5f88-8d84-2966d9655e2e": { + "id": "cda20386-a3c2-5f88-8d84-2966d9655e2e", + "alias": "sa_system_boundary_and_functions_transmit_distress_report", + "element": "f5497540-43a7-5573-826b-61eb7e4760a9", + "position": { + "x": 88.0, + "y": 184.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + }, + "fd95388c-dc7e-54cf-9005-0a087dcbab52": { + "id": "fd95388c-dc7e-54cf-9005-0a087dcbab52", + "alias": "sa_system_boundary_and_functions_vessel_communication_service", + "element": "3eafabe6-d6ca-5127-a660-d81213347de0", + "position": { + "x": 40.0, + "y": 40.0 + }, + "size": { + "width": 272.0, + "height": 600.0 + }, + "collapsed": false + }, + "ffe8645d-8eea-5b41-95e6-6384b83e2641": { + "id": "ffe8645d-8eea-5b41-95e6-6384b83e2641", + "alias": "sa_system_boundary_and_functions_classify_incident_and_alert_operator", + "element": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "position": { + "x": 768.0, + "y": 184.0 + }, + "size": { + "width": 176.0, + "height": 132.0 + }, + "collapsed": false + } + }, + "routes": [] + } + }, + "artifact_links": { + "c1da9a6c-abd3-53be-9129-bf6daa83b288": { + "id": "c1da9a6c-abd3-53be-9129-bf6daa83b288", + "alias": "console_enclosure_cad", + "name": "Console enclosure CAD", + "description": "Illustrative external engineering reference; opening a model does not fetch it.", + "owner": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "relation": "References", + "uri": "cad://rescue-console/enclosure.step", + "revision": "B.3", + "fragment": null + }, + "da671f6a-a673-5ae8-85e6-41f39ffded6a": { + "id": "da671f6a-a673-5ae8-85e6-41f39ffded6a", + "alias": "response_implementation", + "name": "Response implementation", + "description": "Illustrative external engineering reference; opening a model does not fetch it.", + "owner": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "relation": "Implements", + "uri": "git+https://example.org/rescue/control?path=src/response.rs", + "revision": "design-v2", + "fragment": null + } + }, + "traces": { + "0fd7b637-5acf-5b8b-8cc1-3115c31ed995": { + "id": "0fd7b637-5acf-5b8b-8cc1-3115c31ed995", + "alias": "trace_advice_to_relay", + "name": "Advice to relay ↔ Advice to relay", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "9b930e28-6a0f-5b25-98f0-5aec4f542d90", + "sa": "c89e57d4-c77e-5f29-8000-b1d9182a4596", + "kind": "Exchange", + "baseline": { + "oa": { + "name": "Advice to relay", + "description": "" + }, + "sa": { + "name": "Advice to relay", + "description": "" + } + } + }, + "1012eb71-7412-5a60-a3bd-f0e285347f02": { + "id": "1012eb71-7412-5a60-a3bd-f0e285347f02", + "alias": "trace_rescue_coordination", + "name": "Rescue coordination ↔ Rescue coordination system", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "ddb01361-5d9e-5a45-87be-58ac4755ef03", + "sa": "30fc41ea-fc3d-5b57-9a05-67b14425fad9", + "kind": "Participant", + "baseline": { + "oa": { + "name": "Rescue team", + "description": "" + }, + "sa": { + "name": "Rescue system", + "description": "" + } + } + }, + "1eb80c6e-21a3-5d26-b0ef-c865d913cf14": { + "id": "1eb80c6e-21a3-5d26-b0ef-c865d913cf14", + "alias": "trace_protect_life_at_sea", + "name": "Protect life at sea ↔ Coordinate rescue response", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "8c1deb44-f362-56d5-9297-8ec84dd3cb4d", + "sa": "e6832e4f-9352-5a22-87b6-0c06b3140d50", + "kind": "Capability", + "baseline": { + "oa": { + "name": "Protect life at sea", + "description": "" + }, + "sa": { + "name": "Coordinate rescue response", + "description": "" + } + } + }, + "202a189f-cd85-50a4-a6ca-7990907cdfe2": { + "id": "202a189f-cd85-50a4-a6ca-7990907cdfe2", + "alias": "trace_assess_incident", + "name": "Assess incident ↔ Classify incident and alert operator", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "b065b859-8b5e-5295-b214-69a2e7c3d4bb", + "sa": "b05744bd-4dce-54b7-a9ff-8861d11dc1e0", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Assess incident", + "description": "" + }, + "sa": { + "name": "Assess incident", + "description": "" + } + } + }, + "23d3cc11-532d-595e-8acb-c9cca7d17eea": { + "id": "23d3cc11-532d-595e-8acb-c9cca7d17eea", + "alias": "trace_vessel_in_distress", + "name": "Vessel in distress ↔ Vessel communication service", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "f2bb5075-31b6-586c-8e53-7df0d7478cf4", + "sa": "3eafabe6-d6ca-5127-a660-d81213347de0", + "kind": "Participant", + "baseline": { + "oa": { + "name": "Vessel", + "description": "" + }, + "sa": { + "name": "Vessel service", + "description": "" + } + } + }, + "2f53a69c-d13a-5eb5-abe0-cdd0c704e777": { + "id": "2f53a69c-d13a-5eb5-abe0-cdd0c704e777", + "alias": "trace_direct_advice", + "name": "Direct advice ↔ Direct advice", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "844bdfbe-c481-5055-98b8-ec38a1603769", + "sa": "956d5b0a-1e34-518f-b46d-425751998bbc", + "kind": "Exchange", + "baseline": { + "oa": { + "name": "Direct advice", + "description": "" + }, + "sa": { + "name": "Direct advice", + "description": "" + } + } + }, + "35c86a52-4bb2-5c42-83ea-cd4e94a348d6": { + "id": "35c86a52-4bb2-5c42-83ea-cd4e94a348d6", + "alias": "trace_workshop_oa_rescue_second", + "name": "Send advice ↔ Send advice", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "36164305-7318-5777-bb37-1b69796bba35", + "sa": "b8896811-d893-50fc-b695-d2ee07dae9e3", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Send advice", + "description": "" + }, + "sa": { + "name": "Send advice", + "description": "" + } + } + }, + "3ce04971-d8f5-52e8-8e84-7cbc560aab15": { + "id": "3ce04971-d8f5-52e8-8e84-7cbc560aab15", + "alias": "trace_distress_report", + "name": "Distress report ↔ Digital distress report", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "e545eb5b-109f-5862-8a15-ed40cc564035", + "sa": "080677b3-a619-5da3-906b-bfe69327eb57", + "kind": "Item", + "baseline": { + "oa": { + "name": "Distress report", + "description": "" + }, + "sa": { + "name": "Digital distress report", + "description": "" + } + } + }, + "3e8a9d77-06a1-59ec-9989-695b9b13fc25": { + "id": "3e8a9d77-06a1-59ec-9989-695b9b13fc25", + "alias": "trace_advice_to_vessel", + "name": "Relayed advice ↔ Relayed advice", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "659fe810-36bb-50d8-bc55-f761ef1c02d3", + "sa": "076628bf-719a-52f1-a30f-e479e057b4e9", + "kind": "Exchange", + "baseline": { + "oa": { + "name": "Relayed advice", + "description": "" + }, + "sa": { + "name": "Relayed advice", + "description": "" + } + } + }, + "3f1465d7-3438-5f3d-b50c-443d19cf4e75": { + "id": "3f1465d7-3438-5f3d-b50c-443d19cf4e75", + "alias": "trace_workshop_oa_relay_first", + "name": "Forward report ↔ Forward report", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "eb85c896-ed8f-5eb4-a9ad-3f3a817c3f2e", + "sa": "8b23ecf0-f5ce-57cf-8bce-8e0c08f89436", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Forward report", + "description": "" + }, + "sa": { + "name": "Forward report", + "description": "" + } + } + }, + "4522228a-dde5-5b4b-8c24-a08c3ac3f986": { + "id": "4522228a-dde5-5b4b-8c24-a08c3ac3f986", + "alias": "trace_workshop_oa_vessel_work", + "name": "Vessel contact ↔ Vessel contact", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "5cf70948-ec50-5caf-bca9-fedaeb5f971c", + "sa": "95fcc41c-81c3-5183-8b7d-f6d7e2a0f67c", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Vessel contact", + "description": "" + }, + "sa": { + "name": "Vessel contact", + "description": "" + } + } + }, + "5445c826-bb54-5d13-9de6-0c758dac8dac": { + "id": "5445c826-bb54-5d13-9de6-0c758dac8dac", + "alias": "trace_workshop_oa_rescue_work", + "name": "Rescue response ↔ Rescue response", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "97f7bcde-b8d8-56b2-ac5c-740506c38166", + "sa": "14f31813-a548-595b-a217-34412c1692ab", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Rescue response", + "description": "" + }, + "sa": { + "name": "Rescue response", + "description": "" + } + } + }, + "59db4085-d057-560d-866e-0436b156aa3b": { + "id": "59db4085-d057-560d-866e-0436b156aa3b", + "alias": "trace_workshop_oa_relay_work", + "name": "Coastal traffic ↔ Coastal traffic", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "5c84fe4d-b5a7-5dd2-a4da-3ee03803c138", + "sa": "3fc7b01b-75f4-53bf-bd31-b9840efe36fb", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Coastal traffic", + "description": "" + }, + "sa": { + "name": "Coastal traffic", + "description": "" + } + } + }, + "59dc3949-de08-56d9-a24f-e1906ee39d3d": { + "id": "59dc3949-de08-56d9-a24f-e1906ee39d3d", + "alias": "trace_incident_decision", + "name": "Incident decision ↔ Incident decision", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "bc6da29f-91fb-5e86-ad07-f714805f344c", + "sa": "526753bc-88b0-5322-bffc-1b36376becf1", + "kind": "Exchange", + "baseline": { + "oa": { + "name": "Incident decision", + "description": "" + }, + "sa": { + "name": "Incident decision", + "description": "" + } + } + }, + "7d789667-96c6-5538-9afb-768c43fcee84": { + "id": "7d789667-96c6-5538-9afb-768c43fcee84", + "alias": "trace_workshop_oa_vessel_second", + "name": "Confirm advice ↔ Confirm advice", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "cd43dcb2-d417-5f7c-a065-2f79b7759b6d", + "sa": "febf00a2-efed-5faf-b8c2-5d4bc77ddb53", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Confirm advice", + "description": "" + }, + "sa": { + "name": "Confirm advice", + "description": "" + } + } + }, + "8450368f-3f6b-5fe1-99a7-ac266c65b4f4": { + "id": "8450368f-3f6b-5fe1-99a7-ac266c65b4f4", + "alias": "trace_coastal_relay", + "name": "Coastal relay ↔ Coastal relay", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "606b870d-be72-5f5b-8067-bcaea1b3e70e", + "sa": "0aa33dc1-57eb-5307-9dcc-c566682c99f7", + "kind": "Participant", + "baseline": { + "oa": { + "name": "Coastal relay", + "description": "" + }, + "sa": { + "name": "Coastal relay", + "description": "" + } + } + }, + "a5ca123c-e79a-5897-ba7e-9bfe41dd8f26": { + "id": "a5ca123c-e79a-5897-ba7e-9bfe41dd8f26", + "alias": "trace_distress_received", + "name": "Distress received ↔ Report handled", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "06355b22-2b30-561c-8cfe-6eb5eccefec6", + "sa": "04dd0e11-8ec8-5abf-869e-8d718b587b63", + "kind": "Scenario", + "baseline": { + "oa": { + "name": "Distress received", + "description": "" + }, + "sa": { + "name": "Report handled", + "description": "" + } + } + }, + "ab075c48-de3e-5254-9fc5-3d05aeaa2967": { + "id": "ab075c48-de3e-5254-9fc5-3d05aeaa2967", + "alias": "trace_respond_to_distress", + "name": "Respond to distress ↔ Manage distress response", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "40078074-1925-5b68-8640-ecca13bd3c32", + "sa": "4099917c-0e9c-5535-8b89-6dc614a2f0c9", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Respond to distress", + "description": "" + }, + "sa": { + "name": "Manage distress response", + "description": "" + } + } + }, + "be0dc087-1905-5be2-bcbd-cc3538a2271b": { + "id": "be0dc087-1905-5be2-bcbd-cc3538a2271b", + "alias": "trace_workshop_oa_relay_second", + "name": "Forward advice ↔ Forward advice", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "69295b0a-afb4-503c-b98e-783f2429802a", + "sa": "4656d08f-158b-53eb-b368-e53083dfaed5", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Forward advice", + "description": "" + }, + "sa": { + "name": "Forward advice", + "description": "" + } + } + }, + "d6fba43a-a420-5438-b095-bcee2e2e0936": { + "id": "d6fba43a-a420-5438-b095-bcee2e2e0936", + "alias": "trace_distress_signal", + "name": "Distress signal ↔ Validated distress report", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "f6d8f4b9-8ac8-58e6-bf04-c446f9722b33", + "sa": "a15f7dfd-ac0b-562a-a633-fadc9fb64176", + "kind": "Exchange", + "baseline": { + "oa": { + "name": "Distress signal", + "description": "" + }, + "sa": { + "name": "Validated distress report", + "description": "" + } + } + }, + "e065f9ce-83b9-5af8-b3a6-9542b55328bf": { + "id": "e065f9ce-83b9-5af8-b3a6-9542b55328bf", + "alias": "trace_relay_to_rescue", + "name": "Relayed report ↔ Relayed report", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "a33b68f1-c297-5bd5-96ab-75bab66b92b1", + "sa": "61782ac2-5817-5705-8cfc-baa1be5d6cb0", + "kind": "Exchange", + "baseline": { + "oa": { + "name": "Relayed report", + "description": "" + }, + "sa": { + "name": "Relayed report", + "description": "" + } + } + }, + "e795d325-7f3d-5c6f-aadf-0506a7146ce9": { + "id": "e795d325-7f3d-5c6f-aadf-0506a7146ce9", + "alias": "trace_report_to_relay", + "name": "Report to relay ↔ Report to relay", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "9eaa1fc3-44e0-5091-b117-1358fd8e2a05", + "sa": "4678335a-04ae-5a19-a302-ea583bdd6c65", + "kind": "Exchange", + "baseline": { + "oa": { + "name": "Report to relay", + "description": "" + }, + "sa": { + "name": "Report to relay", + "description": "" + } + } + }, + "fcb6f83b-4c2f-580d-bcc5-25a11ac0b53d": { + "id": "fcb6f83b-4c2f-580d-bcc5-25a11ac0b53d", + "alias": "trace_report_distress", + "name": "Report distress ↔ Transmit distress report", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "184a46a3-9695-5b47-a736-880e18775e09", + "sa": "f5497540-43a7-5573-826b-61eb7e4760a9", + "kind": "Refinement", + "baseline": { + "oa": { + "name": "Report distress", + "description": "" + }, + "sa": { + "name": "Send distress", + "description": "" + } + } + }, + "fcc38192-797a-5fa7-a63a-bc5778ec5d4f": { + "id": "fcc38192-797a-5fa7-a63a-bc5778ec5d4f", + "alias": "trace_distress_to_response", + "name": "Distress to response ↔ Digital distress handling", + "description": "Reviewed OA/SA correspondence in the coastal rescue example.", + "oa": "7ef353cf-a4e3-56d2-bd3d-9d86cf2885a7", + "sa": "608fdf4f-e596-5b7e-aa79-2c6656cb2970", + "kind": "Sequence", + "baseline": { + "oa": { + "name": "Distress to response", + "description": "" + }, + "sa": { + "name": "Digital distress handling", + "description": "" + } + } + }, + "fdaff816-20ea-5eeb-8a6d-a75ac456771b": { + "id": "fdaff816-20ea-5eeb-8a6d-a75ac456771b", + "alias": "trace_safety_advice", + "name": "Safety advice ↔ Safety advice", + "description": "OA/SA correspondence in the routing workshop.", + "oa": "435cc548-f6f7-5fdb-bfb6-0bb68a8deb04", + "sa": "c53454d5-4cb3-53ee-bfaa-8506795fd89c", + "kind": "Item", + "baseline": { + "oa": { + "name": "Safety advice", + "description": "" + }, + "sa": { + "name": "Safety advice", + "description": "" + } + } + } + } +}