@memoarchitect/ontology 0.6.4 → 0.7.0

package/examples/nested-architecture-dsm/model/catalog/architecture/logical/structure.sysml

@@ -0,0 +1,183 @@
+// Logical structure — the column axis of the DSM.
+//
+// Four levels deep on purpose (System → Subsystem → Subsystem → component),
+// so expanding and collapsing the matrix has something real to do. Nesting is
+// declared with Composes rather than left implicit, which is what the DSM
+// reads to build the column tree.
+package memo_examples_nested_architecture_dsm_architecture_logical_structure {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_logical_structure::*;
+
+    // ── Level 0: the system ──────────────────────────────────────
+    part sysTherapyDelivery : System {
+        attribute :>> id = "NDS-SYS-001"; attribute :>> name = "TherapyDeliverySystem";
+        attribute :>> componentRole = ComponentRoleKind::generic;
+        attribute :>> systemType = SystemTypeKind::logical;
+        attribute :>> systemBoundaryDescription = "Everything inside the pump enclosure, including its power path and user interface.";
+        attribute :>> responsibility = "Deliver a prescribed infusion safely and report what it delivered.";
+    }
+
+    // ── Level 1: subsystems ──────────────────────────────────────
+    part subFluidPath : Subsystem {
+        attribute :>> id = "NDS-SUB-001"; attribute :>> name = "FluidPathSubsystem";
+        attribute :>> componentRole = ComponentRoleKind::generic;
+        attribute :>> systemType = SystemTypeKind::hardware;
+        attribute :>> responsibility = "Move fluid from the reservoir to the patient line at a commanded rate.";
+    }
+    part subControl : Subsystem {
+        attribute :>> id = "NDS-SUB-002"; attribute :>> name = "ControlSubsystem";
+        attribute :>> componentRole = ComponentRoleKind::controlElement;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Decide what the fluid path should do, and hold the therapy state.";
+    }
+    part subUserInterface : Subsystem {
+        attribute :>> id = "NDS-SUB-003"; attribute :>> name = "UserInterfaceSubsystem";
+        attribute :>> componentRole = ComponentRoleKind::userInterface;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Present therapy state to the clinician and accept their input.";
+    }
+    part subPower : Subsystem {
+        attribute :>> id = "NDS-SUB-004"; attribute :>> name = "PowerSubsystem";
+        attribute :>> componentRole = ComponentRoleKind::generic;
+        attribute :>> systemType = SystemTypeKind::hardware;
+        attribute :>> responsibility = "Supply and monitor power across mains and battery operation.";
+    }
+
+    connection : Composes connect parent ::> sysTherapyDelivery to child ::> subFluidPath;
+    connection : Composes connect parent ::> sysTherapyDelivery to child ::> subControl;
+    connection : Composes connect parent ::> sysTherapyDelivery to child ::> subUserInterface;
+    connection : Composes connect parent ::> sysTherapyDelivery to child ::> subPower;
+
+    // ── Level 2: a subsystem inside a subsystem ──────────────────
+    // The safety monitor is nested one level deeper than its peers, which is
+    // what makes a collapsed ControlSubsystem row a genuine roll-up rather
+    // than a rename of its children.
+    part subSafetyMonitor : Subsystem {
+        attribute :>> id = "NDS-SUB-005"; attribute :>> name = "SafetyMonitorSubsystem";
+        attribute :>> componentRole = ComponentRoleKind::channel;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Watch the control path from outside it and stop delivery on breach.";
+        attribute :>> safetyPartition = "monitor partition, separate MPU region from the control partition";
+    }
+    connection : Composes connect parent ::> subControl to child ::> subSafetyMonitor;
+
+    // ── Level 2/3: components ────────────────────────────────────
+    part lcPumpMechanism : LogicalComponent {
+        attribute :>> id = "NDS-LC-001"; attribute :>> name = "PumpMechanism";
+        attribute :>> componentRole = ComponentRoleKind::controlElement;
+        attribute :>> systemType = SystemTypeKind::hardware;
+        attribute :>> responsibility = "Displace fluid under command.";
+        attribute :>> controlledVariable = "delivered volume per stroke";
+    }
+    part lcOcclusionChannel : LogicalComponent {
+        attribute :>> id = "NDS-LC-002"; attribute :>> name = "OcclusionSensingChannel";
+        attribute :>> componentRole = ComponentRoleKind::channel;
+        attribute :>> systemType = SystemTypeKind::hardware;
+        attribute :>> responsibility = "Sense line pressure and air in line.";
+        attribute :>> channelRole = ChannelRoleKind::primary;
+    }
+    part lcReservoirInterface : LogicalComponent {
+        attribute :>> id = "NDS-LC-003"; attribute :>> name = "ReservoirInterface";
+        attribute :>> componentRole = ComponentRoleKind::generic;
+        attribute :>> systemType = SystemTypeKind::hardware;
+        attribute :>> responsibility = "Seat the reservoir and expose its remaining volume.";
+    }
+    connection : Composes connect parent ::> subFluidPath to child ::> lcPumpMechanism;
+    connection : Composes connect parent ::> subFluidPath to child ::> lcOcclusionChannel;
+    connection : Composes connect parent ::> subFluidPath to child ::> lcReservoirInterface;
+
+    part lcDoseController : LogicalComponent {
+        attribute :>> id = "NDS-LC-004"; attribute :>> name = "DoseController";
+        attribute :>> componentRole = ComponentRoleKind::controlElement;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Turn a prescription into rate commands.";
+        attribute :>> controlLaw = "closed loop on delivered volume, saturated at the prescribed limit";
+        attribute :>> controlledVariable = "infusion rate";
+    }
+    part lcTherapyStateStore : LogicalComponent {
+        attribute :>> id = "NDS-LC-005"; attribute :>> name = "TherapyStateStore";
+        attribute :>> componentRole = ComponentRoleKind::dataStore;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Hold the active therapy record across power cycles.";
+        attribute :>> persistenceRequirement = "survives power loss with the last completed transaction intact";
+        attribute :>> integrityRequirement = "CRC per record, rejected on mismatch";
+    }
+    connection : Composes connect parent ::> subControl to child ::> lcDoseController;
+    connection : Composes connect parent ::> subControl to child ::> lcTherapyStateStore;
+
+    part lcWatchdogChannel : LogicalComponent {
+        attribute :>> id = "NDS-LC-006"; attribute :>> name = "WatchdogChannel";
+        attribute :>> componentRole = ComponentRoleKind::channel;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Reset to the safe state when the control loop misses its deadline.";
+        attribute :>> channelRole = ChannelRoleKind::monitor;
+        attribute :>> diversityBasis = "independent time base from the control partition";
+    }
+    part lcPressureIntegrityChannel : LogicalComponent {
+        attribute :>> id = "NDS-LC-007"; attribute :>> name = "PressureIntegrityChannel";
+        attribute :>> componentRole = ComponentRoleKind::channel;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Cross-check pressure against the commanded rate and stop on divergence.";
+        attribute :>> channelRole = ChannelRoleKind::monitor;
+        attribute :>> diversityBasis = "different measurement principle from the primary occlusion channel";
+    }
+    connection : Composes connect parent ::> subSafetyMonitor to child ::> lcWatchdogChannel;
+    connection : Composes connect parent ::> subSafetyMonitor to child ::> lcPressureIntegrityChannel;
+
+    part lcDisplayManager : LogicalComponent {
+        attribute :>> id = "NDS-LC-008"; attribute :>> name = "DisplayManager";
+        attribute :>> componentRole = ComponentRoleKind::userInterface;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Render therapy state on the main screen.";
+        attribute :>> interactionSummary = "read-only status surface, refreshed once per second";
+    }
+    part lcAlarmAnnunciator : LogicalComponent {
+        attribute :>> id = "NDS-LC-009"; attribute :>> name = "AlarmAnnunciator";
+        attribute :>> componentRole = ComponentRoleKind::userInterface;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Raise audible and visible alarms by priority.";
+        attribute :>> interactionSummary = "IEC 60601-1-8 alarm signals";
+    }
+    part lcKeypadHandler : LogicalComponent {
+        attribute :>> id = "NDS-LC-010"; attribute :>> name = "KeypadHandler";
+        attribute :>> componentRole = ComponentRoleKind::userInterface;
+        attribute :>> systemType = SystemTypeKind::software;
+        attribute :>> responsibility = "Debounce and interpret key presses.";
+        attribute :>> interactionSummary = "physical keypad, confirm-before-apply for every rate change";
+    }
+    connection : Composes connect parent ::> subUserInterface to child ::> lcDisplayManager;
+    connection : Composes connect parent ::> subUserInterface to child ::> lcAlarmAnnunciator;
+    connection : Composes connect parent ::> subUserInterface to child ::> lcKeypadHandler;
+
+    part lcBatteryManager : LogicalComponent {
+        attribute :>> id = "NDS-LC-011"; attribute :>> name = "BatteryManager";
+        attribute :>> componentRole = ComponentRoleKind::generic;
+        attribute :>> systemType = SystemTypeKind::hardware;
+        attribute :>> responsibility = "Charge, gauge and protect the battery.";
+    }
+    part lcPowerRailMonitor : LogicalComponent {
+        attribute :>> id = "NDS-LC-012"; attribute :>> name = "PowerRailMonitor";
+        attribute :>> componentRole = ComponentRoleKind::channel;
+        attribute :>> systemType = SystemTypeKind::hardware;
+        attribute :>> responsibility = "Detect rail brownout and request a source switch.";
+        attribute :>> channelRole = ChannelRoleKind::monitor;
+    }
+    connection : Composes connect parent ::> subPower to child ::> lcBatteryManager;
+    connection : Composes connect parent ::> subPower to child ::> lcPowerRailMonitor;
+
+    // ── Component-to-component dependency ────────────────────────
+    // What the DSM plots when both axes are architecture: who needs whom.
+    connection : ExchangesWith connect source ::> lcOcclusionChannel to target ::> lcDoseController;
+    connection : ExchangesWith connect source ::> lcDoseController to target ::> lcPumpMechanism;
+    connection : ExchangesWith connect source ::> lcPumpMechanism to target ::> lcTherapyStateStore;
+    connection : ExchangesWith connect source ::> lcTherapyStateStore to target ::> lcDisplayManager;
+    connection : ExchangesWith connect source ::> lcWatchdogChannel to target ::> lcDoseController;
+    connection : ExchangesWith connect source ::> lcPressureIntegrityChannel to target ::> lcAlarmAnnunciator;
+    connection : ExchangesWith connect source ::> lcKeypadHandler to target ::> lcDoseController;
+    connection : ExchangesWith connect source ::> lcReservoirInterface to target ::> lcPumpMechanism;
+    connection : ExchangesWith connect source ::> lcBatteryManager to target ::> lcPowerRailMonitor;
+    connection : ExchangesWith connect source ::> lcPowerRailMonitor to target ::> lcAlarmAnnunciator;
+}

