@memoarchitect/ontology 0.4.4

package/examples/gpca-pump/model/catalog/gpca_verification.sysml

@@ -0,0 +1,285 @@
+package memo_examples_gpca_pump_model_catalog_gpca_verification {
+    private import ScalarValues::*;
+
+    private import memo_architecture_assurance::*;
+    private import memo_core_enumerations::*;
+
+    // ── Verification cases ──────────────────────────────────────
+    part vcModeRange : VerificationCase {
+        attribute :>> id = "VER-001";
+        attribute :>> name = "VerifyModeRange";
+        attribute :>> methodKind = VerificationMethodKind::formalProof;
+        attribute :>> acceptanceCriteria = "Current_System_mode only takes valid exclusive values";
+        attribute :>> status = "planned";
+    }
+    part vcLockout : VerificationCase {
+        attribute :>> id = "VER-002";
+        attribute :>> name = "VerifyBolusLockout";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "No patient bolus initiated when lockout or max bolus constraints active";
+        attribute :>> status = "planned";
+    }
+    part vcSameStepAlarm : VerificationCase {
+        attribute :>> id = "VER-003";
+        attribute :>> name = "VerifySameStepAlarmStop";
+        attribute :>> methodKind = VerificationMethodKind::modelChecking;
+        attribute :>> acceptanceCriteria = "Alarm output affects infusion in same execution step";
+        attribute :>> status = "planned";
+    }
+    part vcTemporalModeSafety : VerificationCase {
+        attribute :>> id = "VER-004";
+        attribute :>> name = "VerifyTemporalModeSafety";
+        attribute :>> methodKind = VerificationMethodKind::modelChecking;
+        attribute :>> acceptanceCriteria = "No invalid transitions and pause on critical alarms";
+        attribute :>> status = "planned";
+    }
+    part vcAirInLine : VerificationCase {
+        attribute :>> id = "VER-005";
+        attribute :>> name = "VerifyAirInLineStop";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Injected air above threshold pauses infusion and annunciates per the REQ 59 High-priority actions (REQ-CS-21)";
+        attribute :>> status = "planned";
+    }
+    part vcOcclusion : VerificationCase {
+        attribute :>> id = "VER-006";
+        attribute :>> name = "VerifyOcclusionDetection";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Clamped line above pressure threshold pauses infusion and annunciates (REQ-X-04)";
+        attribute :>> status = "planned";
+    }
+    part vcEmptyReservoir : VerificationCase {
+        attribute :>> id = "VER-007";
+        attribute :>> name = "VerifyEmptyReservoirStop";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Reservoir-empty assertion transitions to PAUSED (KVO flow) and annunciates per the REQ 59 High-priority actions (REQ-CS-23)";
+        attribute :>> status = "planned";
+    }
+    part vcPost : VerificationCase {
+        attribute :>> id = "VER-008";
+        attribute :>> name = "VerifyPowerOnSelfTest";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Each injected POST fault (CPU, RAM, ROM, watchdog, sensors) blocks therapy and alarms (REQ-X-02)";
+        attribute :>> status = "planned";
+    }
+    part vcPowerLoss : VerificationCase {
+        attribute :>> id = "VER-009";
+        attribute :>> name = "VerifyPowerLossRetentionAndResume";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Prescription and log intact after power cycle; therapy resumes only after confirmation (REQ-X-03)";
+        attribute :>> status = "planned";
+    }
+    part vcWatchdog : VerificationCase {
+        attribute :>> id = "VER-010";
+        attribute :>> name = "VerifyWatchdogSafeState";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Induced CPU hang forces zero flow and continuous alarm within 60 ms (REQ-X-08, TC-003)";
+        attribute :>> status = "planned";
+    }
+    part vcHourlyMax : VerificationCase {
+        attribute :>> id = "VER-011";
+        attribute :>> name = "VerifyHourlyDoseCeiling";
+        attribute :>> methodKind = VerificationMethodKind::simulation;
+        attribute :>> acceptanceCriteria = "Randomized bolus/basal schedules never exceed hourly maximum in sliding window (REQ-X-06)";
+        attribute :>> status = "planned";
+    }
+    part vcPumpAccuracy : VerificationCase {
+        attribute :>> id = "VER-012";
+        attribute :>> name = "VerifyDeliveryAccuracy";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Gravimetric bench measurement within ±5% (Tolerance_Min_const) across rate range (REQ-X-11)";
+        attribute :>> status = "planned";
+    }
+    part vcAlarmLoudness : VerificationCase {
+        attribute :>> id = "VER-013";
+        attribute :>> name = "VerifyAlarmSoundPressure";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Each priority tone meets Audio_level_const, 50 db for 2 s per I 8 (REQ-X-12)";
+        attribute :>> status = "planned";
+    }
+    part vcFreeFlow : VerificationCase {
+        attribute :>> id = "VER-014";
+        attribute :>> name = "VerifyAntiFreeFlowValve";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "No gravity flow with set disengaged under worst-case head height (REQ-X-14)";
+        attribute :>> status = "planned";
+    }
+    part vcStuckButton : VerificationCase {
+        attribute :>> id = "VER-015";
+        attribute :>> name = "VerifyStuckButtonDetection";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Shorted pendant input yields no bolus and Medium-priority notification after 60 s (REQ-X-09)";
+        attribute :>> status = "planned";
+    }
+    part vcFlowCrossCheck : VerificationCase {
+        attribute :>> id = "VER-016";
+        attribute :>> name = "VerifyFlowCrossCheck";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Injected deviation beyond Tolerance_Min_const sustained past Max_Duration_OverInfusion_const pauses therapy and annunciates (REQ-X-10)";
+        attribute :>> status = "planned";
+    }
+
+    part vcDrugLibrary : VerificationCase {
+        attribute :>> id = "VER-017";
+        attribute :>> name = "VerifyDrugLibraryEnforcement";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Hard-limit entries rejected, soft-limit entries require confirmation, both logged (REQ-X-01)";
+        attribute :>> status = "planned";
+    }
+    part vcPrescriptionConfirm : VerificationCase {
+        attribute :>> id = "VER-018";
+        attribute :>> name = "VerifyPrescriptionConfirmation";
+        attribute :>> methodKind = VerificationMethodKind::demonstration;
+        attribute :>> acceptanceCriteria = "Therapy cannot start without distinct confirmation; displayed values equal stored values (REQ-CS-09)";
+        attribute :>> status = "planned";
+    }
+    part vcEventLog : VerificationCase {
+        attribute :>> id = "VER-019";
+        attribute :>> name = "VerifyEventLogIntegrity";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Operational/error log entries per REQ-CS-78..81; tampering detectable (REQ-X-07)";
+        attribute :>> status = "planned";
+    }
+    part vcReverseDeliveryPause : VerificationCase {
+        attribute :>> id = "VER-020";
+        attribute :>> name = "VerifyReverseDeliveryPause";
+        attribute :>> methodKind = VerificationMethodKind::modelChecking;
+        attribute :>> acceptanceCriteria = "Continuous or cumulative reverse delivery beyond the REQ-CS-22 duration limits transitions to PAUSED and raises the Reverse Delivery notification (NOTIF-04)";
+        attribute :>> status = "planned";
+    }
+    part vcAntiRefluxMechanism : VerificationCase {
+        attribute :>> id = "VER-021";
+        attribute :>> name = "VerifyContinuousReverseDeliveryPrevention";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "During normal use and single fault condition, continuous reverse delivery is not possible (IEC 601-2-24 basis per GPCA safety requirements)";
+        attribute :>> status = "planned";
+    }
+    part vcVtbiCeiling : VerificationCase {
+        attribute :>> id = "VER-022";
+        attribute :>> name = "VerifyVtbiCeilingPause";
+        attribute :>> methodKind = VerificationMethodKind::modelChecking;
+        attribute :>> acceptanceCriteria = "Actual volume infused above the drug-database maximum VTBI transitions to PAUSED with flow at most KVO (REQ-CS-20, AGREE GP-008) and raises NOTIF-06";
+        attribute :>> status = "planned";
+    }
+    part vcInfusionComplete : VerificationCase {
+        attribute :>> id = "VER-023";
+        attribute :>> name = "VerifyInfusionCompleteStop";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Reaching prescribed total duration or maximum VTBI transitions ACTIVE to IDLE with Infusion Complete actions (REQ-CS-28)";
+        attribute :>> status = "planned";
+    }
+    part vcDoorInterlock : VerificationCase {
+        attribute :>> id = "VER-024";
+        attribute :>> name = "VerifyDoorOpenDeliveryInhibit";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Door open during THERAPY limits flow to at most KVO and raises a notification (AGREE GP-011; REQ-X-05)";
+        attribute :>> status = "planned";
+    }
+
+    // ── Validation cases (design validation / IEC 62366) ────────
+    part valSimulatedWard : ValidationCase {
+        attribute :>> id = "VAL-001";
+        attribute :>> name = "SimulatedWardTherapyValidation";
+        attribute :>> validationMethod = ValidationMethodKind::simulatedUse;
+        attribute :>> userParticipation = "nurses and physicians on a simulated ward";
+        attribute :>> acceptanceCriteria = "Complete therapy scenarios OS-001..OS-006 executed without unresolved use difficulty";
+        attribute :>> clinicalContext = "post-operative PCA therapy in acute care";
+    }
+    part valSummativeUsability : ValidationCase {
+        attribute :>> id = "VAL-002";
+        attribute :>> name = "SummativeUsabilityTest";
+        attribute :>> validationMethod = ValidationMethodKind::summativeUsabilityTest;
+        attribute :>> userParticipation = "15 representative clinical users per user group";
+        attribute :>> acceptanceCriteria = "No critical use errors (UE-001..UE-004) observed on safety-related tasks; residual difficulty acceptable per IEC 62366-1";
+        attribute :>> clinicalContext = "prescription programming, reservoir change, alarm response";
+    }
+
+    // ── Test artifacts and evidence ─────────────────────────────
+    part testReportLockout : TestArtifact {
+        attribute :>> id = "TEST-001";
+        attribute :>> name = "BolusLockoutTestReport";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> artifactKind = ArtifactKind::testReport;
+        attribute :>> resultSummary = "planned";
+    }
+    part testProtocolSafetySuite : TestArtifact {
+        attribute :>> id = "TEST-002";
+        attribute :>> name = "SafetyAlarmTestProtocol";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> artifactKind = ArtifactKind::testProtocol;
+        attribute :>> resultSummary = "covers VER-005..VER-010, VER-015, VER-016, VER-020, VER-022..VER-024";
+    }
+    part evidenceLockout : Evidence {
+        attribute :>> id = "EVD-001";
+        attribute :>> name = "BolusLockoutEvidence";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> evidenceType = "verification evidence";
+        attribute :>> integrityStatus = "draft";
+    }
+    part evidenceModeRange : Evidence {
+        attribute :>> id = "EVD-002";
+        attribute :>> name = "ModeRangeEvidence";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> evidenceType = "formal proof evidence";
+        attribute :>> integrityStatus = "draft";
+    }
+    part evidenceSameStepAlarm : Evidence {
+        attribute :>> id = "EVD-003";
+        attribute :>> name = "SameStepAlarmEvidence";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> evidenceType = "model checking evidence";
+        attribute :>> integrityStatus = "draft";
+    }
+    part evidenceTemporalModeSafety : Evidence {
+        attribute :>> id = "EVD-004";
+        attribute :>> name = "TemporalModeSafetyEvidence";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> evidenceType = "model checking evidence";
+        attribute :>> integrityStatus = "draft";
+    }
+    part evidenceSafetyAlarmSuite : Evidence {
+        attribute :>> id = "EVD-005";
+        attribute :>> name = "SafetyAlarmSuiteEvidence";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> evidenceType = "bench test evidence for alarm-driven safe states";
+        attribute :>> integrityStatus = "draft";
+    }
+    part evidenceUsability : Evidence {
+        attribute :>> id = "EVD-006";
+        attribute :>> name = "SummativeUsabilityEvidence";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> evidenceType = "summative usability report per IEC 62366-1";
+        attribute :>> integrityStatus = "draft";
+    }
+    part evidenceHardwareBench : Evidence {
+        attribute :>> id = "EVD-008";
+        attribute :>> name = "HardwareBenchEvidence";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> evidenceType = "bench evidence for alarm loudness and anti-free-flow valve";
+        attribute :>> integrityStatus = "draft";
+    }
+    part evidenceDoseProgramming : Evidence {
+        attribute :>> id = "EVD-009";
+        attribute :>> name = "DoseProgrammingEvidence";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> evidenceType = "test evidence for prescription limits, confirmation, dose ceiling, and event log";
+        attribute :>> integrityStatus = "draft";
+    }
+    part evidenceDeliveryAccuracy : Evidence {
+        attribute :>> id = "EVD-007";
+        attribute :>> name = "DeliveryAccuracyEvidence";
+        attribute :>> version = "0.1";
+        attribute :>> lifecycleState = LifecycleStateKind::development;
+        attribute :>> evidenceType = "gravimetric bench test evidence";
+        attribute :>> integrityStatus = "draft";
+    }
+}

