@memoarchitect/ontology 0.7.0 → 0.8.22

package/src/architecture/operational/context/stakeholders/memo_stakeholders.sysml

@@ -1,27 +1,17 @@
-// ISO/IEC/IEEE 42010 architecture-description core (§4). A Stakeholder has
-// interests (Concerns) in the system; a Viewpoint frames concerns; a View
+// ISO/IEC/IEEE 42010 architecture-description core (§4). A stakeholder has
+// interests in the system; a Viewpoint frames concerns; a View
 // (memo_viewpoints_definitions::MemoView) is governed by a viewpoint within an
 // ArchitectureDescription. The same real-world entity may play both the
-// Stakeholder and the Actor role — expressed by ActsAsActor, never by merging
-// the types.
+// Stakeholder and operational-participant concerns stay distinct from the
+// architecture-description types below.
 package memo_architecture_operational_context_stakeholders {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
     private import memo_core_relationships::*;
     private import memo_architecture_operational_context_actors::*;
-
-    part def Stakeholder specializes MemoPart {
-        attribute stakeholderCategory : String;
-        attribute influence : String;
-    }
-
-    part def Concern specializes MemoPart {
-        attribute concernKind : ConcernKind;
-        attribute question : String;
-    }
-
     part def ArchitectureDescription specializes DocumentedElement {
         attribute systemOfInterest : String;
         attribute version : String;
@@ -38,19 +28,6 @@ package memo_architecture_operational_context_stakeholders {
         attribute ruleExpression : String;
     }
 
-    connection def HasConcern :> MemoRelationship {
-        end interestedStakeholder : Stakeholder;
-        end stakeholderConcern : Concern;
-    }
-    connection def FramesConcern :> MemoRelationship {
-        end framingViewpoint : MemoPart;
-        end framedConcern : Concern;
-    }
-    // Links the stakeholder to the actor role the same entity plays, if any.
-    connection def ActsAsActor :> MemoRelationship {
-        end interestedStakeholder : Stakeholder;
-        end actorRole : Actor;
-    }
     // Governs unifies GovernsCorrespondence / GovernsUse, keyed by governKind.
     enum def GovernKind {
         enum correspondence;
@@ -58,7 +35,13 @@ package memo_architecture_operational_context_stakeholders {
     }
     connection def Governs :> MemoRelationship {
         attribute governKind : GovernKind;
-        end governor : MemoPart;
-        end governedElement : MemoPart;
+        end governor : MemoPart :>> source;
+        end governedElement : MemoPart :>> target;
+    }
+    abstract connection governsLinks : Governs[*];
+    metadata def <governs> GovernsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = governsLinks meta SysML::Usage;
     }
 }

package/src/architecture/operational/context/use_context/memo_use_context.sysml

@@ -1,7 +1,16 @@
 // Operational use context (IEC 62366-1 use specification). Intended use and
 // reasonably foreseeable misuse are assurance requirements/risk inputs and
 // live in memo_assurance_requirements.
+//
+// This package once defined `ExchangesWith` for directional context-level data
+// flow between boundary entities. It is deleted: SysML v2's own `flow` covers
+// every case and is strictly stronger, because `of <ItemDef>` says WHAT moves
+// and two untyped connection ends cannot. Delegation between a boundary port
+// and the interior it stands for is `bind` — identity, not transport. SysML v2
+// keeps the two apart the same way: training ch. 13 wires components with
+// `flow`, ch. 12 delegates across a boundary with `bind`.
 package memo_architecture_operational_context_use_context {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -47,32 +56,49 @@ package memo_architecture_operational_context_use_context {
         attribute contextSide : ContextSideKind;
         // The verb, as it should read on the edge ("Directs procedure").
         attribute interactionLabel : String[0..1];
-        end contextParticipant : MemoPart;
+        end contextParticipant : ArchitectureElement :>> source;
         // Untyped: the system of interest may be a part or an operational activity.
-        end systemOfInterest;
+        end systemOfInterest : ArchitectureElement :>> target;
+    }
+    abstract connection interactsInContextLinks : InteractsInContext[*];
+    metadata def <interactsInContext> InteractsInContextMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = interactsInContextLinks meta SysML::Usage;
     }
 
     connection def InteractsWith :> MemoRelationship {
-        end contextParticipant : Actor;
+        end contextParticipant : OperationalParticipant :>> source;
         // Untyped so operational activities (action def) can be targets as well as parts.
         end target;
     }
-    // Directional context-level data flow between boundary entities.
-    connection def ExchangesWith :> MemoRelationship {
-        end source : MemoPart;
-        end target : MemoPart;
-    }
-    // Physical connection between boundary entities (fluid path, mounting).
-    connection def ConnectsPhysically :> MemoRelationship {
-        end source : MemoPart;
-        end target : MemoPart;
+    abstract connection interactsWithLinks : InteractsWith[*];
+    metadata def <interactsWith> InteractsWithMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = interactsWithLinks meta SysML::Usage;
     }
+    // `ConnectsPhysically` is native `connect` (R10-S6): write
+    // `connection connect source ::> <a> to target ::> <b>;` — the ordinary
+    // untyped binary connection — instead of a connection def for it.
     connection def AppliesInContext :> MemoRelationship {
-        end useContext : UseContext;
-        end subjectElement : MemoPart;
+        end useContext : UseContext :>> source;
+        end subjectElement : MemoPart :>> target;
+    }
+    abstract connection appliesInContextLinks : AppliesInContext[*];
+    metadata def <appliesInContext> AppliesInContextMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = appliesInContextLinks meta SysML::Usage;
     }
     connection def SituatedIn :> MemoRelationship {
-        end useContext : UseContext;
-        end environment : UseEnvironment;
+        end useContext : UseContext :>> source;
+        end environment : UseEnvironment :>> target;
+    }
+    abstract connection situatedInLinks : SituatedIn[*];
+    metadata def <situatedIn> SituatedInMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = situatedInLinks meta SysML::Usage;
     }
 }