package/examples/nested-architecture-dsm/model/catalog/assurance/requirements/needs.sysml

@@ -0,0 +1,53 @@
+// Stakeholder needs — the outermost row of a full trace chain.
+//
+// Need → Requirement → Function → VerificationCase is the chain the
+// traceability view is meant to walk one hop at a time.
+package memo_examples_nested_architecture_dsm_assurance_requirements_needs {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_assurance_requirements_needs::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements::*;
+
+    requirement needAccurateTherapy : Need {
+        attribute :>> id = "NDS-NEED-001"; attribute :>> name = "AccurateTherapyDelivery";
+        attribute :>> needKind = NeedKind::'stakeholder';
+        attribute :>> statement = "Clinicians need the delivered dose to match the prescription closely enough to be clinically safe.";
+        attribute :>> priority = "high";
+    }
+    requirement needProtectionFromHarm : Need {
+        attribute :>> id = "NDS-NEED-002"; attribute :>> name = "ProtectionFromDeliveryFaults";
+        attribute :>> needKind = NeedKind::'stakeholder';
+        attribute :>> statement = "Patients need delivery to stop before a line fault or air bolus reaches them.";
+        attribute :>> priority = "high";
+    }
+    requirement needUninterruptedTherapy : Need {
+        attribute :>> id = "NDS-NEED-003"; attribute :>> name = "UninterruptedTherapy";
+        attribute :>> needKind = NeedKind::operational;
+        attribute :>> statement = "Wards need therapy to continue through transport and mains interruptions.";
+        attribute :>> priority = "medium";
+        attribute :>> operationalContextReference = "intra-hospital transport, up to four hours off mains";
+    }
+    requirement needLegibleStatus : Need {
+        attribute :>> id = "NDS-NEED-004"; attribute :>> name = "LegibleTherapyStatus";
+        attribute :>> needKind = NeedKind::'stakeholder';
+        attribute :>> statement = "Clinicians need to read therapy state and alarms correctly from the bedside.";
+        attribute :>> priority = "high";
+        attribute :>> userPopulationReference = "ward nurses, including those wearing corrective lenses";
+    }
+
+    // Need → Requirement.
+    connection derAccuracy : DerivesFrom connect sourceDriver ::> needAccurateTherapy to targetRequirement ::> reqDoseAccuracy;
+    connection derOcclusion : DerivesFrom connect sourceDriver ::> needProtectionFromHarm to targetRequirement ::> reqOcclusionDetection;
+    connection derAirInLine : DerivesFrom connect sourceDriver ::> needProtectionFromHarm to targetRequirement ::> reqAirInLine;
+    connection derAlarm : DerivesFrom connect sourceDriver ::> needLegibleStatus to targetRequirement ::> reqAlarmAnnunciation;
+    connection derBattery : DerivesFrom connect sourceDriver ::> needUninterruptedTherapy to targetRequirement ::> reqBatteryEndurance;
+    connection derConfirmation : DerivesFrom connect sourceDriver ::> needLegibleStatus to targetRequirement ::> reqPrescriptionConfirmation;
+    connection derStatus : DerivesFrom connect sourceDriver ::> needLegibleStatus to targetRequirement ::> reqStatusVisibility;
+
+    // Software requirements derive from the system requirement they refine
+    // (IEC 62304), which is a second, requirement-to-requirement trace axis.
+    connection derAlarmFromSystem : DerivesFrom connect sourceDriver ::> reqOcclusionDetection to targetRequirement ::> reqAlarmAnnunciation;
+    connection derConfirmationFromSystem : DerivesFrom connect sourceDriver ::> reqDoseAccuracy to targetRequirement ::> reqPrescriptionConfirmation;
+}