package/examples/gpca-pump/model/samples/README.md

@@ -0,0 +1,24 @@
+# Diagram rendering samples
+
+This folder backs MEMO Architect's **Samples** experience with small, disposable
+SysML v2 inputs. Each file exists only to exercise one renderer; together they
+do not describe a product or reference architecture.
+
+## Action Flow samples
+
+| File | Shows |
+|------|-------|
+| `action_flow_view.sysml` | Minimal renderer smoke test — dummy actions, typed item flows, successions, one composite. |
+| `operational_behaviour_view.sysml` | **Operational** behaviour — swimlanes per clinical role (Physician/Nurse/Biomed Tech/Patient), a `fork`/`join` for concurrent prep, and a composite step (`Administer PCA Therapy`) with a drill-in sub-flow. |
+| `functional_flow_view.sysml` | **Functional/component** behaviour — swimlanes per realising component, typed data/energy/material flows, a `fork`/`join` for concurrent occlusion monitoring, and a composite `Deliver Medication` valve sub-flow. |
+
+`fork`/`join` are SysML v2 control nodes: a `fork` splits one control flow into
+concurrent flows, a `join` synchronises them back; the branches are declared by
+the surrounding `first … then …` successions that reference the node by name.
+
+The first rendering milestone covers interconnection, tree, and action flow.
+Run the supported example application from the repository root:
+
+```sh
+pnpm example:dev
+```