package/src/architecture/operational/scenarios/memo_scenarios.sysml

@@ -1,10 +1,10 @@
 // Scenario foundation. A scenario is a selected path through a
-// workflow (or functional flow), classified by three independent typed
-// dimensions — variant, operational condition, purpose — replacing the former
-// single ScenarioKind. An occurrence is an actual or hypothetical execution
+// workflow (or functional flow), classified by its kind plus three independent
+// dimensions — variant, operational condition, and purpose. An occurrence is an actual or hypothetical execution
 // of a scenario. Alternate scenarios reference their base scenario and
 // variation point instead of duplicating the workflow.
 package memo_architecture_operational_scenarios {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -47,11 +47,25 @@ package memo_architecture_operational_scenarios {
         enum cybersecurity;
     }
 
-    // Shared scenario foundation. Specializations exist only where structure
-    // or invariants differ (OperativeScenario here; FunctionalScenario in
-    // memo_functions; UIScenario in memo_architecture_implementation_ui;
-    // VerificationScenario / ThreatScenario in assurance packages).
-    abstract action def MemoScenario specializes MemoAction {
+    // The architecture/assurance role a scenario plays. These values preserve
+    // the former named scenario specializations without turning a taxonomy into
+    // six action definitions.
+    enum def ScenarioKind {
+        enum functional;
+        enum operative;
+        enum ui;
+        enum threat;
+        // `verification` is a SysML v2 reserved word; retain the regulated
+        // term with the same `memo` prefix used by ScenarioPurposeKind.
+        enum memoVerification;
+        enum hazardRelatedUse;
+    }
+
+    // Shared scenario foundation. Fields that apply only to one scenario kind
+    // remain optional here; this keeps the taxonomy queryable without six
+    // otherwise redundant action definitions.
+    action def MemoScenario specializes MemoAction {
+        attribute scenarioKind : ScenarioKind;
         attribute variantKind : ScenarioVariantKind;
         attribute operationalCondition : OperationalConditionKind;
         attribute scenarioPurpose : ScenarioPurposeKind[0..*];
@@ -62,26 +76,34 @@ package memo_architecture_operational_scenarios {
         attribute postCondition : String;
         attribute pathSummary : String;
 
-        ref involvedActors : Actor[0..*];
+        ref involvedActors : OperationalParticipant[0..*];
         ref useContext : UseContext[0..1];
         // Alternate/exception/recovery scenarios reference their base and the
         // point at which behavior diverges — never a copied workflow.
         ref baseScenario : MemoScenario[0..1];
         attribute variationPoint : String;
-    }
 
-    // The operational-layer scenario: a path through an OperationalWorkflow in
-    // a use context. It is realized down the V by a FunctionalScenario (the
-    // function sequence) and a UIScenario (the interaction sequence), each owned
-    // by its own architecture layer and linked by typed realization
-    // relationships — never by copying the path. Workflow stays operational;
-    // only the scenario is layered.
-    action def OperativeScenario specializes MemoScenario {
+        // functional scenario
+        ref selectedFlow : MemoAction[0..1];
+        // operative scenario
         ref parentWorkflow : OperationalWorkflow[0..1];
         ref parentUseCase : UseCase[0..1];
-        // Each scenario owns the operational activity/action flow for its
-        // selected path. Do not reuse one generic activity for every scenario.
         ref activities : OperationalActivity[0..*];
+        // UI scenario
+        ref parentFlow : MemoAction[0..1];
+        // threat scenario
+        attribute actorDescription : String;
+        attribute assumptionSummary : String;
+        attribute guaranteeSummary : String;
+        attribute securityObjective : String;
+        attribute abuseCaseReference : String;
+        attribute defaultCategory : ThreatCategoryKind[0..1];
+        // verification scenario
+        attribute verificationEnvironment : String;
+        attribute stimulusSummary : String;
+        // hazard-related use scenario (IEC 62366-1 3.9)
+        attribute hazardReference : String;
+        attribute selectionRationale : String;
     }
 
     // An actual or hypothetical execution of a scenario (usability test run,
@@ -104,13 +126,25 @@ package memo_architecture_operational_scenarios {
         attribute selectsKind : SelectsKind;
         attribute pathOrder : Integer[0..1];
         attribute decisionTaken : String[0..1];
-        end scenario : MemoScenario;
+        end scenario : MemoScenario :>> source;
         // A selected path element may be a WorkflowStep action or a flow
         // element. Those constructs do not share a MEMO base metaclass.
-        end selected;
+        end selected :>> target;
+    }
+    abstract connection selectsLinks : Selects[*];
+    metadata def <selects> SelectsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = selectsLinks meta SysML::Usage;
     }
     connection def OccursDuring :> MemoRelationship {
-        end occurrence : ScenarioOccurrence;
-        end context : UseContext;
+        end occurrence : ScenarioOccurrence :>> source;
+        end context : UseContext :>> target;
+    }
+    abstract connection occursDuringLinks : OccursDuring[*];
+    metadata def <occursDuring> OccursDuringMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = occursDuringLinks meta SysML::Usage;
     }
 }