package/examples/nested-architecture-dsm/model/catalog/assurance/requirements/requirements.sysml

@@ -0,0 +1,89 @@
+// Requirements — the row axis of the traceability matrix.
+//
+// StatusVisibility is deliberately left untraced, so the coverage figure is
+// under 100% and there is an empty row to author a trace into from the
+// traceability view.
+package memo_examples_nested_architecture_dsm_assurance_requirements {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_assurance_requirements::*;
+
+    requirement reqDoseAccuracy : Requirement {
+        attribute :>> id = "NDS-REQ-001"; attribute :>> name = "DoseAccuracy";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "The pump shall deliver the prescribed volume within ±5% over any 60-minute window.";
+        attribute :>> notation = RequirementNotationKind::sophist;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> systemResponse = "deliver the prescribed volume within ±5% over any 60-minute window";
+        attribute :>> concernKind = ConcernKind::clinical;
+    }
+    requirement reqOcclusionDetection : Requirement {
+        attribute :>> id = "NDS-REQ-002"; attribute :>> name = "OcclusionDetection";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "When line pressure exceeds the occlusion threshold, the pump shall stop delivery within 2 seconds.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::eventDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "When line pressure exceeds the occlusion threshold";
+        attribute :>> systemResponse = "stop delivery within 2 seconds";
+        attribute :>> concernKind = ConcernKind::safety;
+    }
+    requirement reqAirInLine : Requirement {
+        attribute :>> id = "NDS-REQ-003"; attribute :>> name = "AirInLineProtection";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "When an air bolus above 0.1 mL is detected, the pump shall stop delivery and raise a high-priority alarm.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::eventDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "When an air bolus above 0.1 mL is detected";
+        attribute :>> systemResponse = "stop delivery and raise a high-priority alarm";
+        attribute :>> concernKind = ConcernKind::safety;
+    }
+    requirement reqAlarmAnnunciation : Requirement {
+        attribute :>> id = "NDS-REQ-004"; attribute :>> name = "AlarmAnnunciation";
+        attribute :>> requirementKind = RequirementKind::software;
+        attribute :>> statement = "While any alarm condition is active, the pump shall present its IEC 60601-1-8 signal until the condition clears or is acknowledged.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::stateDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "While any alarm condition is active";
+        attribute :>> systemResponse = "present its IEC 60601-1-8 signal until the condition clears or is acknowledged";
+        attribute :>> concernKind = ConcernKind::safety;
+        attribute :>> safetyClass = SafetyClassKind::C;
+    }
+    requirement reqBatteryEndurance : Requirement {
+        attribute :>> id = "NDS-REQ-005"; attribute :>> name = "BatteryEndurance";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "On loss of mains power, the pump shall continue delivery for at least 4 hours at 25 mL/h.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::eventDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "On loss of mains power";
+        attribute :>> systemResponse = "continue delivery for at least 4 hours at 25 mL/h";
+        attribute :>> concernKind = ConcernKind::reliability;
+    }
+    requirement reqPrescriptionConfirmation : Requirement {
+        attribute :>> id = "NDS-REQ-006"; attribute :>> name = "PrescriptionConfirmation";
+        attribute :>> requirementKind = RequirementKind::software;
+        attribute :>> statement = "When the clinician changes the infusion rate, the pump shall require explicit confirmation before applying it.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::eventDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "When the clinician changes the infusion rate";
+        attribute :>> systemResponse = "require explicit confirmation before applying it";
+        attribute :>> concernKind = ConcernKind::usability;
+        attribute :>> safetyClass = SafetyClassKind::C;
+    }
+    // Untraced on purpose — the gap the traceability view is meant to find.
+    requirement reqStatusVisibility : Requirement {
+        attribute :>> id = "NDS-REQ-007"; attribute :>> name = "StatusVisibility";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "The pump shall display the active rate and volume delivered legibly at 1 m.";
+        attribute :>> notation = RequirementNotationKind::sophist;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> systemResponse = "display the active rate and volume delivered legibly at 1 m";
+        attribute :>> concernKind = ConcernKind::usability;
+    }
+}