package/examples/gpca-pump/model/samples/action_flow_view.sysml

@@ -0,0 +1,72 @@
+package memo_examples_gpca_pump_model_samples_action_flow_view {
+    private import ScalarValues::*;
+    private import memo_core_relationships::*;
+
+    private import memo_architecture_logical_structure::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    item def DataPacket;
+    item def EnergyToken;
+    item def MaterialBatch;
+
+    action def ReceiveInput { out received : DataPacket; }
+    action def ValidateInput { in received : DataPacket; out validated : EnergyToken; }
+    action def ProcessInput { in validated : EnergyToken; out result : MaterialBatch; }
+    action def RecordResult { in result : MaterialBatch; }
+
+    part laneA : LogicalComponent { attribute :>> name = "Lane A"; }
+    part laneB : LogicalComponent { attribute :>> name = "Lane B"; }
+
+    action sampleActionFlow {
+        action receive : ReceiveInput;
+        action validate : ValidateInput;
+        action process : ProcessInput {
+            action processStepA : ValidateInput;
+            action processStepB : ProcessInput;
+            action processStepC : ProcessInput;
+            first start then processStepA;
+            first processStepA then processStepB;
+            first processStepB then processStepC;
+            first processStepC then done;
+        }
+        action record : RecordResult;
+
+        flow of DataPacket from receive.received to validate.received;
+        flow of EnergyToken from validate.validated to process.validated;
+        flow of MaterialBatch from process.result to record.result;
+
+        first start then receive;
+        first receive then validate;
+        first validate then process;
+        first process then record;
+        first record then done;
+    }
+
+    allocate sampleActionFlow.receive to laneA;
+    allocate sampleActionFlow.validate to laneA;
+    allocate sampleActionFlow.process to laneB;
+    allocate sampleActionFlow.process.processStepA to laneB;
+    allocate sampleActionFlow.process.processStepB to laneB;
+    allocate sampleActionFlow.process.processStepC to laneB;
+    allocate sampleActionFlow.record to laneB;
+
+    view sampleActionFlowView : MemoDiagramView {
+        expose sampleActionFlow::**;
+        expose laneA;
+        expose laneB;
+        attribute depth = 2;
+        attribute :>> title = "Sample · Action Flow";
+        attribute :>> shortDescription = "Dummy actions, typed item flows, successions, and a composite action for renderer development.";
+        attribute :>> viewKind = DiagramViewKind::actionflow;
+        attribute :>> diagramType = "afd";
+    }
+
+    connection : IncludedIn connect sourceElement ::> sampleActionFlow.receive to targetView ::> sampleActionFlowView;
+    connection : IncludedIn connect sourceElement ::> sampleActionFlow.validate to targetView ::> sampleActionFlowView;
+    connection : IncludedIn connect sourceElement ::> sampleActionFlow.process to targetView ::> sampleActionFlowView;
+    connection : IncludedIn connect sourceElement ::> sampleActionFlow.process.processStepA to targetView ::> sampleActionFlowView;
+    connection : IncludedIn connect sourceElement ::> sampleActionFlow.process.processStepB to targetView ::> sampleActionFlowView;
+    connection : IncludedIn connect sourceElement ::> sampleActionFlow.process.processStepC to targetView ::> sampleActionFlowView;
+    connection : IncludedIn connect sourceElement ::> sampleActionFlow.record to targetView ::> sampleActionFlowView;
+}