package/src/architecture/operational/use_cases/memo_use_cases.sysml

@@ -2,6 +2,7 @@
 // achieve with system support — there is no separate Goal class. Clinical,
 // service, manufacturing, and development use cases specialize the same base.
 package memo_architecture_operational_use_cases {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -18,12 +19,7 @@ package memo_architecture_operational_use_cases {
         enum development;
     }
 
-    use case def UseCase {
-        attribute id : String;
-        attribute name : String;
-        attribute description : String;
-        attribute rationale : String;
-        attribute sourceReference : String;
+    use case def UseCase :> MemoUseCase {
         // Text of this use case's goal; this is not a separate Goal element.
         attribute goalStatement : String;
         attribute trigger : String;
@@ -34,34 +30,47 @@ package memo_architecture_operational_use_cases {
         // clinical / service / manufacturing / development
         attribute useCaseKind : UseCaseKind;
 
-        // The device or system under consideration supports the goal.
-        ref supportingSystem : MemoPart[0..1];
+        // The device or system under consideration supports the goal. Native
+        // `subject`, not `ref` (R10-S6): SysIDE requires an explicit subject
+        // before a use case can declare `actor` — `case-usage-subject-
+        // parameter-position` — and "the device/system under consideration"
+        // is exactly what a case's subject means, so this was a duplicate
+        // waiting to surface once `actor` needed a subject to attach to.
+        subject supportingSystem : MemoPart[0..1];
         ref primaryUser : User[0..1];
-        ref supportingActors : Actor[0..*];
+        ref supportingActors : OperationalParticipant[0..*];
         ref useContext : UseContext[0..1];
         ref originatingNeeds : Need[0..*];
     }
 
     connection def Motivates :> MemoRelationship {
-        end motivatingNeed : Need;
-        end motivatedUseCase : UseCase;
+        end motivatingNeed : Need :>> source;
+        end motivatedUseCase : UseCase :>> target;
     }
-    connection def Initiates :> MemoRelationship {
-        end initiatingUser : User;
-        end initiatedUseCase : UseCase;
-    }
-    connection def ParticipatesIn :> MemoRelationship {
-        end participatingActor : Actor;
-        end useCase : UseCase;
-    }
-    // UML use-case relationships. Includes establishes a decomposition level;
-    // extends remains a cross-cutting relationship and is always presented.
-    connection def Includes :> MemoRelationship {
-        end includingUseCase : UseCase;
-        end includedUseCase : UseCase;
+    abstract connection motivatesLinks : Motivates[*];
+    metadata def <motivates> MotivatesMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = motivatesLinks meta SysML::Usage;
     }
+    // `Initiates` and `ParticipatesIn` are native `actor` (R10-S6): both were
+    // a bare typed edge onto UseCase with no attributes of their own, and
+    // native `actor` does not distinguish an initiating actor from a
+    // participating one — that distinction now lives in how the actor is
+    // named on the use case, not in a relationship type. Write
+    // `actor <role> = <existingElement>;` inside the use case instead.
+    // UML use-case decomposition (`Includes`) is native `include use case` /
+    // `include` (R10-S6); write that instead of a connection here. `extends`
+    // has 0 hits in the corpus for a use-case `extend` production, so it stays
+    // a MEMO construct: a cross-cutting relationship that is always presented.
     connection def Extends :> MemoRelationship {
-        end extendingUseCase : UseCase;
-        end extendedUseCase : UseCase;
+        end extendingUseCase : UseCase :>> source;
+        end extendedUseCase : UseCase :>> target;
+    }
+    abstract connection extendsLinks : Extends[*];
+    metadata def <extends> ExtendsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = extendsLinks meta SysML::Usage;
     }
 }

package/src/architecture/operational/workflows/memo_workflows.sysml

@@ -5,6 +5,7 @@
 // scenario. Workflows are action defs: steps, decisions, forks/joins, and
 // successions use native SysML v2 action semantics where portable.
 package memo_architecture_operational_workflows {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -36,7 +37,7 @@ package memo_architecture_operational_workflows {
         attribute completionCondition : String;
         attribute recoveryPathSummary : String;
         attribute timingConstraints : String;
-        ref involvedActors : Actor[0..*];
+        ref involvedActors : OperationalParticipant[0..*];
         attribute environmentSummary : String;
     }
 
@@ -47,7 +48,7 @@ package memo_architecture_operational_workflows {
         attribute exitCondition : String;
         ref performedActivity : OperationalActivity[0..1];
         ref performedTask : UserTask[0..1];
-        ref responsibleRole : Actor[0..1];
+        ref responsibleRole : OperationalParticipant[0..1];
     }
 
     // decision / fork / join / handoff.
@@ -68,8 +69,8 @@ package memo_architecture_operational_workflows {
         attribute parallelismRationale : String[0..1];
         attribute joinCondition : String[0..1];
         attribute informationTransferred : String[0..1];
-        ref fromRole : Actor[0..1];
-        ref toRole : Actor[0..1];
+        ref fromRole : OperationalParticipant[0..1];
+        ref toRole : OperationalParticipant[0..1];
     }
 
     // Resources a workflow requires: information, materials, or equipment by
@@ -93,12 +94,24 @@ package memo_architecture_operational_workflows {
         // The accepted endpoints span SysML metaclasses: an operational
         // workflow or other action may support a use case, task, or
         // capability. They therefore have no single MEMO base type.
-        end supporter;
-        end supported;
+        end supporter :>> source;
+        end supported : MemoAction :>> target;
+    }
+    abstract connection supportsLinks : Supports[*];
+    metadata def <supports> SupportsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = supportsLinks meta SysML::Usage;
     }
     connection def RequiresResource :> MemoRelationship {
-        end workflow : OperationalWorkflow;
-        end resource : WorkflowResource;
+        end workflow : OperationalWorkflow :>> source;
+        end resource : WorkflowResource :>> target;
+    }
+    abstract connection requiresResourceLinks : RequiresResource[*];
+    metadata def <requiresResource> RequiresResourceMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = requiresResourceLinks meta SysML::Usage;
     }
 
     // ── Workflow transformation (as-is → to-be) ──────────────────