package/examples/nested-architecture-dsm/model/catalog/assurance/verification_validation/verification_validation.sysml

@@ -0,0 +1,90 @@
+// Verification cases — the far end of the trace chain, and a third axis for
+// the traceability matrix (function → verification case).
+package memo_examples_nested_architecture_dsm_assurance_verification_validation {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_assurance_verification_validation::*;
+    private import memo_examples_nested_architecture_dsm_architecture_functional_functions::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements::*;
+
+    verification vcDoseAccuracy : VerificationCase {
+        attribute :>> id = "NDS-VER-001"; attribute :>> name = "VerifyDoseAccuracy";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Gravimetric delivery over 60 minutes is within ±5% of the prescribed volume at 1, 25 and 999 mL/h.";
+        attribute :>> status = "planned";
+    }
+    verification vcOcclusionResponse : VerificationCase {
+        attribute :>> id = "NDS-VER-002"; attribute :>> name = "VerifyOcclusionResponse";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Delivery stops within 2 s of the occlusion threshold being crossed, at every supported rate.";
+        attribute :>> status = "planned";
+    }
+    verification vcAirInLineResponse : VerificationCase {
+        attribute :>> id = "NDS-VER-003"; attribute :>> name = "VerifyAirInLineResponse";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "A 0.1 mL air bolus stops delivery and raises a high-priority alarm.";
+        attribute :>> status = "planned";
+    }
+    verification vcAlarmSignals : VerificationCase {
+        attribute :>> id = "NDS-VER-004"; attribute :>> name = "VerifyAlarmSignals";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Alarm signals conform to IEC 60601-1-8 for every priority, and persist until cleared or acknowledged.";
+        attribute :>> status = "planned";
+    }
+    verification vcBatteryEndurance : VerificationCase {
+        attribute :>> id = "NDS-VER-005"; attribute :>> name = "VerifyBatteryEndurance";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Delivery continues for at least 4 hours at 25 mL/h from a fully charged battery after mains loss.";
+        attribute :>> status = "planned";
+    }
+    verification vcConfirmationFlow : VerificationCase {
+        attribute :>> id = "NDS-VER-006"; attribute :>> name = "VerifyConfirmationFlow";
+        attribute :>> methodKind = VerificationMethodKind::demonstration;
+        attribute :>> acceptanceCriteria = "No rate change reaches the controller without an explicit confirmation step.";
+        attribute :>> status = "planned";
+    }
+    verification vcStatusLegibility : VerificationCase {
+        attribute :>> id = "NDS-VER-007"; attribute :>> name = "VerifyStatusLegibility";
+        attribute :>> methodKind = VerificationMethodKind::inspection;
+        attribute :>> acceptanceCriteria = "Rate and volume delivered are readable at 1 m under 100–1000 lux.";
+        attribute :>> status = "planned";
+    }
+    verification vcPowerSourceSwitch : VerificationCase {
+        attribute :>> id = "NDS-VER-008"; attribute :>> name = "VerifyPowerSourceSwitch";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Rail brownout switches source without interrupting delivery.";
+        attribute :>> status = "planned";
+    }
+
+    // Requirement → verification case.
+    connection verDoseAccuracy : VerifiedBy connect verificationTarget ::> reqDoseAccuracy to verificationCase ::> vcDoseAccuracy;
+    connection verOcclusion : VerifiedBy connect verificationTarget ::> reqOcclusionDetection to verificationCase ::> vcOcclusionResponse;
+    connection verAirInLine : VerifiedBy connect verificationTarget ::> reqAirInLine to verificationCase ::> vcAirInLineResponse;
+    connection verAlarm : VerifiedBy connect verificationTarget ::> reqAlarmAnnunciation to verificationCase ::> vcAlarmSignals;
+    connection verBattery : VerifiedBy connect verificationTarget ::> reqBatteryEndurance to verificationCase ::> vcBatteryEndurance;
+    connection verConfirmation : VerifiedBy connect verificationTarget ::> reqPrescriptionConfirmation to verificationCase ::> vcConfirmationFlow;
+    connection verStatus : VerifiedBy connect verificationTarget ::> reqStatusVisibility to verificationCase ::> vcStatusLegibility;
+
+    // Function → verification case, so safety-critical functions carry their
+    // own verification rather than inheriting it through a requirement.
+    connection verFnDeliverTherapy : VerifiedBy connect verificationTarget ::> fnDeliverTherapy to verificationCase ::> vcDoseAccuracy;
+    connection verFnMeterFluid : VerifiedBy connect verificationTarget ::> fnMeterFluid to verificationCase ::> vcDoseAccuracy;
+    connection verFnDriveActuator : VerifiedBy connect verificationTarget ::> fnDriveActuator to verificationCase ::> vcDoseAccuracy;
+    connection verFnMeasureDelivered : VerifiedBy connect verificationTarget ::> fnMeasureDelivered to verificationCase ::> vcDoseAccuracy;
+    connection verFnControlDose : VerifiedBy connect verificationTarget ::> fnControlDose to verificationCase ::> vcDoseAccuracy;
+    connection verFnComputeRate : VerifiedBy connect verificationTarget ::> fnComputeRate to verificationCase ::> vcDoseAccuracy;
+    connection verFnValidatePrescription : VerifiedBy connect verificationTarget ::> fnValidatePrescription to verificationCase ::> vcConfirmationFlow;
+    connection verFnEnsureSafety : VerifiedBy connect verificationTarget ::> fnEnsureSafety to verificationCase ::> vcOcclusionResponse;
+    connection verFnDetectOcclusion : VerifiedBy connect verificationTarget ::> fnDetectOcclusion to verificationCase ::> vcOcclusionResponse;
+    connection verFnDetectAirInLine : VerifiedBy connect verificationTarget ::> fnDetectAirInLine to verificationCase ::> vcAirInLineResponse;
+    connection verFnEnforceDoseLimits : VerifiedBy connect verificationTarget ::> fnEnforceDoseLimits to verificationCase ::> vcOcclusionResponse;
+    connection verFnInformUser : VerifiedBy connect verificationTarget ::> fnInformUser to verificationCase ::> vcStatusLegibility;
+    connection verFnRenderStatus : VerifiedBy connect verificationTarget ::> fnRenderStatus to verificationCase ::> vcStatusLegibility;
+    connection verFnAnnunciateAlarm : VerifiedBy connect verificationTarget ::> fnAnnunciateAlarm to verificationCase ::> vcAlarmSignals;
+    connection verFnAcceptInput : VerifiedBy connect verificationTarget ::> fnAcceptInput to verificationCase ::> vcConfirmationFlow;
+    connection verFnManagePower : VerifiedBy connect verificationTarget ::> fnManagePower to verificationCase ::> vcBatteryEndurance;
+    connection verFnMonitorBattery : VerifiedBy connect verificationTarget ::> fnMonitorBattery to verificationCase ::> vcBatteryEndurance;
+    connection verFnSelectPowerSource : VerifiedBy connect verificationTarget ::> fnSelectPowerSource to verificationCase ::> vcPowerSourceSwitch;
+}