package/examples/gpca-pump/model/samples/action_flow_view.viewlayout

@@ -0,0 +1,9 @@
+format: memo.viewlayout/v1
+viewSource: model/samples/action_flow_view.sysml
+layouts:
+  diag-sample-sampleActionFlowView:
+    nodes:
+    nodes: {}
+    edges: {}
+    canvas:
+      autoLayout: true

package/examples/gpca-pump/model/samples/functional_flow_view.sysml

@@ -0,0 +1,153 @@
+package memo_examples_gpca_pump_model_samples_functional_flow_view {
+    private import ScalarValues::*;
+
+    private import memo_architecture_logical_structure::*;
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Sample · Functional flow — component behaviour of dose delivery
+    //
+    // Demonstrates an Action Flow (activity) diagram of *functional/component*
+    // behaviour: how the architecture components collaborate to deliver a dose.
+    // Swimlanes group functions by the component that realises them; typed item
+    // flows show data (blue), energy (orange) and material (green) moving
+    // between functions; a fork/join runs occlusion monitoring concurrently
+    // with drive/deliver; and `fxDeliver` is a composite (double-click to
+    // drill into its valve sub-flow, then "← Parent" to return).
+    // ─────────────────────────────────────────────────────────────────────────
+
+    // Typed flow payloads
+    item def FxSensorReading;
+    item def FxRateCommand;
+    item def FxMotorEnergy;
+    item def FxMedicationFluid;
+    item def FxOcclusionSignal;
+
+    // Functions with typed in/out pins
+    action def FxAcquire { out reading : FxSensorReading; }
+    action def FxCompute { in reading : FxSensorReading; out command : FxRateCommand; }
+    action def FxEnforce { in command : FxRateCommand; out safeCommand : FxRateCommand; }
+    action def FxDrive { in command : FxRateCommand; out energy : FxMotorEnergy; }
+    action def FxDeliverMedication { in energy : FxMotorEnergy; out fluid : FxMedicationFluid; }
+    action def FxMonitor { out signal : FxOcclusionSignal; }
+    action def FxDetect { in signal : FxOcclusionSignal; }
+
+    // Component hierarchy used by the Level control:
+    // L1 system → L2 subsystems → L3 allocated components.
+    part fxPumpSystem : LogicalComponent { attribute :>> name = "Infusion Pump System"; }
+    part fxSensingSubsystem : LogicalComponent { attribute :>> name = "Sensing Subsystem"; }
+    part fxControlSubsystem : LogicalComponent { attribute :>> name = "Control Subsystem"; }
+    part fxDeliverySubsystem : LogicalComponent { attribute :>> name = "Delivery Subsystem"; }
+    part fxSafetySubsystem : LogicalComponent { attribute :>> name = "Safety Subsystem"; }
+
+    // L3 components — one natural-level swimlane each
+    part fxSensor : LogicalComponent { attribute :>> name = "Sensor Subsystem"; }
+    part fxController : LogicalComponent { attribute :>> name = "Infusion Controller"; }
+    part fxActuator : LogicalComponent { attribute :>> name = "Pump Actuator"; }
+    part fxSafety : LogicalComponent { attribute :>> name = "Safety Monitor"; }
+
+    connection : Composes connect parent ::> fxPumpSystem to child ::> fxSensingSubsystem;
+    connection : Composes connect parent ::> fxPumpSystem to child ::> fxControlSubsystem;
+    connection : Composes connect parent ::> fxPumpSystem to child ::> fxDeliverySubsystem;
+    connection : Composes connect parent ::> fxPumpSystem to child ::> fxSafetySubsystem;
+    connection : Composes connect parent ::> fxSensingSubsystem to child ::> fxSensor;
+    connection : Composes connect parent ::> fxControlSubsystem to child ::> fxController;
+    connection : Composes connect parent ::> fxDeliverySubsystem to child ::> fxActuator;
+    connection : Composes connect parent ::> fxSafetySubsystem to child ::> fxSafety;
+
+    action fxDeliveryFlow {
+        action fxAcquire : FxAcquire { attribute name = "Acquire Sensor Data"; }
+        action fxCompute : FxCompute { attribute name = "Compute Infusion Rate"; }
+
+        // Split: enforce/drive/deliver runs concurrently with occlusion monitoring
+        fork fxForkDeliver;
+        action fxEnforce : FxEnforce { attribute name = "Enforce Dose Limits"; }
+        action fxDrive : FxDrive { attribute name = "Drive Pump Motor"; }
+        action fxMonitor : FxMonitor { attribute name = "Monitor Occlusion"; }
+        action fxDetect : FxDetect { attribute name = "Detect Occlusion"; }
+        join fxJoinDeliver;
+
+        // Composite function — valve sub-flow (drill-in)
+        action fxDeliver : FxDeliverMedication {
+            attribute name = "Deliver Medication";
+            action fxOpenValve { attribute name = "Open Valve"; }
+            action fxHoldDose { attribute name = "Hold Metered Dose"; }
+            action fxCloseValve { attribute name = "Close Valve"; }
+
+            flow of FxMedicationFluid from fxDeliveryFlow.fxDeliver.fxHoldDose to fxCloseValve;
+
+            first start then fxOpenValve;
+            first fxOpenValve then fxHoldDose;
+            first fxHoldDose then fxCloseValve;
+            first fxCloseValve then done;
+        }
+
+        action fxLog { attribute name = "Log Delivery"; }
+
+        flow of FxSensorReading from fxAcquire.reading to fxCompute.reading;
+        flow of FxRateCommand from fxEnforce.safeCommand to fxDrive.command;
+        flow of FxMotorEnergy from fxDrive.energy to fxDeliver.energy;
+        flow of FxOcclusionSignal from fxMonitor.signal to fxDetect.signal;
+
+        first start then fxAcquire;
+        first fxAcquire then fxCompute;
+        first fxCompute then fxForkDeliver;
+        first fxForkDeliver then fxEnforce;
+        first fxForkDeliver then fxMonitor;
+        first fxEnforce then fxDrive;
+        first fxDrive then fxDeliver;
+        first fxMonitor then fxDetect;
+        first fxDeliver then fxJoinDeliver;
+        first fxDetect then fxJoinDeliver;
+        first fxJoinDeliver then fxLog;
+        first fxLog then done;
+    }
+
+    // Swimlane allocation — which component realises each function
+    allocate fxDeliveryFlow.fxAcquire to fxSensor;
+    allocate fxDeliveryFlow.fxCompute to fxController;
+    allocate fxDeliveryFlow.fxEnforce to fxSafety;
+    allocate fxDeliveryFlow.fxDrive to fxActuator;
+    allocate fxDeliveryFlow.fxDeliver to fxActuator;
+    allocate fxDeliveryFlow.fxMonitor to fxSafety;
+    allocate fxDeliveryFlow.fxDetect to fxSafety;
+    allocate fxDeliveryFlow.fxLog to fxController;
+    allocate fxDeliveryFlow.fxDeliver.fxOpenValve to fxActuator;
+    allocate fxDeliveryFlow.fxDeliver.fxHoldDose to fxActuator;
+    allocate fxDeliveryFlow.fxDeliver.fxCloseValve to fxActuator;
+
+    view fxDeliveryView : MemoDiagramView {
+        expose fxDeliveryFlow::**;
+        expose fxPumpSystem::**;
+        attribute depth = 2;
+        attribute :>> title = "Sample · Dose Delivery (Functional Flow)";
+        attribute :>> shortDescription = "Component behaviour: functions in swimlanes per realising component, typed data/energy/material flows, a fork/join for concurrent occlusion monitoring, and a composite 'Deliver Medication' valve sub-flow (double-click to drill in).";
+        attribute :>> viewKind = DiagramViewKind::actionflow;
+        attribute :>> diagramType = "ffd";
+    }
+
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxAcquire to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxCompute to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxForkDeliver to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxEnforce to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxDrive to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxDeliver to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxMonitor to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxDetect to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxJoinDeliver to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxLog to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxDeliver.fxOpenValve to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxDeliver.fxHoldDose to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliveryFlow.fxDeliver.fxCloseValve to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxPumpSystem to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxSensingSubsystem to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxControlSubsystem to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxDeliverySubsystem to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxSafetySubsystem to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxSensor to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxController to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxActuator to targetView ::> fxDeliveryView;
+    connection : IncludedIn connect sourceElement ::> fxSafety to targetView ::> fxDeliveryView;
+}