@@ -113,8 +126,14 @@ package memo_architecture_operational_workflows {
         attribute transformKind : TransformKind;
         attribute transformation : StepTransformationKind[0..1];
         attribute transformationRationale : String[0..1];
-        end source : MemoPart;
-        end target : MemoPart;
+        end source : MemoAction;
+        end target : MemoAction;
+    }
+    abstract connection transformsLinks : Transforms[*];
+    metadata def <transforms> TransformsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = transformsLinks meta SysML::Usage;
     }
     // The device or system whose introduction enables a workflow.
 }

package/src/architecture/realization/deployment/memo_deployment.sysml

@@ -1,18 +1,30 @@
-// Deployment (allocation) view: SoftwareModule buildsInto
-// DeploymentUnit; DeploymentUnit deploysTo ProcessingNode; SoftwareComponent
-// hostedBy ProcessingNode. Software deploys only to capable execution nodes
-// (rules/crosslayer).
+// Deployment (allocation) view: SoftwareModule buildsInto DeploymentUnit;
+// DeploymentUnit deploysTo ProcessingNode. Software deploys only to capable
+// execution nodes (rules/crosslayer).
+//
+// `HostedBy` is NOT part of that chain, and this comment used to claim it was
+// ("SoftwareComponent hostedBy ProcessingNode"). It is
+// `processingNode : ArchitectureElement -> hostAssembly : ArchitectureElement`:
+// physical hosting of a node by the assembly it is mounted in, running the
+// other way and between different things. Software reaches a node through
+// DeploysTo.
 package memo_architecture_realization_deployment {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
+    // The standard's allocation base, which the two AADL bindings below root
+    // on alongside MemoRelationship.
+    private import Allocations::Allocation;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
     private import memo_core_relationships::*;
     private import memo_architecture_implementation_software_structure::*;
     private import memo_architecture_implementation_software_runtime::*;
+    private import memo_architecture_implementation_hardware_electrical::*;   // NetworkMedium
     private import memo_architecture_realization_physical::*;
     private import memo_architecture_functional_functions::*;
     private import memo_architecture_logical_structure::*;
+    private import memo_architecture_logical_interfaces::*;                   // ComponentExchange
 
     part def DeploymentUnit specializes ArchitectureElement {
         attribute unitKind : String;
@@ -29,17 +41,88 @@ package memo_architecture_realization_deployment {
     }
 
     connection def BuildsInto :> MemoRelationship {
-        end module : SoftwareModule;
-        end deploymentUnit : DeploymentUnit;
+        end module : SoftwareModule :>> source;
+        end deploymentUnit : DeploymentUnit :>> target;
+    }
+    abstract connection buildsIntoLinks : BuildsInto[*];
+    metadata def <buildsInto> BuildsIntoMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = buildsIntoLinks meta SysML::Usage;
     }
     connection def DeploysTo :> MemoRelationship {
         attribute deploymentKind : DeploymentKind;
-        end deploymentUnit : DeploymentUnit;
-        end node : ProcessingNode;
+        end deploymentUnit : DeploymentUnit :>> source;
+        end node : ProcessingNode :>> target;
+    }
+    abstract connection deploysToLinks : DeploysTo[*];
+    metadata def <deploysTo> DeploysToMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = deploysToLinks meta SysML::Usage;
     }
     connection def ProvidesEnvironment :> MemoRelationship {
-        end node : ProcessingNode;
-        end environment : RuntimeEnvironment;
+        end node : ProcessingNode :>> source;
+        end environment : RuntimeEnvironment :>> target;
+    }
+    abstract connection providesEnvironmentLinks : ProvidesEnvironment[*];
+    metadata def <providesEnvironment> ProvidesEnvironmentMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = providesEnvironmentLinks meta SysML::Usage;
+    }
+
+    // ─── AADL bindings (SAE AS5506) — plan C1 ────────────────────────────
+    //
+    // AADL's analytic power is that EVERYTHING is bound to something, and the
+    // binding is where latency, bandwidth and fault propagation accrue. MEMO
+    // had one binding of three: `DeploysTo` is `actual_processor_binding`.
+    // Without the other two, `SoftwareComponent.memoryBudget` is unanalysable
+    // and `EndToEndFlow.latencyBudgetMs` cannot be checked against the media
+    // the flow traverses — the analysis the flow comment below describes and
+    // the model could not perform.
+    //
+    // Both are `allocation def`s rooted on the standard's
+    // `Allocations::Allocation`, because a binding IS an allocation and the
+    // language says so. The double specialization keeps MEMO's identification
+    // core from `MemoRelationship` while adding the standard's allocation
+    // semantics; both root on `Connections::BinaryConnection`, so this is a
+    // diamond and not a conflict. Verified under `syside check` against a
+    // negative control (a non-existent supertype is reported), so the clean
+    // result is the checker agreeing rather than the checker skipping.
+
+    // AADL `actual_memory_binding`. Which memory a software component's code
+    // and data occupy — what makes a memory budget a claim about a device
+    // rather than a string.
+    allocation def MemoryBinding :> MemoRelationship, Allocations::Allocation {
+        attribute bindingKind : String;
+        end boundComponent : SoftwareComponent :>> source;
+        end memory : MemoryDevice :>> target;
+    }
+    abstract connection memoryBindingLinks : MemoryBinding[*];
+    metadata def <memoryBinding> MemoryBindingMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::AllocationDefinition;
+        :> annotatedElement : SysML::AllocationUsage;
+        :>> baseType = memoryBindingLinks meta SysML::Usage;
+    }
+
+    // AADL `actual_connection_binding`. Which physical medium carries a
+    // component exchange. The source is the ComponentExchange rather than the
+    // `ComponentConnects` link, because the exchange is the ELEMENT that owns
+    // the budget (§19.3) and a link instance is not something the graph can
+    // bind to; it is also exactly where the latency the medium contributes has
+    // to be accounted.
+    allocation def ConnectionBinding :> MemoRelationship, Allocations::Allocation {
+        attribute allocatedBandwidth : String;
+        attribute mediumLatencyMs : Real;
+        end boundExchange : ComponentExchange :>> source;
+        end medium : NetworkMedium :>> target;
+    }
+    abstract connection connectionBindingLinks : ConnectionBinding[*];
+    metadata def <connectionBinding> ConnectionBindingMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::AllocationDefinition;
+        :> annotatedElement : SysML::AllocationUsage;
+        :>> baseType = connectionBindingLinks meta SysML::Usage;
     }
 
     // ─── AADL-style flow modeling (SAE AS5506) ───────────────────────────