package/examples/nested-architecture-dsm/model/catalog/project.sysml

@@ -0,0 +1,28 @@
+// Nested architecture DSM — project identity and method binding.
+//
+// The native entrypoint. The imports name what this project contains and the
+// binding names the methodology governing it. No YAML file participates.
+package memo_examples_nested_architecture_dsm_project {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_methodology_core::*;
+    private import memo_methodology_profiles::*;
+
+    // The project's own content, imported so the catalog is one reachable
+    // closure from a single entrypoint.
+    private import memo_examples_nested_architecture_dsm_architecture_logical_structure::*;
+    private import memo_examples_nested_architecture_dsm_architecture_functional_functions::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements_needs::*;
+    private import memo_examples_nested_architecture_dsm_assurance_verification_validation::*;
+    private import memo_examples_nested_architecture_dsm_traces::*;
+
+    part projectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-NESTED-DSM-001";
+        attribute :>> name = "NestedArchitectureDsmProjectMethodBinding";
+        attribute :>> projectName = "Nested Architecture DSM";
+        ref :>> selectedMethodology = mdDefaultDefinition;
+        attribute :>> scopeMode = ScopeModeKind::explicit;
+    }
+}

package/examples/nested-architecture-dsm/model/catalog/traces.sysml

@@ -0,0 +1,49 @@
+// Cross-axis links: allocation and satisfaction.
+//
+// These are what make the two matrices show different things over the same
+// model. The DSM reads allocation as a dependency between a function and the
+// block that carries it; the traceability view reads satisfaction as coverage
+// of a requirement. Keeping both in one file makes the cross-axis story easy
+// to read, and easy to extend from the traceability view's editor.
+package memo_examples_nested_architecture_dsm_traces {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_examples_nested_architecture_dsm_architecture_functional_functions::*;
+    private import memo_examples_nested_architecture_dsm_architecture_logical_structure::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements::*;
+
+    // ── Function → block allocation ──────────────────────────────
+    connection allocDrive : AllocatedTo connect function ::> fnDriveActuator to allocatedElement ::> lcPumpMechanism;
+    connection allocMeasure : AllocatedTo connect function ::> fnMeasureDelivered to allocatedElement ::> lcPumpMechanism;
+    connection allocComputeRate : AllocatedTo connect function ::> fnComputeRate to allocatedElement ::> lcDoseController;
+    connection allocValidate : AllocatedTo connect function ::> fnValidatePrescription to allocatedElement ::> lcDoseController;
+    connection allocOcclusion : AllocatedTo connect function ::> fnDetectOcclusion to allocatedElement ::> lcOcclusionChannel;
+    connection allocAirInLine : AllocatedTo connect function ::> fnDetectAirInLine to allocatedElement ::> lcOcclusionChannel;
+    // Two channels carry the same protective function — the redundancy shows
+    // up in the matrix as two marks on one row.
+    connection allocLimitsWatchdog : AllocatedTo connect function ::> fnEnforceDoseLimits to allocatedElement ::> lcWatchdogChannel;
+    connection allocLimitsPressure : AllocatedTo connect function ::> fnEnforceDoseLimits to allocatedElement ::> lcPressureIntegrityChannel;
+    connection allocRender : AllocatedTo connect function ::> fnRenderStatus to allocatedElement ::> lcDisplayManager;
+    connection allocAlarm : AllocatedTo connect function ::> fnAnnunciateAlarm to allocatedElement ::> lcAlarmAnnunciator;
+    connection allocInput : AllocatedTo connect function ::> fnAcceptInput to allocatedElement ::> lcKeypadHandler;
+    connection allocBattery : AllocatedTo connect function ::> fnMonitorBattery to allocatedElement ::> lcBatteryManager;
+    connection allocPowerSource : AllocatedTo connect function ::> fnSelectPowerSource to allocatedElement ::> lcPowerRailMonitor;
+    // A capability allocated at subsystem level rather than to one component:
+    // collapsed, it lands in the same cell as its children's allocations.
+    connection allocMeterFluid : AllocatedTo connect function ::> fnMeterFluid to allocatedElement ::> subFluidPath;
+
+    // ── Requirement → function satisfaction ──────────────────────
+    connection satDoseAccuracyRate : SatisfiedBy connect requiredElement ::> reqDoseAccuracy to satisfyingElement ::> fnComputeRate;
+    connection satDoseAccuracyDrive : SatisfiedBy connect requiredElement ::> reqDoseAccuracy to satisfyingElement ::> fnDriveActuator;
+    connection satOcclusion : SatisfiedBy connect requiredElement ::> reqOcclusionDetection to satisfyingElement ::> fnDetectOcclusion;
+    connection satOcclusionLimits : SatisfiedBy connect requiredElement ::> reqOcclusionDetection to satisfyingElement ::> fnEnforceDoseLimits;
+    connection satAirInLine : SatisfiedBy connect requiredElement ::> reqAirInLine to satisfyingElement ::> fnDetectAirInLine;
+    connection satAirInLineAlarm : SatisfiedBy connect requiredElement ::> reqAirInLine to satisfyingElement ::> fnAnnunciateAlarm;
+    connection satAlarm : SatisfiedBy connect requiredElement ::> reqAlarmAnnunciation to satisfyingElement ::> fnAnnunciateAlarm;
+    connection satBatteryMonitor : SatisfiedBy connect requiredElement ::> reqBatteryEndurance to satisfyingElement ::> fnMonitorBattery;
+    connection satBatterySource : SatisfiedBy connect requiredElement ::> reqBatteryEndurance to satisfyingElement ::> fnSelectPowerSource;
+    connection satConfirmation : SatisfiedBy connect requiredElement ::> reqPrescriptionConfirmation to satisfyingElement ::> fnAcceptInput;
+    connection satConfirmationValidate : SatisfiedBy connect requiredElement ::> reqPrescriptionConfirmation to satisfyingElement ::> fnValidatePrescription;
+}