package/examples/gpca-pump/model/samples/interconnection_view.sysml

@@ -0,0 +1,93 @@
+package memo_examples_gpca_pump_model_samples_interconnection_view {
+    private import ScalarValues::*;
+    private import memo_architecture_context::*;
+
+    private import memo_architecture_interfaces::*;
+    private import memo_architecture_logical_structure::*;
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    part coffeeMachine : LogicalComponent { attribute :>> name = "Coffee Machine"; }
+    part waterSupply : LogicalComponent { attribute :>> name = "Water Supply"; }
+    part waterTank : LogicalComponent { attribute :>> name = "Water Reservoir"; }
+    part heaterAssembly : LogicalComponent { attribute :>> name = "Thermal Control Assembly"; }
+    part heatingElement : LogicalComponent { attribute :>> name = "Water Heating Element"; }
+    part brewGroup : LogicalComponent { attribute :>> name = "Brew Group"; }
+    part cup : LogicalComponent { attribute :>> name = "Cup"; }
+
+    port mainsWaterIn : DataPort { attribute :>> direction = DirectionKind::input; }
+    port beverageOut : DataPort { attribute :>> direction = DirectionKind::output; }
+    port supplyWaterOut : DataPort { attribute :>> direction = DirectionKind::output; }
+    port cupBeverageIn : DataPort { attribute :>> direction = DirectionKind::input; }
+    port serviceInterface : DataPort { attribute :>> direction = DirectionKind::bidirectional; }
+    port diagnostics : DataPort { attribute :>> direction = DirectionKind::output; }
+    port tankWaterOut : DataPort { attribute :>> direction = DirectionKind::output; }
+    port tankWaterIn : DataPort { attribute :>> direction = DirectionKind::input; }
+    port heaterWaterIn : DataPort { attribute :>> direction = DirectionKind::input; }
+    port heatedWaterOut : DataPort { attribute :>> direction = DirectionKind::output; }
+    port brewWaterIn : DataPort { attribute :>> direction = DirectionKind::input; }
+    port brewedCoffeeOut : DataPort { attribute :>> direction = DirectionKind::output; }
+    port heaterStatusOut : DataPort { attribute :>> direction = DirectionKind::output; }
+
+    connection : Composes connect parent ::> coffeeMachine to child ::> waterTank;
+    connection : Composes connect parent ::> coffeeMachine to child ::> heaterAssembly;
+    connection : Composes connect parent ::> coffeeMachine to child ::> brewGroup;
+    connection : Composes connect parent ::> coffeeMachine to child ::> mainsWaterIn;
+    connection : Composes connect parent ::> coffeeMachine to child ::> beverageOut;
+    connection : Composes connect parent ::> coffeeMachine to child ::> serviceInterface;
+    connection : Composes connect parent ::> serviceInterface to child ::> diagnostics;
+    connection : Composes connect parent ::> waterTank to child ::> tankWaterOut;
+    connection : Composes connect parent ::> waterTank to child ::> tankWaterIn;
+    connection : Composes connect parent ::> heaterAssembly to child ::> heatingElement;
+    connection : Composes connect parent ::> heaterAssembly to child ::> heaterWaterIn;
+    connection : Composes connect parent ::> heaterAssembly to child ::> heatedWaterOut;
+    connection : Composes connect parent ::> brewGroup to child ::> brewWaterIn;
+    connection : Composes connect parent ::> brewGroup to child ::> brewedCoffeeOut;
+    connection : Composes connect parent ::> heatingElement to child ::> heaterStatusOut;
+    connection : Composes connect parent ::> waterSupply to child ::> supplyWaterOut;
+    connection : Composes connect parent ::> cup to child ::> cupBeverageIn;
+
+    connection : ExchangesWith connect source ::> supplyWaterOut to target ::> mainsWaterIn;
+    connection : ExchangesWith connect source ::> mainsWaterIn to target ::> tankWaterIn;
+    connection : ExchangesWith connect source ::> tankWaterOut to target ::> heaterWaterIn;
+    connection : ExchangesWith connect source ::> heatedWaterOut to target ::> brewWaterIn;
+    connection : ExchangesWith connect source ::> brewedCoffeeOut to target ::> beverageOut;
+    connection : ExchangesWith connect source ::> beverageOut to target ::> cupBeverageIn;
+    connection : ExchangesWith connect source ::> heaterStatusOut to target ::> diagnostics;
+
+    view sampleInterconnectionView : MemoDiagramView {
+        expose coffeeMachine::**;
+        expose waterSupply::**;
+        expose cup::**;
+        attribute depth = 2;
+        attribute :>> title = "Coffee Machine · Thermal & Fluid IBD";
+        attribute :>> shortDescription = "Balanced internal architecture with readable boundary ports, nested service diagnostics, and external water and beverage interfaces.";
+        attribute :>> viewKind = DiagramViewKind::interconnection;
+        attribute :>> diagramType = "ibd";
+        part :>> selectionQuery {
+            attribute :>> includeRelationshipKinds = ("Composes", "ExchangesWith");
+        }
+    }
+
+    connection : IncludedIn connect sourceElement ::> coffeeMachine to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> waterSupply to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> waterTank to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> heaterAssembly to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> heatingElement to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> brewGroup to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> cup to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> mainsWaterIn to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> beverageOut to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> supplyWaterOut to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> cupBeverageIn to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> serviceInterface to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> diagnostics to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> tankWaterOut to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> tankWaterIn to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> heaterWaterIn to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> heatedWaterOut to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> brewWaterIn to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> brewedCoffeeOut to targetView ::> sampleInterconnectionView;
+    connection : IncludedIn connect sourceElement ::> heaterStatusOut to targetView ::> sampleInterconnectionView;
+}