@@ -68,8 +151,8 @@ package memo_architecture_realization_deployment {
     part def EndToEndFlow specializes ArchitectureElement {
         attribute latencyBudgetMs : Real;
         attribute analysisPurpose : String;
-        ref sourceFunction : SystemFunction[0..1];
-        ref sinkFunction : SystemFunction[0..1];
+        ref sourceFunction : MemoFunction[0..1];
+        ref sinkFunction : MemoFunction[0..1];
         ref logicalSegments : LogicalComponent[0..*];
         // Runtime C&C components (SEI) — the elements actually bound to hardware.
         ref softwareSegments : SoftwareComponent[0..*];
@@ -79,12 +162,24 @@ package memo_architecture_realization_deployment {
     // segment per traversed component boundary (AADL flow-spec → end-to-end).
     connection def FlowComprisesSpec :> MemoRelationship {
         attribute segmentOrder : Integer;
-        end endToEndFlow : EndToEndFlow;
-        end spec : FlowSpecification;
+        end endToEndFlow : EndToEndFlow :>> source;
+        end spec : FlowSpecification :>> target;
+    }
+    abstract connection flowComprisesSpecLinks : FlowComprisesSpec[*];
+    metadata def <flowComprisesSpec> FlowComprisesSpecMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = flowComprisesSpecLinks meta SysML::Usage;
     }
     // The flow traverses a software→hardware binding; latency accrues here.
     connection def FlowTraversesBinding :> MemoRelationship {
-        end endToEndFlow : EndToEndFlow;
-        end deploymentUnit : DeploymentUnit;
+        end endToEndFlow : EndToEndFlow :>> source;
+        end deploymentUnit : DeploymentUnit :>> target;
+    }
+    abstract connection flowTraversesBindingLinks : FlowTraversesBinding[*];
+    metadata def <flowTraversesBinding> FlowTraversesBindingMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = flowTraversesBindingLinks meta SysML::Usage;
     }
 }