package/examples/reusable-instrument/model/catalog/project.sysml

@@ -0,0 +1,24 @@
+// Reusable Instrument — project identity and method binding.
+//
+// The native entrypoint. The imports name what this project contains and the
+// binding names the methodology it is governed by. No YAML file participates.
+package memo_examples_reusable_instrument_project {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_methodology_core::*;
+    private import memo_methodology_profiles::*;
+
+    // The project's own content, imported so the catalog is one reachable
+    // closure from a single entrypoint.
+    private import memo_examples_reusable_instrument_viewpoints_unassigned::*;
+    private import memo_examples_reusable_instrument_viewpoints_unassigned_views_reusable_instrument_overview::*;
+
+    part projectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-REUSABLE-INSTRUMENT-001";
+        attribute :>> name = "ReusableInstrumentProjectMethodBinding";
+        attribute :>> projectName = "Reusable Instrument";
+        ref :>> selectedMethodology = mdDefaultDefinition;
+        attribute :>> scopeMode = ScopeModeKind::explicit;
+    }
+}

package/examples/reusable-instrument/model/catalog/reusable_instrument.sysml

@@ -5,6 +5,7 @@ package memo_examples_reusable_instrument {
     private import ScalarValues::*;
 
     private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
     private import memo_architecture_operational_context_actors::*;
     private import memo_architecture_operational_use_cases::*;
     private import memo_architecture_operational_activities::*;
@@ -45,15 +46,15 @@ package memo_examples_reusable_instrument {
         attribute :>> id = "RI-ACT-003"; attribute :>> name = "PackAndAutoclave";
         attribute :>> criticality = CriticalityKind::high;
     }
-    action wsClean : WorkflowStep { attribute :>> stepOrder = 1; ref :>> performedActivity = actClean; }
-    action wsInspect : WorkflowStep { attribute :>> stepOrder = 2; ref :>> performedActivity = actInspect; }
-    action wsSterilize : WorkflowStep { attribute :>> stepOrder = 3; ref :>> performedActivity = actSterilizeLoad; }
+    action wsClean : WorkflowStep { ref :>> performedActivity = actClean; }
+    action wsInspect : WorkflowStep { ref :>> performedActivity = actInspect; }
+    action wsSterilize : WorkflowStep { ref :>> performedActivity = actSterilizeLoad; }
     connection : Composes connect parent ::> wfReprocess to child ::> wsClean;
-    connection : StepPrecedes connect predecessor ::> wsClean to successor ::> wsInspect;
-    connection : StepPrecedes connect predecessor ::> wsInspect to successor ::> wsSterilize;
+    first wsClean then wsInspect;
+    first wsInspect then wsSterilize;
     connection : Supports { attribute :>> supportKind = SupportKind::useCase; connect supporter ::> wfReprocess to supported ::> ucSterilize; }
 
-    part scNominalCycle : OperativeScenario {
+    action scNominalCycle : OperativeScenario {
         attribute :>> id = "RI-SC-001"; attribute :>> name = "NominalReprocessingCycle";
         attribute :>> variantKind = ScenarioVariantKind::nominal;
         attribute :>> operationalCondition = OperationalConditionKind::normal;

package/examples/reusable-instrument/model/catalog/viewpoints/unassigned/viewpoint.sysml

@@ -0,0 +1,9 @@
+// unassigned viewpoint.
+//
+// This project does not define its own viewpoint here; it binds the reusable
+// MEMO viewpoint that frames these concerns. The views it governs sit beneath
+// `views/`.
+package memo_examples_reusable_instrument_viewpoints_unassigned {
+    // The reusable package declaring unassigned could not be resolved during
+    // conversion. Import it here so the views beneath this viewpoint resolve.
+}

package/examples/reusable-instrument/model/{viewpoints → catalog/viewpoints/unassigned/views}/reusable_instrument_overview.sysml

@@ -1,4 +1,4 @@
-package memo_examples_reusable_instrument_viewpoints {
+package memo_examples_reusable_instrument_viewpoints_unassigned_views_reusable_instrument_overview {
     private import memo_examples_reusable_instrument::*;
     private import memo_viewpoints_definitions::*;
     private import memo_core_enumerations::*;

package/examples/software-only-medical-device/model/catalog/project.sysml

@@ -0,0 +1,24 @@
+// Software Only Medical Device — project identity and method binding.
+//
+// The native entrypoint. The imports name what this project contains and the
+// binding names the methodology it is governed by. No YAML file participates.
+package memo_examples_software_only_medical_device_project {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_methodology_core::*;
+    private import memo_methodology_profiles::*;
+
+    // The project's own content, imported so the catalog is one reachable
+    // closure from a single entrypoint.
+    private import memo_examples_software_only_medical_device_viewpoints_unassigned::*;
+    private import memo_examples_software_only_medical_device_viewpoints_unassigned_views_software_only_medical_device_overview::*;
+
+    part projectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-MEDICAL-DEVICE-001";
+        attribute :>> name = "SoftwareOnlyMedicalDeviceProjectMethodBinding";
+        attribute :>> projectName = "Software Only Medical Device";
+        ref :>> selectedMethodology = mdDefaultDefinition;
+        attribute :>> scopeMode = ScopeModeKind::explicit;
+    }
+}

package/examples/software-only-medical-device/model/catalog/viewpoints/unassigned/viewpoint.sysml

@@ -0,0 +1,9 @@
+// unassigned viewpoint.
+//
+// This project does not define its own viewpoint here; it binds the reusable
+// MEMO viewpoint that frames these concerns. The views it governs sit beneath
+// `views/`.
+package memo_examples_software_only_medical_device_viewpoints_unassigned {
+    // The reusable package declaring unassigned could not be resolved during
+    // conversion. Import it here so the views beneath this viewpoint resolve.
+}

package/examples/software-only-medical-device/model/{viewpoints → catalog/viewpoints/unassigned/views}/software_only_medical_device_overview.sysml

@@ -1,4 +1,4 @@
-package memo_examples_software_only_medical_device_viewpoints {
+package memo_examples_software_only_medical_device_viewpoints_unassigned_views_software_only_medical_device_overview {
     private import memo_examples_software_only_medical_device::*;
     private import memo_viewpoints_definitions::*;
     private import memo_core_enumerations::*;