package/src/architecture/realization/physical/memo_physical_architecture.sysml

@@ -22,9 +22,34 @@ package memo_architecture_realization_physical {
         attribute capacityMB : String;
         attribute nonVolatile : Boolean;
     }
-    part def PhysicalPort specializes InterfaceElement {
+    // A physical boundary feature: the connector the outside world plugs into.
+    //
+    // A `port def` (Track A1), not a part. It was `part def PhysicalPort
+    // specializes InterfaceElement` for one reason — the exchange endpoints
+    // were `MemoPart`-typed, so anything that terminated an exchange had to be
+    // a part (CR-ONT-002, since rewritten). Track A0 made those ends
+    // metaclass-neutral, and KerML forbids a port from specializing a
+    // part-based type, so the specialization moves to `MemoPort`.
+    //
+    // `direction` is gone: the port usage carries `in` / `out` / `inout`
+    // natively (Track A2). `DirectionKind` survives for the non-port
+    // constructs that still need it — see memo_core_enumerations.
+    //
+    // `portKind` is declared here AND on SoftwarePort rather than on a shared
+    // base. `MemoPort` is the identification core and nothing else — the block
+    // comment in memo_core_common makes that a stated invariant across all
+    // five bases — and pushing `portKind` down onto DataPort, SensorPort,
+    // CommandPort, and LogicalPort would give them a second classifier beside
+    // the ones they already carry (`interfaceType`, `sensorDomain`,
+    // `commandDomain`, `contentKind`). An intermediate `abstract port def`
+    // holding one attribute is a class standing in for an attribute, which is
+    // what the lean direction removes. One attribute, two sites, no new type.
+    port def PhysicalPort specializes MemoPort {
         attribute portKind : InterfaceKind;
+        // AADL port category (plan C2) — see SoftwarePort. A physical port
+        // carries it for the same reason: a sampled sensor line and a queued
+        // interrupt line fail differently under overload.
+        attribute portCategory : PortCategoryKind;
         attribute connectorType : String;
-        attribute direction : DirectionKind;
     }
 }