diff --git a/Gemfile b/Gemfile
index 2037caf..1ebe644 100644
--- a/Gemfile
+++ b/Gemfile
@@ -15,6 +15,10 @@ gemspec
   actual_path = sibling_gem == "emf" ? File.expand_path("~/src/claricle/emf") : actual_path
   if actual_path && File.directory?(actual_path) && ENV["EA_FORCE_RUBYGEMS"] != "1"
     gem sibling_gem, path: actual_path
+  elsif sibling_gem == "xmi"
+    # xmi 0.7.0 is unreleased; resolve the companion branch until it
+    # ships, then delete this elsif so xmi comes from rubygems again.
+    gem sibling_gem, github: "lutaml/xmi", branch: "feat/nested-classifier-mapping"
   else
     gem sibling_gem
   end
diff --git a/ea.gemspec b/ea.gemspec
index 17884b3..5a13e62 100644
--- a/ea.gemspec
+++ b/ea.gemspec
@@ -36,7 +36,14 @@ Gem::Specification.new do |spec|
   spec.add_dependency "lutaml-path"
   spec.add_dependency "sqlite3"
   spec.add_dependency "rubyzip"
-  spec.add_dependency "xmi", "~> 0.6", ">= 0.6.0"
+  # Requires unreleased xmi features (nestedClassifier, lowerValue-first
+  # order); CI installs them from the companion branch (see Gemfile).
+  # A released xmi (e.g. 0.6.2) satisfies this constraint but would
+  # silently drop nested classes, so lib/ea/xmi_guard.rb raises at
+  # require time when the loaded xmi lacks nestedClassifier support.
+  # Tighten to "~> 0.7" (and delete the guard) once xmi 0.7.0 is
+  # released.
+  spec.add_dependency "xmi", ">= 0.6.2"
   spec.add_dependency "nokogiri", "~> 1.18"
   spec.add_dependency "liquid"
   spec.add_dependency "thor", "~> 1.4"
diff --git a/lib/ea.rb b/lib/ea.rb
index 542c432..cd4fe93 100644
--- a/lib/ea.rb
+++ b/lib/ea.rb
@@ -63,3 +63,9 @@ def to_uml(path_or_model)
     end
   end
 end
+
+# Boot-time guard: fail loudly if the resolved xmi gem lacks the
+# unreleased features this gem depends on (see lib/ea/xmi_guard.rb and
+# the xmi dependency comment in ea.gemspec). Required last so
+# Ea::Error is defined when the guard raises.
+require "ea/xmi_guard"
diff --git a/lib/ea/cli/app.rb b/lib/ea/cli/app.rb
index 38d5f0a..a2f5af6 100644
--- a/lib/ea/cli/app.rb
+++ b/lib/ea/cli/app.rb
@@ -120,6 +120,7 @@ def render(name = nil, file = nil)
       desc "export SUB FILE", "Export model (SUB: xmi|json|plantuml|xsd)"
       option :output, **OUTPUT_OPTION, desc: "Output path"
       option :package, type: :string, desc: "Restrict to a package name"
+      option :mdg, type: :array, desc: "MDG technology XML files or directories (xmi only)"
       def export(sub, file)
         Command::Export.new(sub: sub, file: file, **symbolize(options)).call
       end
diff --git a/lib/ea/cli/command/export.rb b/lib/ea/cli/command/export.rb
index 2e3ac3c..f34fb23 100644
--- a/lib/ea/cli/command/export.rb
+++ b/lib/ea/cli/command/export.rb
@@ -39,7 +39,7 @@ def exporter
         # a string. New formats add a new entry here without touching
         # this class body. Lambdas lazy-resolve autoloaded namespaces.
         EXPORTERS = {
-          xmi: ->(model, **_o) { Ea::Transformers.qea_to_xmi(model) },
+          xmi: ->(model, **o) { Ea::Transformers.qea_to_xmi(model, mdg_registry: o[:mdg_registry]) },
           json: ->(model, **o) { Ea::Export::Json::Generator.call(model, **o) },
           "json-schema": ->(model, **o) { Ea::Export::JsonSchema::Generator.call(model, **o) },
           plantuml: ->(model, **o) { Ea::Export::PlantUml::Generator.call(model, **o) },
@@ -71,9 +71,18 @@ def exporter_options
           opts = {}
           opts[:target_namespace] = options[:target_namespace] if options[:target_namespace]
           opts[:prefix] = options[:prefix] if options[:prefix]
+          add_mdg_registry(opts)
           opts
         end
 
+        # Registry construction is xmi-only: the other exporters reject
+        # unknown keywords.
+        def add_mdg_registry(opts)
+          return unless options[:mdg] && sub == :xmi
+
+          opts[:mdg_registry] = Ea::Mdg::Registry.from_paths(options[:mdg])
+        end
+
         def model
           @model ||= load_database(file_path)
         end
diff --git a/lib/ea/cli/command/mdg.rb b/lib/ea/cli/command/mdg.rb
index cf15fd1..bc338e0 100644
--- a/lib/ea/cli/command/mdg.rb
+++ b/lib/ea/cli/command/mdg.rb
@@ -39,16 +39,7 @@ def registry
         end
 
         def build_registry
-          registry = Ea::Mdg::Registry.new
-          Dir.glob("spec/fixtures/mdg/**/*.xml").each do |path|
-            begin
-              doc = Ea::Mdg::Loader.from_path(path).document
-              registry.register(doc)
-            rescue StandardError => e
-              warn "Skipped #{path}: #{e.message}" if ENV["EA_DEBUG"]
-            end
-          end
-          registry
+          Ea::Mdg::Registry.from_paths(["spec/fixtures/mdg"])
         end
 
         def list_technologies
diff --git a/lib/ea/guid_format.rb b/lib/ea/guid_format.rb
index fb7de56..ed72e0e 100644
--- a/lib/ea/guid_format.rb
+++ b/lib/ea/guid_format.rb
@@ -71,5 +71,21 @@ def connector_end_xmi_id(connector_xmi_id, side:)
       trimmed = first_segment.length > 2 ? first_segment[2..] : first_segment
       rest ? "EAID_#{tag}#{trimmed}_#{rest}" : "EAID_#{tag}#{trimmed}"
     end
+
+    # Build the xmi:id for an operation's synthesized return parameter.
+    #
+    # Sparx EA's convention: take the operation's own id and replace its
+    # first GUID segment with `RETURNID`. An id carrying no further
+    # segments has nothing to drop, so its only segment is kept. The
+    # parameter's ea_guid is the braced form of this id, so callers
+    # derive it with {xmi_id_to_ea_guid} rather than spelling the shape
+    # a second time.
+    #
+    # @param operation_xmi_id [String] e.g. "EAID_AB12CDEF_3456_..."
+    # @return [String] e.g. "EAID_RETURNID_3456_..."
+    def return_parameter_xmi_id(operation_xmi_id)
+      body = operation_xmi_id.sub(/\A(?:EAID|EAPK)_/, "")
+      "EAID_RETURNID_#{body.split("_", 2).last}"
+    end
   end
 end
diff --git a/lib/ea/mdg/registry.rb b/lib/ea/mdg/registry.rb
index d12662e..6dcb903 100644
--- a/lib/ea/mdg/registry.rb
+++ b/lib/ea/mdg/registry.rb
@@ -26,6 +26,27 @@ def initialize
         @documents = []
       end
 
+      # Build a registry from MDG XML files and/or directories
+      # (directories are globbed recursively). Unloadable files are
+      # skipped — MDG discovery is a boundary where partial input is
+      # normal (set EA_DEBUG=1 to see what was skipped).
+      #
+      # @param paths [Array<String>]
+      # @return [Ea::Mdg::Registry]
+      def self.from_paths(paths)
+        new.tap do |registry|
+          paths.flat_map { |path| expand_mdg_path(path) }.each do |file|
+            registry.register(Loader.from_path(file).document)
+          rescue StandardError => e
+            warn "Skipped MDG #{file}: #{e.message}" if ENV["EA_DEBUG"]
+          end
+        end
+      end
+
+      def self.expand_mdg_path(path)
+        File.directory?(path) ? Dir.glob(File.join(path, "**/*.xml")).sort : [path]
+      end
+
       # Register an MDG Document. Subsequent registrations of the
       # same technology_name replace the prior one (last-wins).
       #
diff --git a/lib/ea/qea/database.rb b/lib/ea/qea/database.rb
index 123db55..b07c78d 100644
--- a/lib/ea/qea/database.rb
+++ b/lib/ea/qea/database.rb
@@ -212,9 +212,19 @@ def diagram_links_for(id)
         @diagram_links_by_id[id] || []
       end
 
-      # Find an object by ID
+      # Find an object by ID. Uses the repository's primary-key index
+      # rather than a scan: the parentid walk in QeaToXmi's
+      # `cyclic_ancestry?` calls this once per ancestor hop per object.
+      #
+      # Hash lookup matches on eql?, so it would miss a Float id that a
+      # scan's == would have caught. No caller here can do that:
+      # t_object.Object_ID is declared Type::Integer and the model
+      # coerces on construction, and every caller passes either such an
+      # attribute or an explicit to_i. Deliberately left unguarded — a
+      # scan fallback on miss would put every absent-parent lookup in
+      # the ancestry walk back on a linear scan.
       def find_object(id)
-        objects.find_by_key(:ea_object_id, id)
+        objects.find(id)
       end
 
       # Find object by ea_guid
diff --git a/lib/ea/qea/models/ea_connector.rb b/lib/ea/qea/models/ea_connector.rb
index 335048b..425a898 100644
--- a/lib/ea/qea/models/ea_connector.rb
+++ b/lib/ea/qea/models/ea_connector.rb
@@ -119,10 +119,11 @@ def aggregation?
           connector_type == "Aggregation"
         end
 
-        # Check if connector is a realization
+        # Check if connector is a realization. EA writes both the US
+        # and UK spellings depending on version/edition.
         # @return [Boolean]
         def realization?
-          connector_type == "Realization"
+          %w[Realization Realisation].include?(connector_type)
         end
 
         # Check if source is aggregate
diff --git a/lib/ea/qea/models/ea_object.rb b/lib/ea/qea/models/ea_object.rb
index 58683fb..8b3cf91 100644
--- a/lib/ea/qea/models/ea_object.rb
+++ b/lib/ea/qea/models/ea_object.rb
@@ -194,17 +194,22 @@ def leaf?
         #   Note           — diagram note. Same situation as Text: rendering
         #                    hint, not a model element. Dropped.
         #
+        TRANSFORMER_TYPES = {
+          "Enumeration" => :enumeration,
+          "DataType" => :data_type,
+          "PrimitiveType" => :data_type,
+          "Class" => :class,
+          "Interface" => :class,
+          "Signal" => :signal,
+          "Object" => :instance,
+          "Association" => :association_element,
+        }.freeze
+
         # @return [Symbol, nil] Registry key or nil if not a UML model element
         def transformer_type
-          if enumeration? || stereotype_is?("enumeration")
-            :enumeration
-          elsif data_type?
-            :data_type
-          elsif uml_class? || interface?
-            :class
-          elsif instance?
-            :instance
-          end
+          return :enumeration if stereotype_is?("enumeration")
+
+          TRANSFORMER_TYPES[object_type]
         end
 
         def stereotype_is?(expected)
diff --git a/lib/ea/qea/models/ea_xref.rb b/lib/ea/qea/models/ea_xref.rb
index 4367fa8..1fb8e19 100644
--- a/lib/ea/qea/models/ea_xref.rb
+++ b/lib/ea/qea/models/ea_xref.rb
@@ -10,6 +10,9 @@ class EaXref < BaseModel
         attribute :xref_id, Lutaml::Model::Type::String
         attribute :name, Lutaml::Model::Type::String
         attribute :xref_type, Lutaml::Model::Type::String
+        attribute :visibility, Lutaml::Model::Type::String
+        attribute :behavior, Lutaml::Model::Type::String
+        attribute :partition, Lutaml::Model::Type::String
         attribute :client, Lutaml::Model::Type::String
         attribute :supplier, Lutaml::Model::Type::String
         attribute :description, Lutaml::Model::Type::String
diff --git a/lib/ea/qea/repositories/base_repository.rb b/lib/ea/qea/repositories/base_repository.rb
index cbaaea7..4b9cab5 100644
--- a/lib/ea/qea/repositories/base_repository.rb
+++ b/lib/ea/qea/repositories/base_repository.rb
@@ -215,9 +215,12 @@ def size
 
         private
 
+        # First occurrence wins, matching what a scan would return —
+        # `find` and `find_by_key` must not disagree about which record
+        # answers for a duplicated key.
         def build_pk_index
           @pk_index = {}
-          @records.each { |r| @pk_index[r.primary_key] = r }
+          @records.each { |r| @pk_index[r.primary_key] ||= r }
         end
       end
     end
diff --git a/lib/ea/transformers/qea_to_xmi.rb b/lib/ea/transformers/qea_to_xmi.rb
index ad8532f..01c5f36 100644
--- a/lib/ea/transformers/qea_to_xmi.rb
+++ b/lib/ea/transformers/qea_to_xmi.rb
@@ -25,6 +25,7 @@ module QeaToXmi
       autoload :RunState,           "ea/transformers/qea_to_xmi/run_state"
       autoload :AssociationEnd,     "ea/transformers/qea_to_xmi/association_end"
       autoload :ExtensionSerializer, "ea/transformers/qea_to_xmi/extension_serializer"
+      autoload :PrimitiveTypes,    "ea/transformers/qea_to_xmi/primitive_types"
       autoload :ProfileSerializer, "ea/transformers/qea_to_xmi/profile_serializer"
     end
   end
diff --git a/lib/ea/transformers/qea_to_xmi/cardinality.rb b/lib/ea/transformers/qea_to_xmi/cardinality.rb
index 3c0591d..def8ce6 100644
--- a/lib/ea/transformers/qea_to_xmi/cardinality.rb
+++ b/lib/ea/transformers/qea_to_xmi/cardinality.rb
@@ -13,21 +13,42 @@ module QeaToXmi
       # `<upperValue value="M"/>`) — never a range string. This module
       # translates the EA form to a `{ lower:, upper: }` pair.
       #
-      # Default-when-empty: EA's "no bound specified" maps to UML's
-      # unspecified multiplicity, which Sparx renders as
-      # `<lowerValue value="0"/>` and `<upperValue value="-1"/>`.
-      # Always emitting both is required for round-trip parity with
-      # real Sparx XMI (see TODO 26).
+      # Default-when-empty: blank input maps to UML's unspecified
+      # multiplicity, `{ lower: "0", upper: "*" }`. Whether those
+      # bounds reach the document is the caller's call — EA leaves an
+      # association end bare when its card field is blank.
       module Cardinality
         # Tokens EA uses for "unbounded". Matched case-insensitively.
-        UNLIMITED_TOKENS = %w[* *-1 unbounded].freeze
+        UNLIMITED_TOKENS = %w[* *-1 -1 unbounded].freeze
 
-        # UML defaults when EA carries no explicit bound.
+        # UML defaults when EA carries no explicit bound. EA's wire
+        # form for unlimited is "*" (never "-1" — the reference
+        # exports contain no value="-1" at all).
         DEFAULT_LOWER = "0"
-        DEFAULT_UPPER = "-1"
+        DEFAULT_UPPER = "*"
+
+        # EA writes an explicit 1..1 for a Property whose t_attribute
+        # bound columns are BOTH blank, rather than falling back to the
+        # UML unspecified multiplicity.
+        DEFAULT_ATTRIBUTE_BOUNDS = { lower: "1", upper: "1" }.freeze
 
         module_function
 
+        # The bound pair for a t_attribute row. The 1..1 default is a
+        # property of the PAIR — with one column set, the missing side
+        # keeps the normal UML fallback, so `2` and a blank upper is
+        # 2..* rather than the invalid 2..1.
+        #
+        # @param lower [String, Integer, nil] t_attribute.lowerbound
+        # @param upper [String, Integer, nil] t_attribute.upperbound
+        # @return [Hash{Symbol=>String}] `{ lower:, upper: }`
+        def attribute_bounds(lower, upper)
+          both_blank = lower.to_s.strip.empty? && upper.to_s.strip.empty?
+          return DEFAULT_ATTRIBUTE_BOUNDS if both_blank
+
+          { lower: normalize_lower(lower), upper: normalize_upper(upper) }.freeze
+        end
+
         # @param raw [String, nil] e.g. "1..*", "0..1", "1", "*", nil
         # @return [Hash{Symbol=>String}] `{ lower:, upper: }` always
         #   populated; never nil. Empty/nil input returns the UML default.
@@ -38,17 +59,14 @@ def parse(raw)
           return parse_range(stripped) if stripped.include?("..")
 
           # Bare unlimited token (e.g. "*") means "many" — lower bound
-          # is unspecified, which UML renders as 0..-1. Returning
-          # `{ lower: "-1", upper: "-1" }` here would be invalid:
-          # LiteralInteger cannot hold -1.
+          # is unspecified, which renders as 0..*.
           return defaults if UNLIMITED_TOKENS.include?(stripped.downcase)
 
-          single = normalize_bound(stripped)
-          { lower: single, upper: single }
+          { lower: stripped, upper: stripped }
         end
 
-        # Normalise an upper-bound token: `*` / `unbounded` → `-1`
-        # (UML LiteralUnlimitedNatural wire form).
+        # Normalise an upper-bound token: `*` / `unbounded` → `*`
+        # (the LiteralUnlimitedNatural wire form EA also uses).
         # @param raw [String, Integer, nil]
         # @return [String]
         def normalize_upper(raw)
@@ -57,17 +75,21 @@ def normalize_upper(raw)
           stripped = raw.to_s.strip
           return DEFAULT_UPPER if stripped.empty?
 
-          UNLIMITED_TOKENS.include?(stripped.downcase) ? "-1" : stripped
+          UNLIMITED_TOKENS.include?(stripped.downcase) ? "*" : stripped
         end
 
         # Normalise a lower-bound token: empty/nil → "0" (UML default).
+        # Unlimited tokens also → "0" — a lower bound serializes as
+        # uml:LiteralInteger, which cannot hold `*` or `-1`.
         # @param raw [String, Integer, nil]
         # @return [String]
         def normalize_lower(raw)
           return DEFAULT_LOWER if raw.nil?
 
           stripped = raw.to_s.strip
-          stripped.empty? ? DEFAULT_LOWER : stripped
+          return DEFAULT_LOWER if stripped.empty?
+
+          UNLIMITED_TOKENS.include?(stripped.downcase) ? DEFAULT_LOWER : stripped
         end
 
         # ---- Internal helpers ----
@@ -78,17 +100,7 @@ def defaults
 
         def parse_range(stripped)
           lower, upper = stripped.split("..", 2)
-          { lower: normalize_bound(lower), upper: normalize_bound(upper) }
-        end
-
-        # A single bound token (one side of `..` or a bare scalar).
-        # Empty / `*` → UML unlimited (`-1`).
-        def normalize_bound(token)
-          return "-1" if token.nil?
-          return "-1" if token.strip.empty?
-
-          stripped = token.strip
-          UNLIMITED_TOKENS.include?(stripped.downcase) ? "-1" : stripped
+          { lower: normalize_lower(lower), upper: normalize_upper(upper) }
         end
       end
     end
diff --git a/lib/ea/transformers/qea_to_xmi/context.rb b/lib/ea/transformers/qea_to_xmi/context.rb
index 53be516..581dae7 100644
--- a/lib/ea/transformers/qea_to_xmi/context.rb
+++ b/lib/ea/transformers/qea_to_xmi/context.rb
@@ -9,6 +9,11 @@ module QeaToXmi
       # - ID-derivation helpers (`xmi_id_for`, `end_xmi_id_for`) backed by
       #   {GuidFormat}
       # - delegated database lookups (objects, packages, attributes, etc.)
+      # - the walk's position ordering (`sorted_by_position`), applied at
+      #   the lookup for operation parameters so the UML tree and the
+      #   extension block cannot disagree about their order. Attributes
+      #   and operations are deliberately left for their callers to
+      #   order — see `attributes_for`.
       #
       # The {Ea::Qea::Database} already maintains its own lookup indexes
       # (object-by-id, connectors-by-object, attributes-by-object, etc.).
@@ -33,6 +38,17 @@ def xmi_id_for(record, prefix: "EAID")
           GuidFormat.ea_guid_to_xmi_id(record.ea_guid, prefix: prefix)
         end
 
+        # Whether a record can anchor a synthesized id. EA derives a
+        # synthesized id's tail from its owner's GUID, so an owner
+        # without one yields a tailless id. Both the UML tree and the
+        # extension block ask this, so they cannot disagree about
+        # whether to emit the thing that id would have named.
+        # @param record [#ea_guid]
+        # @return [Boolean]
+        def identifiable?(record)
+          !record&.ea_guid.to_s.strip.empty?
+        end
+
         # @param connector_xmi_id [String]
         # @param side [Symbol] :source or :destination
         # @return [String]
@@ -66,6 +82,11 @@ def objects_in_package(package_id)
           database.objects_in_package(package_id)
         end
 
+        # Deliberately NOT ordered here, unlike params_for_operation:
+        # the extension block emits attributes in database order while
+        # the LI-bound preallocation sorts them by name, so each caller
+        # orders for itself. Sorting at this lookup would move export
+        # bytes.
         # @param object_id [Integer]
         # @return [Array<Ea::Qea::Models::EaAttribute>]
         def attributes_for(object_id)
@@ -78,10 +99,23 @@ def operations_for(object_id)
           database.operations_for_object(object_id)
         end
 
+        # t_operationparams is loaded with an unordered SELECT, and both
+        # the UML tree and the extension block emit parameters in Pos
+        # order. Ordering here means no caller can obtain them unordered.
         # @param operation_id [Integer]
         # @return [Array<Ea::Qea::Models::EaOperationParam>]
         def params_for_operation(operation_id)
-          database.operation_params_for(operation_id)
+          sorted_by_position(database.operation_params_for(operation_id))
+        end
+
+        # ---- Ordering -----------------------------------------------------
+
+        # EA emits a record's children in tree-position order (TPos / Pos),
+        # ties broken by name.
+        # @param records [Array<Ea::Qea::Models::BaseModel>]
+        # @return [Array<Ea::Qea::Models::BaseModel>]
+        def sorted_by_position(records)
+          records.sort_by { |record| [record.sort_position, record.name.to_s] }
         end
 
         # Connectors where the object is on either side.
diff --git a/lib/ea/transformers/qea_to_xmi/extension_serializer.rb b/lib/ea/transformers/qea_to_xmi/extension_serializer.rb
index afe45d1..54b3a2a 100644
--- a/lib/ea/transformers/qea_to_xmi/extension_serializer.rb
+++ b/lib/ea/transformers/qea_to_xmi/extension_serializer.rb
@@ -36,6 +36,7 @@ def call
           sections = [
             build_elements_section,
             build_connectors_section,
+            build_primitivetypes_section,
             build_diagrams_section
           ].reject(&:empty?)
           sections.join("\n")
@@ -96,6 +97,7 @@ def object_element_xml(obj)
                                                            is_abstract: obj.abstract?),
             style_for_object(obj),
             tags_block_for(obj.ea_guid),
+            xrefs_xml("\t\t\t", obj.ea_guid, "element property"),
             attributes_block_for(obj),
             operations_block_for(obj),
             "\t\t</element>"
@@ -121,7 +123,9 @@ def skip_object?(obj)
           "DataType" => "uml:DataType",
           "PrimitiveType" => "uml:PrimitiveType",
           "Object" => "uml:Object",
-          "Package" => "uml:Package"
+          "Signal" => "uml:Signal",
+          "Package" => "uml:Package",
+          "Association" => "uml:Association"
         }.freeze
 
         def uml_type_for(obj)
@@ -250,17 +254,24 @@ def attribute_xml(attr)
             "\t\t\t\t\t<coords ordered=\"0\" scale=\"0\"/>",
             "\t\t\t\t\t<containment containment=\"Not Specified\" position=\"#{attr.pos || 0}\"/>",
             "\t\t\t\t\t<stereotype/>",
-            %(\t\t\t\t\t<bounds lower="#{attr.lowerbound || 1}" upper="#{attr.upperbound || 1}"/>),
+            bounds_xml(attr),
             "\t\t\t\t\t<options/>",
             "\t\t\t\t\t<style/>",
             %(\t\t\t\t\t<styleex value="#{escape(attr.styleex.to_s)}"/>),
             "\t\t\t\t\t<tags/>",
-            "\t\t\t\t\t<xrefs/>",
+            xrefs_xml("\t\t\t\t\t", attr.ea_guid, "attribute property"),
             "\t\t\t\t</attribute>"
           ]
           lines.join("\n")
         end
 
+        # Shares the transformer's pair rule so the extension block and
+        # the UML tree can never report different multiplicities.
+        def bounds_xml(attr)
+          bounds = Cardinality.attribute_bounds(attr.lowerbound, attr.upperbound)
+          %(\t\t\t\t\t<bounds lower="#{escape(bounds[:lower])}" upper="#{escape(bounds[:upper])}"/>)
+        end
+
         def attribute_scope(attr)
           (attr.scope || "Public").downcase.capitalize
         end
@@ -310,14 +321,19 @@ def operation_xml(op)
             "\t\t\t\t\t<code/>",
             "\t\t\t\t\t<style/>",
             "\t\t\t\t\t<styleex/>",
-            documentation_element(op.notes),
-            "\t\t\t\t\t<tags/>",
-            parameters_block_for(op),
-            "\t\t\t\t</operation>"
+            *operation_tail(op)
           ]
           lines.join("\n")
         end
 
+        def operation_tail(op)
+          [documentation_element(op.notes),
+           "\t\t\t\t\t<tags/>",
+           parameters_block_for(op),
+           xrefs_xml("\t\t\t\t\t", op.ea_guid, "operation property"),
+           "\t\t\t\t</operation>"]
+        end
+
         def operation_scope(op)
           (op.scope || "Public").downcase.capitalize
         end
@@ -338,11 +354,42 @@ def operation_type(op)
         end
 
         def parameters_block_for(op)
-          params = @context.params_for_operation(op.operationid)
-          return "" if params.empty?
+          entries = [return_parameter_xml(op), *declared_parameters_xml(op)].compact
+          return "" if entries.empty?
+
+          "\t\t\t\t\t<parameters>\n#{entries.join("\n")}\n\t\t\t\t\t</parameters>"
+        end
+
+        def declared_parameters_xml(op)
+          @context.params_for_operation(op.operationid)
+                  .reject(&:return?)
+                  .map { |param| parameter_xml(param) }
+        end
+
+        # The trailing children of a synthesized return parameter —
+        # all empty, in EA's order.
+        RETURN_PARAMETER_TAIL = ["\t\t\t\t\t\t\t<style/>",
+                                 "\t\t\t\t\t\t\t<styleex/>",
+                                 "\t\t\t\t\t\t\t<documentation/>",
+                                 "\t\t\t\t\t\t\t<tags/>",
+                                 "\t\t\t\t\t\t\t<xrefs/>"].freeze
 
-          inner = params.map { |p| parameter_xml(p) }.join("\n")
-          "\t\t\t\t\t<parameters>\n#{inner}\n\t\t\t\t\t</parameters>"
+        # EA lists the return first, as a synthesized parameter with no
+        # t_operationparams row behind it. Both its idref and its
+        # ea_guid come from the operation's own id via {GuidFormat}, so
+        # the two agree by construction — an untyped operation has no
+        # return to describe, and one whose nullable t_operation.ea_guid
+        # is blank has nothing to derive the ids from.
+        def return_parameter_xml(operation)
+          return nil if PrimitiveTypes.normalize_name(operation.type).empty?
+          return nil unless @context.identifiable?(operation)
+
+          return_id = GuidFormat.return_parameter_xmi_id(@context.xmi_id_for(operation))
+          [%(\t\t\t\t\t\t<parameter xmi:idref="#{return_id}" visibility="public">),
+           %(\t\t\t\t\t\t\t<properties pos="0" type="#{escape(operation.type.to_s)}" const="false" ) +
+             %(ea_guid="#{GuidFormat.xmi_id_to_ea_guid(return_id)}"/>),
+           *RETURN_PARAMETER_TAIL,
+           "\t\t\t\t\t\t</parameter>"].join("\n")
         end
 
         def parameter_xml(param)
@@ -392,11 +439,16 @@ def connector_xml(conn)
           return nil unless source_obj && target_obj
 
           name_attr = conn.name ? %( name="#{escape(conn.name)}") : ""
-          inner = end_xml(source_obj, "source") + end_xml(target_obj, "target") + connector_body_xml(conn)
+          inner = end_xml(conn, source_obj, "source") + end_xml(conn, target_obj, "target") + connector_body_xml(conn)
           %(\t\t<connector xmi:idref="#{connector_id}"#{name_attr}>\n#{inner}\t\t</connector>)
         end
 
-        def end_xml(obj, kind)
+        END_XREF_TYPE = {
+          "source" => "connectorSrcEnd property",
+          "target" => "connectorDestEnd property"
+        }.freeze
+
+        def end_xml(conn, obj, kind)
           xmi_id = @context.xmi_id_for(obj)
           lines = [
             "\t\t\t<#{kind} xmi:idref=\"#{xmi_id}\">",
@@ -408,7 +460,7 @@ def end_xml(obj, kind)
             "\t\t\t\t<modifiers isOrdered=\"false\" changeable=\"none\" isNavigable=\"false\"/>",
             "\t\t\t\t<style value=\"Union=0;Derived=0;AllowDuplicates=0;Owned=0;Navigable=Unspecified;\"/>",
             "\t\t\t\t<documentation/>",
-            "\t\t\t\t<xrefs/>",
+            xrefs_xml("\t\t\t\t", conn.ea_guid, END_XREF_TYPE.fetch(kind)),
             "\t\t\t\t<tags/>",
             "\t\t\t</#{kind}>"
           ]
@@ -430,12 +482,72 @@ def connector_body_xml(conn)
               "seqno=\"0\" headStyle=\"0\" lineStyle=\"0\"/>",
             "\t\t\t<extendedProperties virtualInheritance=\"0\"/>",
             "\t\t\t<style/>",
-            "\t\t\t<xrefs/>",
+            xrefs_xml("\t\t\t", conn.ea_guid, "connector property"),
             "\t\t\t<tags/>"
           ]
           "#{lines.join("\n")}\n"
         end
 
+        # ---- <xrefs> ----------------------------------------------------
+
+        # EA renders t_xref rows as a $XREFPROP mini-language string in
+        # a single value attribute. Derived from the reference exports:
+        # token order $XID $NAM $TYP $VIS [$BEH] $PAR $DES $CLT [$SUP]
+        # $ENDXREF; — $BEH only when Behavior is non-blank. A blank
+        # Supplier renders as "<none>" except on "connector property"
+        # rows, where EA omits the token entirely. "diagram properties"
+        # rows are never rendered (reference diagrams keep <xrefs/>).
+        def xrefs_xml(indent, ea_guid, type)
+          rows = @database.xrefs_for_client(ea_guid.to_s)
+                          .select { |xref| xref.xref_type == type }
+          return "#{indent}<xrefs/>" if rows.empty?
+
+          value = rows.map { |xref| xref_value(xref) }.join
+          %(#{indent}<xrefs value="#{escape(value)}"/>)
+        end
+
+        def xref_value(xref)
+          head = "$XREFPROP=$XID=#{xref.xref_id}$XID;$NAM=#{xref.name}$NAM;" \
+                 "$TYP=#{xref.xref_type}$TYP;$VIS=#{xref.visibility}$VIS;"
+          beh = xref.behavior.to_s.empty? ? "" : "$BEH=#{xref.behavior}$BEH;"
+          tail = "$PAR=#{xref.partition}$PAR;$DES=#{xref.description}$DES;" \
+                 "$CLT=#{xref.client}$CLT;#{supplier_token(xref)}$ENDXREF;"
+          "#{head}#{beh}#{tail}"
+        end
+
+        def supplier_token(xref)
+          return "$SUP=#{xref.supplier}$SUP;" unless xref.supplier.to_s.empty?
+          return "" if xref.xref_type == "connector property"
+
+          "$SUP=<none>$SUP;"
+        end
+
+        # ---- <primitivetypes> section ----------------------------------
+
+        # EA nests every synthesized EAnone_ PrimitiveType definition
+        # under a fixed two-package hierarchy inside the Extension.
+        def build_primitivetypes_section
+          names = PrimitiveTypes.unresolved_names(@database)
+          return "" if names.empty?
+
+          ["\t\t<primitivetypes>",
+           primitive_package("\t\t\t", "EAPrimitiveTypesPackage", "EA_PrimitiveTypes_Package"),
+           primitive_package("\t\t\t\t", "EAnoneTypesPackage", "EA_none_Types_Package"),
+           *names.map { |name| primitive_definition(name) },
+           "\t\t\t\t</packagedElement>",
+           "\t\t\t</packagedElement>",
+           "\t\t</primitivetypes>"].join("\n")
+        end
+
+        def primitive_package(indent, id, name)
+          %(#{indent}<packagedElement xmi:type="uml:Package" xmi:id="#{id}" name="#{name}">)
+        end
+
+        def primitive_definition(name)
+          "\t\t\t\t\t<packagedElement xmi:type=\"uml:PrimitiveType\" " \
+            "xmi:id=\"#{escape(PrimitiveTypes.definition_id(name))}\" name=\"#{escape(name)}\"/>"
+        end
+
         # ---- <diagrams> section ----------------------------------------
 
         def build_diagrams_section
@@ -465,27 +577,76 @@ def diagram_xml(dgm)
           lines.join("\n")
         end
 
+        # EA emits object placements (t_diagramobjects, ordered by
+        # Sequence) followed by connector entries (t_diagramlinks).
+        # Derived from examples/exports/basic/model.xml:
+        #   placement: geometry="Left=..;Top=..;Right=..;Bottom=..;
+        #     imgL=..;imgT=..;imgR=..;imgB=..;" from the Rect* columns
+        #     (Top/Bottom sign-flipped; img* at fixed +25/+30 offsets),
+        #     seqno=Sequence, style=ObjectStyle verbatim.
+        #   connector: subject is the CONNECTOR's EAID, geometry is the
+        #     link's Geometry plus "Path=<path>;", style is the link's
+        #     Style plus "Hidden=<hidden>;".
         def diagram_elements_xml(dgm)
-          elements = (@database.collections[:diagram_links] || []).select do |dl|
-            dl.diagramid == dgm.diagram_id
-          end
-          return "\t\t\t<elements/>" if elements.empty?
-
-          inner = elements.filter_map { |dl| diagram_element_xml(dl) }.join("\n")
+          placements = @database.diagram_objects_for(dgm.diagram_id)
+                                .sort_by { |placement| placement_order(placement) }
+                                .filter_map { |placement| object_placement_xml(placement) }
+          links = @database.diagram_links_for(dgm.diagram_id)
+                           .filter_map { |link| connector_entry_xml(link) }
+          inner = (placements + links).join("\n")
           return "\t\t\t<elements/>" if inner.empty?
 
           "\t\t\t<elements>\n#{inner}\n\t\t\t</elements>"
         end
 
-        def diagram_element_xml(dl)
-          obj = @database.find_object(dl.instance_id)
+        IMG_OFFSET_X = 25
+        IMG_OFFSET_Y = 30
+
+        def object_placement_xml(placement)
+          obj = @database.find_object(placement.ea_object_id)
           return nil unless obj
 
-          subject = @context.xmi_id_for(obj)
-          geometry = dl.geometry.to_s
-          attrs = [%(subject="#{subject}")]
-          attrs << %(geometry="#{escape(geometry)}") unless geometry.empty?
-          "\t\t\t\t<element #{attrs.join(" ")}/>"
+          "\t\t\t\t<element geometry=\"#{placement_geometry(placement)}\" " \
+            "subject=\"#{escape(@context.xmi_id_for(obj).to_s)}\" " \
+            "seqno=\"#{placement.sequence.to_i}\" style=\"#{escape(placement.objectstyle.to_s)}\"/>"
+        end
+
+        # Sequence is nullable with DEFAULT 0 — nil sorts as 0, ties
+        # broken stably by instance id.
+        def placement_order(placement)
+          [placement.sequence.to_i, placement.instance_id.to_i]
+        end
+
+        # Rect columns are nullable with DEFAULT 0 — coerce nil to 0.
+        def placement_geometry(placement)
+          left = placement.rectleft.to_i
+          top = -placement.recttop.to_i
+          right = placement.rectright.to_i
+          bottom = -placement.rectbottom.to_i
+          "Left=#{left};Top=#{top};Right=#{right};Bottom=#{bottom};" \
+            "imgL=#{left + IMG_OFFSET_X};imgT=#{top + IMG_OFFSET_Y};" \
+            "imgR=#{right + IMG_OFFSET_X};imgB=#{bottom + IMG_OFFSET_Y};"
+        end
+
+        def connector_entry_xml(link)
+          conn = @database.find_connector(link.connectorid)
+          return nil unless conn
+
+          # EA rewrites the Path waypoints' ";" separators to "$" and
+          # terminates with one ";" (reference: Path=165:-230$371:-230$;).
+          geometry = "#{style_fragment(link.geometry)}Path=#{link.path.to_s.tr(";", "$")};"
+          style = "#{style_fragment(link.style)}Hidden=#{link.hidden};"
+          "\t\t\t\t<element geometry=\"#{escape(geometry)}\" " \
+            "subject=\"#{escape(@context.xmi_id_for(conn).to_s)}\" style=\"#{escape(style)}\"/>"
+        end
+
+        # Real rows (plateau model) can lack the trailing ";" — append
+        # exactly one so concatenated tokens never fuse.
+        def style_fragment(text)
+          value = text.to_s
+          return "" if value.empty?
+
+          value.end_with?(";") ? value : "#{value};"
         end
 
         # ---- helpers ----------------------------------------------------
diff --git a/lib/ea/transformers/qea_to_xmi/id_allocator.rb b/lib/ea/transformers/qea_to_xmi/id_allocator.rb
index 17c7acc..0fcf2fb 100644
--- a/lib/ea/transformers/qea_to_xmi/id_allocator.rb
+++ b/lib/ea/transformers/qea_to_xmi/id_allocator.rb
@@ -4,87 +4,88 @@ module Ea
   module Transformers
     module QeaToXmi
       # Allocates synthetic xmi:id values for elements that don't have a
-      # natural GUID-based one — e.g. literal `<lowerValue>` nodes, or
-      # `<ownedComment>` bodies synthesized from EA's Note objects.
+      # natural GUID-based one — literal `<lowerValue>`/`<upperValue>`
+      # bounds, instance slots and their values, return parameters.
       #
-      # Sparx's EAID format reserves prefixes like `LI` (LiteralInt),
-      # `SL` (Slot), `NL` (NameLabel), `DB` (DiagramBounds), `OE` (OpaqueExpr),
-      # `RT` (Return parameter) for these synthesized identifiers.
+      # EA's scheme, derived from examples/exports/*/model.xml:
       #
-      # Output shape: `EAID_<PREFIX><NNNNNN><GUID_TAIL>` where:
+      #   EAID_<PREFIX><NNNNNN><SEP><TAIL27>
       #
-      # - `EAID_` matches the prefix used by all other Sparx XMI element IDs.
-      # - `<PREFIX>` is a Sparx-reserved literal prefix (LI, SL, OE, ...).
-      # - `<NNNNNN>` is a 6-digit zero-padded counter, scoped to the
-      #   IdAllocator instance (one per `Transformer#serialize` call).
-      # - `<GUID_TAIL>` is the parent element's EA GUID normalised to
-      #   Sparx's wire form. The leading underscore from the opening
-      #   brace of `{GUID-...}` is preserved so the output matches
-      #   real Sparx XMI byte-for-byte (e.g. `EAID_LI000001__EEB1_...`).
-      #   When `parent_guid` is nil, no tail is emitted.
+      # - `<PREFIX>` is a Sparx-reserved literal prefix (LI, SL, OE, RT).
+      # - `<NNNNNN>` is a 6-digit zero-padded counter. LI counts GLOBALLY
+      #   from 1 in allocation order (lower before upper, destination end
+      #   before source end, document walk order across owners). SL, OE
+      #   and RT count from 0 PER OWNING ELEMENT (slots/values per
+      #   InstanceSpecification, return parameters per operation).
+      # - `<TAIL27>` is the owner ID's last 27 characters (the EA GUID
+      #   minus its first segment).
+      # - `<SEP>` is as many underscores as keep the synthesized ID the
+      #   same total width as the owner ID (one for 41-char EAID_ owners,
+      #   two for 42-char src/dst association-end owners).
       #
-      # The allocator is memoised by `seed`: same seed returns the same
-      # allocated ID. Different seeds get different counters.
+      # The allocator memoizes by [owner_id, prefix, seed]: the same
+      # triple always returns the same ID without advancing any counter.
+      #
+      # @api private — internal to the QeaToXmi transformer; its
+      # signature follows the transformer's needs, not semver.
       class IdAllocator
         # Well-known prefixes Sparx uses for synthesized IDs.
         LITERAL_INTEGER   = "LI"
         OPAQUE_EXPRESSION = "OE"
         SLOT              = "SL"
-        NAME_LABEL        = "NL"
-        DIAGRAM_BOUNDS    = "DB"
         RETURN_PARAMETER  = "RT"
 
-        # Leading-underscore-preserving normalisation: `{AB-CD}` → `_AB_CD`.
-        # Matches the wire form Sparx emits for parent-guid-suffixed IDs.
-        GUID_BRACE_OR_DASH = /[-{}]/
+        # Prefixes whose counter runs across the whole document, starting
+        # at 1. All other prefixes restart at 0 per owner.
+        GLOBAL_PREFIXES = [LITERAL_INTEGER].freeze
+
+        TAIL_LENGTH = 27
+        # "EAID_" plus the 8-character prefix+counter token.
+        HEAD_LENGTH = 13
 
         def initialize
-          @counter = 0
+          @global_counters = Hash.new(0)
+          @owner_counters = Hash.new(0)
           @assigned = {}
         end
 
-        # @param prefix [String] one of LITERAL_INTEGER, OPAQUE_EXPRESSION, ...
-        # @param seed [String, nil] stable seed for memoization (e.g. the
-        #   source record's object_id). Same seed returns same allocated id.
-        # @param parent_guid [String, nil] the owning element's EA GUID
-        #   (e.g. `{EEB1-...}`). When provided, the synthesised ID carries
-        #   the parent GUID tail so it is traceable and round-trip-safe.
+        # @param prefix [String] LITERAL_INTEGER, SLOT, OPAQUE_EXPRESSION
+        #   or RETURN_PARAMETER
+        # @param owner_id [String] the owning element's full xmi:id — its
+        #   last 27 characters become the tail and its width sets the
+        #   separator
+        # @param seed [String] stable memoization key within the owner
         # @return [String] e.g. "EAID_LI000001__EEB1_4de7_98F5_670D6EE4A52B"
-        def allocate(prefix:, seed: nil, parent_guid: nil)
-          return @assigned[seed] if seed && @assigned.key?(seed)
+        def allocate(prefix:, owner_id:, seed:)
+          key = [owner_id, prefix, seed]
+          return @assigned[key] if @assigned.key?(key)
 
-          @counter += 1
-          id = compose_id(prefix: prefix, n: @counter, parent_guid: parent_guid)
-          @assigned[seed] = id if seed
-          id
+          @assigned[key] = compose_id(prefix, next_counter(prefix, owner_id), owner_id)
         end
 
         private
 
-        def compose_id(prefix:, n:, parent_guid:)
-          tail = guid_tail(parent_guid)
-          if tail
-            # The format is `EAID_LI<NN>_<guid_tail>` where guid_tail
-            # preserves its leading underscore. Together with the
-            # separator `_` that yields the double-underscore form
-            # Sparx emits (`EAID_LI000001__EEB1_...`).
-            format("EAID_%<prefix>s%<n>06d_%<tail>s", prefix: prefix, n: n, tail: tail)
+        def next_counter(prefix, owner_id)
+          if GLOBAL_PREFIXES.include?(prefix)
+            @global_counters[prefix] += 1
           else
-            format("EAID_%<prefix>s%<n>06d", prefix: prefix, n: n)
+            n = @owner_counters[[prefix, owner_id]]
+            @owner_counters[[prefix, owner_id]] = n + 1
+            n
           end
         end
 
-        # Sparx preserves the leading underscore that comes from the
-        # opening brace of the EA GUID. Strip the closing-brace trailing
-        # underscore only.
-        #
-        # `{EEB1-4de7-98F5-670D6EE4A52B}` → `_EEB1_4de7_98F5_670D6EE4A52B`
-        def guid_tail(parent_guid)
-          return nil if parent_guid.nil? || parent_guid.empty?
+        def compose_id(prefix, counter, owner_id)
+          # QEA guid columns are nullable — an owner with no id (or one
+          # too short to carry a 27-char tail) gets a tailless,
+          # counter-only identifier.
+          return format("EAID_%<prefix>s%<n>06d", prefix: prefix, n: counter) if
+            owner_id.to_s.length < TAIL_LENGTH + HEAD_LENGTH
 
-          parent_guid
-            .gsub(GUID_BRACE_OR_DASH, "_")
-            .sub(/_\z/, "")
+          tail = owner_id[-TAIL_LENGTH..]
+          separator = "_" * (owner_id.length - TAIL_LENGTH - HEAD_LENGTH)
+          format("EAID_%<prefix>s%<n>06d%<sep>s%<tail>s",
+                 prefix: prefix, n: counter, sep: separator, tail: tail)
         end
       end
     end
diff --git a/lib/ea/transformers/qea_to_xmi/primitive_types.rb b/lib/ea/transformers/qea_to_xmi/primitive_types.rb
new file mode 100644
index 0000000..936c4dd
--- /dev/null
+++ b/lib/ea/transformers/qea_to_xmi/primitive_types.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Ea
+  module Transformers
+    module QeaToXmi
+      # Owns the `EAnone_` id shape and EA's <primitivetypes> Extension
+      # hierarchy: every distinct attribute/operation type name with a
+      # blank classifier becomes an `EAnone_<name>` PrimitiveType
+      # definition, in table first-use order (attributes then operations
+      # — verified to match the reference exports' ordering).
+      #
+      # `definition_id` is also what the transformer's type REFERENCES
+      # go through, so a reference and its definition normalize the name
+      # identically and cannot end up as two different ids.
+      #
+      # Names EA maps to OMG standard primitives are excluded on the
+      # attribute side only, and only when the classifier is blank, since
+      # that is the sole case where the attribute carries an href child
+      # instead of an idref.
+      #
+      # KNOWN GAP: a non-blank classifier that resolves to nothing (a
+      # numeric t_object id from a referenced model) still emits an
+      # `EAnone_` reference with no definition behind it. Defining those
+      # here over-emits instead: this scan walks every row in the
+      # database, including rows the package walk never exports, and EA's
+      # own plateau export defines nothing for them. Closing it means
+      # deriving definitions from the references the walk actually
+      # emitted, which is its own change.
+      module PrimitiveTypes
+        # EA primitive names that reference the OMG PrimitiveTypes
+        # library instead of a synthesized EAnone_ definition.
+        HREF_NAMES = { "int" => "Integer" }.freeze
+
+        OMG_PRIMITIVES = "http://www.omg.org/spec/UML/20110701/PrimitiveTypes.xmi"
+
+        module_function
+
+        # @param database [Ea::Qea::Database]
+        # @return [Array<String>] distinct unresolved type names, first-use order
+        def unresolved_names(database)
+          (attribute_names(database) + operation_names(database)).uniq
+        end
+
+        # An attribute reaches the OMG library through an href child only
+        # when it has no classifier to point at. One that names a
+        # classifier resolves against it instead, so it needs no
+        # definition here — see the KNOWN GAP above for the case where
+        # that classifier resolves to nothing.
+        def attribute_names(database)
+          database.attributes.filter_map do |attr|
+            next nil if href_for(attr.type, attr.classifier)
+
+            unresolved_name(attr.type, attr.classifier)
+          end
+        end
+
+        # Operation returns have no href mechanism — they reference
+        # EAnone_<name> directly, so every name they use must be
+        # defined here or the idref dangles.
+        def operation_names(database)
+          database.operations.filter_map { |op| unresolved_name(op.type, op.classifier) }
+        end
+
+        def unresolved_name(type, classifier)
+          name = normalize_name(type)
+          return nil if name.empty?
+          return nil unless blank_classifier?(classifier)
+
+          name
+        end
+
+        # The id EA gives a type name that has no classifier behind it.
+        # The reference and the definition both come from here, so they
+        # cannot normalize the name differently.
+        # @return [String] e.g. "EAnone_int"
+        def definition_id(type_name)
+          "EAnone_#{normalize_name(type_name)}"
+        end
+
+        # EA type columns are free text; leading/trailing space is not
+        # part of the name.
+        def normalize_name(type)
+          type.to_s.strip
+        end
+
+        # The OMG href replaces the EAnone_ idref only when there is no
+        # classifier to point at. Nil means "not an href target", so the
+        # definition side and the transformer read one expression rather
+        # than asking a predicate and then fetching what it proved.
+        # @return [String, nil] OMG href for EA primitive names, else nil
+        def href_for(type, classifier)
+          return nil unless blank_classifier?(classifier)
+
+          target = HREF_NAMES[normalize_name(type)]
+          target && "#{OMG_PRIMITIVES}##{target}"
+        end
+
+        def blank_classifier?(classifier)
+          text = normalize_name(classifier)
+          text.empty? || text == "0"
+        end
+      end
+    end
+  end
+end
diff --git a/lib/ea/transformers/qea_to_xmi/profile_serializer.rb b/lib/ea/transformers/qea_to_xmi/profile_serializer.rb
index 0f8c1f2..f84a1aa 100644
--- a/lib/ea/transformers/qea_to_xmi/profile_serializer.rb
+++ b/lib/ea/transformers/qea_to_xmi/profile_serializer.rb
@@ -32,18 +32,17 @@ def initialize(mdg_registry)
         # @return [Array<Xmi::Uml::PackagedElement>] stereotype and
         #   extension elements for all registered MDG documents.
         #   Empty array when no registry or no stereotypes.
+        #
+        # Stereotype ids are the bare names, so two MDGs defining the
+        # same name would emit clashing definitions. The first
+        # document to define a name wins.
         def call
           return [] unless @mdg_registry
-          return [] if @mdg_registry.documents.empty?
-
-          blocks = []
-          @mdg_registry.documents.each do |doc|
-            doc.stereotypes.each do |stereo|
-              blocks << build_stereotype(stereo)
-              blocks.concat(build_extensions(stereo))
-            end
-          end
-          blocks.compact
+
+          @mdg_registry.documents
+                       .flat_map(&:stereotypes)
+                       .uniq(&:name)
+                       .flat_map { |stereo| [build_stereotype(stereo), *build_extensions(stereo)] }
         end
 
         private
@@ -68,19 +67,18 @@ def build_extensions(stereotype)
           end
         end
 
+        # EA carries both ends as one space-separated memberEnd
+        # attribute on the Extension and repeats it on the
+        # ExtensionEnd — never as child <memberEnd> elements.
         def build_extension(stereotype, metaclass)
-          extension_id = "#{metaclass}_#{stereotype.name}"
           base_id = "#{stereotype.name}-base_#{metaclass}"
           member_ends = "extension_#{stereotype.name} #{base_id}"
 
           ::Xmi::Uml::PackagedElement.new(
             type: "uml:Extension",
-            id: extension_id,
+            id: "#{metaclass}_#{stereotype.name}",
             name: "A_#{metaclass}_#{stereotype.name}",
-            member_ends: [
-              ::Xmi::Uml::MemberEnd.new(idref: "extension_#{stereotype.name}"),
-              ::Xmi::Uml::MemberEnd.new(idref: base_id)
-            ],
+            member_end: member_ends,
             owned_end: [build_extension_end(stereotype, member_ends)]
           )
         end
@@ -90,7 +88,9 @@ def build_extension_end(stereotype, member_ends)
             type: "uml:ExtensionEnd",
             id: "extension_#{stereotype.name}",
             name: "extension_#{stereotype.name}",
-            association: member_ends
+            member_end: member_ends,
+            is_composite: true,
+            uml_type: ::Xmi::Uml::Type.new(idref: stereotype.name)
           )
         end
 
diff --git a/lib/ea/transformers/qea_to_xmi/run_state.rb b/lib/ea/transformers/qea_to_xmi/run_state.rb
index 95e279e..7145922 100644
--- a/lib/ea/transformers/qea_to_xmi/run_state.rb
+++ b/lib/ea/transformers/qea_to_xmi/run_state.rb
@@ -20,8 +20,9 @@ module QeaToXmi
       # `Variable` is the attribute name on the classifier (used to
       # resolve the definingFeature EAID at transformation time).
       # The `Value` plus `Op` form the OpaqueExpression body — Sparx
-      # prepends the operator character to the value (`Op==` →
-      # `body="=Value"`).
+      # prepends the stored operator verbatim. Equality is stored as
+      # `Op==;` (parsed op "="), so `body="=Value"`; comparison ops
+      # keep their full text (`Op=<=;` → `body="<=Value"`).
       #
       # The parser is pure: no I/O, no state. Same input always yields
       # the same output array of {Variable, Value, Op} structs.
@@ -32,15 +33,15 @@ module RunState
         # @!attribute value [String] the literal value text
         # @!attribute op [String] the operator character(s) EA stored
         Binding = Struct.new(:variable, :value, :op) do
-          # Sparx serialises the value with the operator character
-          # prepended (`Op==` → `body="=Value"`). For other operators
-          # (`!=`, `<`, `>`) the full operator string is prepended.
+          # Sparx serialises the value with the stored operator
+          # prepended verbatim ("=" for equality, "<=" etc. as-is —
+          # EA's reference exports contain body="<=valueTwo").
           #
           # @return [String] the body to set on the OpaqueExpression
           def body
             return value if op.nil? || op.empty?
 
-            "#{op[0]}#{value}"
+            "#{op}#{value}"
           end
         end
 
diff --git a/lib/ea/transformers/qea_to_xmi/transformer.rb b/lib/ea/transformers/qea_to_xmi/transformer.rb
index b5efced..48d95e6 100644
--- a/lib/ea/transformers/qea_to_xmi/transformer.rb
+++ b/lib/ea/transformers/qea_to_xmi/transformer.rb
@@ -56,13 +56,36 @@ class Transformer
           class:       ->(obj) { build_class(obj) },
           enumeration: ->(obj) { build_enumeration(obj) },
           data_type:   ->(obj) { build_data_type(obj) },
+          signal:      ->(obj) { build_class(obj, xmi_type: "uml:Signal") },
           instance:    ->(obj) { build_instance(obj) },
+          association_element: ->(obj) { build_association_element(obj) },
+        }.freeze
+
+        # What each builder in CLASSIFIER_BUILDERS actually emits, keyed
+        # by the same symbols. Every builder must appear here: a kind
+        # left out silently loses its attribute bounds or its nested
+        # children — wrong XML, no exception — so the spec asserts these
+        # keys match CLASSIFIER_BUILDERS exactly.
+        #
+        # `:owned_attribute` — the builder emits `<ownedAttribute>` and so
+        #   preallocates attribute bound IDs. Enumerations emit literals
+        #   (never bounds) and instances emit slots.
+        # `:nested_classifier` — the builder walks children, so a kind
+        #   listed here can adopt an object that carries a parentid.
+        #   `build_class` is the only builder that walks children.
+        CLASSIFIER_CAPABILITIES = {
+          class: %i[owned_attribute nested_classifier],
+          signal: %i[owned_attribute nested_classifier],
+          data_type: %i[owned_attribute],
+          enumeration: [],
+          instance: [],
+          association_element: []
         }.freeze
 
         def initialize(database, mdg_registry: nil)
           @database = database
           @mdg_registry = mdg_registry
-          @context  = Context.new(database: database)
+          @context = Context.new(database: database)
         end
 
         # @return [String] XMI XML document
@@ -86,9 +109,39 @@ def initialize(database, mdg_registry: nil)
         def serialize(with_extensions: true)
           xml = build_root.to_xml(use_prefix: true)
           xml = normalize_namespaces(xml)
+          xml = plain_parameter_type(xml)
           with_extensions ? inject_extension_content(xml) : xml
         end
 
+        # EA writes a return parameter's type unprefixed:
+        # `<ownedParameter … type="EAnone_void"/>`. Its reference export
+        # carries 12 of these and no `xmi:type` on ownedParameter at all.
+        #
+        # `xmi:type` is the XMI metaclass discriminator; `type` is the
+        # classifier reference. Two different attributes — but
+        # lutaml-model matches by local name and collapses them into one
+        # slot, so the xmi gem can only emit one of them. It keeps the
+        # namespaced form, which is right for general UML XMI, and
+        # rewriting that in the shared model would break round-tripping
+        # for every non-Sparx consumer. Restoring the reference EA
+        # actually writes is this exporter's job, so it happens here.
+        #
+        # Scoped to ownedParameter: no other element wants it. Walks
+        # complete name="value" pairs rather than scanning the tag as
+        # text — a parameter name is free text out of EA and may itself
+        # contain the literal `xmi:type=`, which a raw substitution
+        # would happily rewrite inside the quotes.
+        ATTRIBUTE_PAIR = /([A-Za-z_][\w:.-]*)=("[^"]*")/
+
+        def plain_parameter_type(xml)
+          xml.gsub(/<ownedParameter\b[^>]*?>/m) do |tag|
+            tag.gsub(ATTRIBUTE_PAIR) do
+              name = Regexp.last_match(1)
+              name == "xmi:type" ? %(type=#{Regexp.last_match(2)}) : Regexp.last_match(0)
+            end
+          end
+        end
+
         # EA's reference XMI uses the 2011-07-01 XMI/UML namespace URIs;
         # the xmi gem's Root model hard-codes 2013-10-01. Post-process
         # the serialized XML to match EA's namespace version. This is a
@@ -193,12 +246,128 @@ def package_children(pkg)
         end
 
         def subpackages(pkg)
-          sorted_by_position(@context.child_packages(pkg.package_id))
-            .map { |sub| build_package(sub) }
+          @context.sorted_by_position(@context.child_packages(pkg.package_id))
+                  .map { |sub| build_package(sub) }
         end
 
+        # EA emits a package's own classifiers first, then the children
+        # nobody adopted. The global LI counter follows that order.
         def classifier_objects(pkg)
-          classifiers_in(pkg).map { |obj| build_classifier(obj) }.compact
+          top_level, orphaned = package_level_classifiers(pkg)
+                                .partition { |obj| obj.parentid.to_i.zero? }
+          (top_level + orphaned).filter_map { |obj| build_classifier_with_bounds(obj) }
+        end
+
+        # Everything EA leaves at package level: an object stays here
+        # unless a classifier in the same package actually adopts it as
+        # a nestedClassifier. A child of an enumeration, of an
+        # instance, of a type we don't build, of a parent in another
+        # package, or of one that isn't there at all has no adopter.
+        #
+        # Adoption is decided from the package's own contents, never
+        # from what the walk has emitted so far — a child can sort
+        # before its own parent, and asking a set that the walk is
+        # still filling would emit that child twice.
+        def package_level_classifiers(pkg)
+          buildable_objects_in(pkg).reject { |obj| adopted?(obj) }
+        end
+
+        # A parent adopts a child only if it is a nesting kind in the
+        # same package AND the ParentID chain above the child actually
+        # terminates. A corrupt model can point an object at itself or
+        # round a cycle; leaving those adopted would drop them from the
+        # export, since the parent that owes them an emission is never
+        # reached. Shared with nested_classifiers_under so the two
+        # cannot disagree about who owns a child.
+        def adopted?(obj)
+          parent = nesting_parent_of(obj)
+          !parent.nil? && !cyclic_ancestry?(obj)
+        end
+
+        def nesting_parent_of(obj)
+          parent_id = obj.parentid.to_i
+          return nil unless parent_id.positive?
+
+          parent = @context.object_by_id(parent_id)
+          return nil unless parent && parent.package_id == obj.package_id
+          return nil unless nests_classifiers?(parent)
+
+          parent
+        end
+
+        def cyclic_ancestry?(obj)
+          seen = Set[obj.ea_object_id]
+          current = obj
+          while (current = nesting_parent_of(current))
+            return true unless seen.add?(current.ea_object_id)
+          end
+          false
+        end
+
+        # EA's class-centric LI allocation: attribute bounds first (name
+        # order), then the classifier itself, then the association-end
+        # bounds anchored here. The memoized allocator lets later
+        # builders reuse these IDs.
+        def build_classifier_with_bounds(obj)
+          preallocate_attribute_bounds(obj)
+          element = build_classifier(obj)
+          preallocate_end_bounds(obj)
+          element
+        end
+
+        # EA allocates a classifier's attribute LI bounds in attribute
+        # NAME order, while the document emits attributes in Pos order.
+        # Pre-allocating here (memoized) makes the later Pos-ordered
+        # build reuse the name-ordered counters. Only owners that go on
+        # to emit ownedAttribute take counters — an enumeration's
+        # literals never carry bounds.
+        def preallocate_attribute_bounds(obj)
+          return unless emits_attributes?(obj)
+
+          @context.attributes_for(obj.ea_object_id)
+                  .sort_by { |a| a.name.to_s }
+                  .each { |attr| build_attribute_bounds(attr) }
+        end
+
+        # Lower before upper — the global LI counter follows this order.
+        # @return [Array(Xmi::Uml::LowerValue, Xmi::Uml::UpperValue)]
+        def build_attribute_bounds(attr)
+          attr_id = @context.xmi_id_for(attr)
+          bounds = Cardinality.attribute_bounds(attr.lowerbound, attr.upperbound)
+          [build_lower_value(bounds[:lower],
+                             seed: "mult-attr-#{attr.id}-lower", owner_id: attr_id),
+           build_upper_value(bounds[:upper],
+                             seed: "mult-attr-#{attr.id}-upper", owner_id: attr_id)]
+        end
+
+        # EA's global LI counter is allocated class-centrically, not in
+        # document order: after a classifier's attribute bounds come the
+        # association-end bounds whose OPPOSITE endpoint is that
+        # classifier (dst ends of connectors starting here, src ends of
+        # connectors ending here). The memoized allocator lets the
+        # Association element reuse these IDs when it is built later.
+        def preallocate_end_bounds(obj)
+          association_ends_anchored_at(obj)
+            .each { |conn, side| build_association_end(conn, side: side) }
+        end
+
+        # The ends anchored at a classifier, ordered by connector GUID
+        # (ascending string order — the only key that fits every tied
+        # case in the reference exports; names, connector ids and
+        # opposite-endpoint ids all contradict at least one).
+        def association_ends_anchored_at(obj)
+          @context.connectors_for(obj.ea_object_id)
+                  .flat_map { |conn| anchored_end_sides(conn, obj.ea_object_id) }
+                  .sort_by { |conn, side| [conn.ea_guid.to_s, side == :destination ? 0 : 1] }
+        end
+
+        def anchored_end_sides(conn, object_id)
+          return [] unless RELATIONSHIP_AT_PACKAGE_LEVEL[conn.connector_type] == :association
+
+          pairs = []
+          pairs << [conn, :destination] if conn.start_object_id == object_id
+          pairs << [conn, :source] if conn.end_object_id == object_id
+          pairs
         end
 
         # Connectors owned by this package: connectors whose start_object is
@@ -207,7 +376,7 @@ def classifier_objects(pkg)
         # Realization are emitted inside the classifier itself.
         def package_level_relationships(pkg)
           emitted = Set.new
-          classifiers_in(pkg).flat_map do |obj|
+          relationship_sources_in(pkg).flat_map do |obj|
             @context.connectors_starting_at(obj.ea_object_id).filter_map do |conn|
               key = RELATIONSHIP_AT_PACKAGE_LEVEL[conn.connector_type]
               next nil unless key
@@ -218,6 +387,13 @@ def package_level_relationships(pkg)
           end
         end
 
+        # Relationship discovery must also see Package objects —
+        # package-to-package Dependency connectors hang off them even
+        # though they never emit as classifiers.
+        def relationship_sources_in(pkg)
+          @context.objects_in_package(pkg.package_id).reject { |o| note?(o) }
+        end
+
         def build_package_relationship(kind, conn)
           case kind
           when :association then build_association(conn)
@@ -232,16 +408,29 @@ def package_comments(pkg)
         # ---- Classifier dispatch (OCP registry) --------------------------
 
         def build_classifier(obj)
-          kind = obj.transformer_type || obj.object_type&.downcase&.to_sym
-          builder = CLASSIFIER_BUILDERS[kind]
+          builder = CLASSIFIER_BUILDERS[obj.transformer_type]
           return nil unless builder
 
           instance_exec(obj, &builder)
         end
 
-        def build_class(obj)
+        # Objects that build no classifier at all (a Component parent, a
+        # Note) reach these predicates too, and answer no to both.
+        def capabilities_of(obj)
+          CLASSIFIER_CAPABILITIES.fetch(obj.transformer_type, [])
+        end
+
+        def emits_attributes?(obj)
+          capabilities_of(obj).include?(:owned_attribute)
+        end
+
+        def nests_classifiers?(obj)
+          capabilities_of(obj).include?(:nested_classifier)
+        end
+
+        def build_class(obj, xmi_type: nil)
           ::Xmi::Uml::PackagedElement.new(
-            type: class_xmi_type(obj),
+            type: xmi_type || class_xmi_type(obj),
             id: @context.xmi_id_for(obj),
             name: obj.name,
             visibility: Visibility.from_scope(obj.scope),
@@ -250,9 +439,16 @@ def build_class(obj)
             interface_realization: interface_realizations_for(obj),
             owned_attribute: attributes_for(obj),
             owned_operation: operations_for(obj),
+            nested_classifier: nested_children_for(obj),
           )
         end
 
+        # Recursive: nested children carry their own nested children,
+        # walked with the same class-centric bound preallocation.
+        def nested_children_for(obj)
+          nested_classifiers_under(obj).filter_map { |child| build_classifier_with_bounds(child) }
+        end
+
         def build_enumeration(obj)
           ::Xmi::Uml::PackagedElement.new(
             type: "uml:Enumeration",
@@ -285,6 +481,15 @@ def build_instance(obj)
           )
         end
 
+        # EA stores some associations as t_object rows. Its export
+        # emits them bare — id and name only, no ownedEnds and no
+        # visibility. The connector-backed associations
+        # (build_association) are a separate path.
+        def build_association_element(obj)
+          ::Xmi::Uml::PackagedElement.new(type: "uml:Association", id: @context.xmi_id_for(obj),
+                                          name: obj.name)
+        end
+
         def build_comment(obj)
           ::Xmi::Uml::OwnedComment.new(
             type: "uml:Comment",
@@ -306,28 +511,31 @@ def generalizations_for(obj)
         # rather than as package-level `<packagedElement type=
         # "uml:Realization">`. We do the same.
         def interface_realizations_for(obj)
-          realization_connectors(obj).map { |conn| build_interface_realization(conn) }
+          realization_connectors(obj).filter_map { |conn| build_interface_realization(conn) }
         end
 
         def attributes_for(obj)
-          sorted_by_position(@context.attributes_for(obj.ea_object_id))
-            .map { |attr| build_attribute(attr) }
+          @context.sorted_by_position(@context.attributes_for(obj.ea_object_id))
+                  .map { |attr| build_attribute(attr) }
         end
 
         def operations_for(obj)
-          sorted_by_position(@context.operations_for(obj.ea_object_id))
-            .map { |op| build_operation(op) }
+          @context.sorted_by_position(@context.operations_for(obj.ea_object_id))
+                  .map { |op| build_operation(op) }
         end
 
         def enum_literals(obj)
-          sorted_by_position(@context.attributes_for(obj.ea_object_id))
-            .map { |attr| build_owned_literal(attr) }
+          @context.sorted_by_position(@context.attributes_for(obj.ea_object_id))
+                  .map { |attr| build_owned_literal(attr) }
         end
 
         # ---- Leaf element builders --------------------------------------
 
         def build_attribute(attr)
-          parent_guid = parent_guid_for_attribute(attr)
+          # An attribute always carries both bounds; association ends
+          # check their single card field instead and stay bare when it
+          # is blank.
+          lower, upper = build_attribute_bounds(attr)
           ::Xmi::Uml::OwnedAttribute.new(
             type: "uml:Property",
             id: @context.xmi_id_for(attr),
@@ -337,8 +545,8 @@ def build_attribute(attr)
             is_ordered: Visibility.boolean_from_flag(attr.isordered),
             is_derived: Visibility.boolean_from_flag(attr.derived),
             uml_type: type_reference_model(attr.type, attr.classifier),
-            upper_value: build_upper_value(attr.upperbound, seed: "mult-attr-#{attr.id}-upper", parent_guid: parent_guid),
-            lower_value: build_lower_value(attr.lowerbound, seed: "mult-attr-#{attr.id}-lower", parent_guid: parent_guid),
+            upper_value: upper,
+            lower_value: lower,
           )
         end
 
@@ -375,30 +583,43 @@ def build_generalization(conn)
         end
 
         def build_interface_realization(conn)
+          client = @context.object_by_id(conn.start_object_id)
           supplier = @context.object_by_id(conn.end_object_id)
+          return nil unless client && supplier
+
+          supplier_ref = @context.xmi_id_for(supplier)
           ::Xmi::Uml::InterfaceRealization.new(
-            type: "uml:InterfaceRealization",
-            id: @context.xmi_id_for(conn),
-            name: conn.name,
-            client: @context.xmi_id_for(conn.start_object_id),
-            supplier: supplier ? @context.xmi_id_for(supplier) : nil,
-            contract: supplier ? @context.xmi_id_for(supplier) : nil,
+            type: "uml:InterfaceRealization", id: @context.xmi_id_for(conn),
+            name: conn.name, client: @context.xmi_id_for(client),
+            supplier: supplier_ref, contract: supplier_ref
           )
         end
 
         def build_dependency(conn)
-          client = @context.object_by_id(conn.start_object_id)
-          supplier = @context.object_by_id(conn.end_object_id)
+          client = dependency_endpoint_ref(conn.start_object_id)
+          supplier = dependency_endpoint_ref(conn.end_object_id)
           return nil unless client && supplier
 
           ::Xmi::Uml::PackagedElement.new(
             type: "uml:Dependency",
             id: @context.xmi_id_for(conn),
-            client: @context.xmi_id_for(client),
-            supplier: @context.xmi_id_for(supplier),
+            client: client,
+            supplier: supplier,
           )
         end
 
+        # Package-object endpoints resolve to their t_package via PDATA1
+        # and reference it as EAPK_ (matching EA); everything else keeps
+        # its own EAID_ reference.
+        def dependency_endpoint_ref(object_id)
+          obj = @context.object_by_id(object_id)
+          return nil unless obj
+          return @context.xmi_id_for(obj) unless package_object?(obj)
+
+          pkg = @database.find_package(obj.pdata1.to_i)
+          pkg && @context.xmi_id_for(pkg, prefix: "EAPK")
+        end
+
         # Sparx serialisation order for `uml:Association` is
         # destination member-end first, source member-end second.
         # Reordering these breaks round-trip fidelity with Sparx EA
@@ -426,8 +647,18 @@ def build_association_end(conn, side:)
           target_id = side == :source ? conn.start_object_id : conn.end_object_id
           target_obj = @context.object_by_id(target_id)
           target_ref = target_obj ? @context.xmi_id_for(target_obj) : nil
-          bounds = Cardinality.parse(cardinality_for(conn, side))
           containment = containment_for(conn, side)
+          # EA emits lower/upper only when the end's cardinality is set —
+          # a blank card gets a bare ownedEnd. Allocation order is lower
+          # before upper, with the END's id (EAID_dst…/EAID_src…) as the
+          # tail source.
+          raw_card = cardinality_for(conn, side)
+          lower = upper = nil
+          unless raw_card.to_s.strip.empty?
+            bounds = Cardinality.parse(raw_card)
+            lower = build_lower_value(bounds[:lower], seed: "mult-#{conn.connector_id}-#{side}-lower", owner_id: end_id)
+            upper = build_upper_value(bounds[:upper], seed: "mult-#{conn.connector_id}-#{side}-upper", owner_id: end_id)
+          end
 
           model = ::Xmi::Uml::OwnedEnd.new(
             type: "uml:Property",
@@ -437,8 +668,8 @@ def build_association_end(conn, side:)
             aggregation: Visibility.aggregation_from_containment(containment),
             association: @context.xmi_id_for(conn),
             uml_type: target_ref ? ::Xmi::Uml::Type.new(idref: target_ref) : nil,
-            upper_value: build_upper_value(bounds[:upper], seed: "mult-#{conn.connector_id}-#{side}-upper", parent_guid: conn.ea_guid),
-            lower_value: build_lower_value(bounds[:lower], seed: "mult-#{conn.connector_id}-#{side}-lower", parent_guid: conn.ea_guid),
+            upper_value: upper,
+            lower_value: lower,
           )
 
           AssociationEnd.new(end_id, model)
@@ -446,28 +677,28 @@ def build_association_end(conn, side:)
 
         # ---- Multiplicity helpers ---------------------------------------
 
-        # Always emit both bounds — UML defaults (lower=0, upper=-1) are
-        # used when the EA field is blank. Matches real Sparx XMI, which
-        # never omits `<upperValue>`/`<lowerValue>` on a Property.
-        def build_upper_value(raw, seed:, parent_guid:)
+        # Callers emit bounds only when the EA cardinality field is set —
+        # EA's reference exports omit `<upperValue>`/`<lowerValue>`
+        # entirely on ends whose card is blank.
+        def build_upper_value(raw, seed:, owner_id:)
           ::Xmi::Uml::UpperValue.new(
             type: "uml:LiteralUnlimitedNatural",
             id: @context.id_allocator.allocate(
               prefix: IdAllocator::LITERAL_INTEGER,
               seed: seed,
-              parent_guid: parent_guid,
+              owner_id: owner_id,
             ),
             value: Cardinality.normalize_upper(raw),
           )
         end
 
-        def build_lower_value(raw, seed:, parent_guid:)
+        def build_lower_value(raw, seed:, owner_id:)
           ::Xmi::Uml::LowerValue.new(
             type: "uml:LiteralInteger",
             id: @context.id_allocator.allocate(
               prefix: IdAllocator::LITERAL_INTEGER,
               seed: seed,
-              parent_guid: parent_guid,
+              owner_id: owner_id,
             ),
             value: Cardinality.normalize_lower(raw),
           )
@@ -476,13 +707,26 @@ def build_lower_value(raw, seed:, parent_guid:)
         # ---- Operation parameters ---------------------------------------
 
         def operation_parameters(op)
-          params = sorted_by_position(@context.params_for_operation(op.operationid))
+          params = @context.params_for_operation(op.operationid)
             .reject(&:return?)
             .map { |p| build_owned_parameter(p) }
-          params << build_return_parameter(op) if op.type && !op.type.empty?
+          params << build_return_parameter(op) if synthesized_return?(op)
           params
         end
 
+        # An untyped operation has no return to describe. One with no
+        # usable GUID has nothing to anchor the RT id's tail on, and the
+        # extension block skips it for the same reason — emitting it
+        # here would leave the two describing different operations.
+        # Type is blank-checked the way PrimitiveTypes normalizes names,
+        # so a whitespace-only Type cannot synthesize a return that
+        # primitive discovery then treats as absent.
+        def synthesized_return?(op)
+          return false if PrimitiveTypes.normalize_name(op.type).empty?
+
+          @context.identifiable?(op)
+        end
+
         def build_owned_parameter(param)
           ::Xmi::Uml::OwnedParameter.new(
             id: @context.xmi_id_for(param),
@@ -496,10 +740,11 @@ def build_return_parameter(op)
             id: @context.id_allocator.allocate(
               prefix: IdAllocator::RETURN_PARAMETER,
               seed: "return-#{op.operationid}",
-              parent_guid: op.ea_guid,
+              owner_id: @context.xmi_id_for(op),
             ),
             name: "return",
             direction: "return",
+            type: type_reference(op.type, op.classifier),
           )
         end
 
@@ -536,15 +781,32 @@ def inheritance_connectors(obj, type)
         end
 
         # Realization connectors owned by this class — those where
-        # this object is the source (client) and the connector type
-        # is Realization. Each emits an `<interfaceRealization>`.
+        # this object is the source (client). Each emits an
+        # `<interfaceRealization>`. Matched via the model predicate so
+        # both EA spellings (Realization/Realisation) are recognized.
         def realization_connectors(obj)
-          inheritance_connectors(obj, "Realization")
+          @context.connectors_for(obj.ea_object_id).select do |conn|
+            conn.start_object_id == obj.ea_object_id && conn.realization?
+          end
         end
 
-        def classifiers_in(pkg)
+        # EA walks classifiers in tree-position order (t_object.TPos,
+        # ties broken by name then object id), not insertion order.
+        # The global LI counter depends on it.
+        def buildable_objects_in(pkg)
           @context.objects_in_package(pkg.package_id)
                   .reject { |o| note?(o) || package_object?(o) }
+                  .sort_by { |o| [o.sort_position, o.name.to_s, o.ea_object_id] }
+        end
+
+        # Children nested under a classifier via t_object.ParentID.
+        # Level-1 order in EA's reference is descending object id;
+        # deeper levels don't match any column we've found — the LI
+        # counters inside deep nests may drift until that's derived.
+        def nested_classifiers_under(obj)
+          @context.objects_in_package(obj.package_id)
+                  .select { |o| o.parentid.to_i == obj.ea_object_id && adopted?(o) }
+                  .sort_by { |o| [o.sort_position, -o.ea_object_id] }
         end
 
         def notes_in(pkg)
@@ -559,27 +821,39 @@ def package_object?(obj)
           obj.object_type == "Package"
         end
 
-        def sorted_by_position(records)
-          records.sort_by { |r| [r.sort_position, r.name.to_s] }
-        end
-
         def primitive?(obj)
           obj.object_type == "PrimitiveType" ||
             (obj.gentype == "Java" && obj.stereotype_is?("primitive"))
         end
 
-        def type_reference(type_name, classifier_guid)
-          return nil if type_name.nil? || type_name.empty?
+        # The fallback id comes from the same module that emits the
+        # <primitivetypes> definitions, so the two normalize the name
+        # identically. A name that is blank once stripped gets no
+        # reference at all — PrimitiveTypes defines nothing for it.
+        def type_reference(type_name, classifier)
+          return nil if PrimitiveTypes.normalize_name(type_name).empty?
 
-          if classifier_guid
-            GuidFormat.ea_guid_to_xmi_id(classifier_guid)
-          else
-            "EAnone_#{type_name}"
-          end
+          classifier_ref(classifier) || PrimitiveTypes.definition_id(type_name)
         end
 
-        def type_reference_model(type_name, classifier_guid)
-          ref = type_reference(type_name, classifier_guid)
+        # QEA stores t_attribute.Classifier / t_operation.Classifier as
+        # an INTEGER t_object id ("0" = unresolved); EAP-era data can
+        # carry a GUID instead. Resolve either to the object's xmi id.
+        def classifier_ref(classifier)
+          text = PrimitiveTypes.normalize_name(classifier)
+          return nil if PrimitiveTypes.blank_classifier?(text)
+          return GuidFormat.ea_guid_to_xmi_id(text) unless text.match?(/\A\d+\z/)
+
+          obj = @context.object_by_id(text.to_i)
+          obj && @context.xmi_id_for(obj)
+        end
+
+        def type_reference_model(type_name, classifier)
+          if (href = PrimitiveTypes.href_for(type_name, classifier))
+            return ::Xmi::Uml::Type.new(href: href)
+          end
+
+          ref = type_reference(type_name, classifier)
           ref ? ::Xmi::Uml::Type.new(idref: ref) : nil
         end
 
@@ -603,14 +877,6 @@ def visibility_for_end(_conn, _side)
           nil
         end
 
-        # The owning element for an attribute's synthesised IDs is the
-        # attribute's classifier (parent object), not the attribute
-        # itself — Sparx encodes the parent class GUID in the suffix.
-        def parent_guid_for_attribute(attr)
-          parent = @context.object_by_id(attr.ea_object_id)
-          parent&.ea_guid
-        end
-
         # InstanceSpecification classifier reference. EA stores this
         # directly in t_object.classifier as the classifier's
         # ea_object_id (NOT pdata1, which is a separate column used
@@ -655,7 +921,7 @@ def slot_id_for(instance, binding)
           @context.id_allocator.allocate(
             prefix: IdAllocator::SLOT,
             seed: "slot-#{instance.ea_object_id}-#{binding.variable}",
-            parent_guid: instance.ea_guid,
+            owner_id: @context.xmi_id_for(instance),
           )
         end
 
@@ -663,7 +929,7 @@ def opaque_expression_id_for(instance, binding)
           @context.id_allocator.allocate(
             prefix: IdAllocator::OPAQUE_EXPRESSION,
             seed: "oe-#{instance.ea_object_id}-#{binding.variable}",
-            parent_guid: instance.ea_guid,
+            owner_id: @context.xmi_id_for(instance),
           )
         end
 
diff --git a/lib/ea/transformers/qea_to_xmi/visibility.rb b/lib/ea/transformers/qea_to_xmi/visibility.rb
index 4af076f..337cd29 100644
--- a/lib/ea/transformers/qea_to_xmi/visibility.rb
+++ b/lib/ea/transformers/qea_to_xmi/visibility.rb
@@ -3,19 +3,16 @@
 module Ea
   module Transformers
     module QeaToXmi
-      # Pure-function mapper from EA's integer scope/containment codes
-      # to UML visibility / aggregation wire strings.
+      # Pure-function mapper from EA's scope/aggregation codes to UML
+      # visibility / aggregation wire strings.
       #
-      # EA stores visibility as an integer in `t_attribute.scope`,
-      # `t_operation.scope`, `t_object.scope`. The encoding:
+      # QEA databases store scope as text in `t_attribute.Scope`,
+      # `t_operation.Scope`, `t_object.Scope`: "Public", "Private",
+      # "Protected", "Package". The integer codes (0-3, same order) are
+      # kept as a fallback for EAP-era databases.
       #
-      #   0 → Public
-      #   1 → Private
-      #   2 → Protected
-      #   3 → Package
-      #
-      # EA stores aggregation kind in `t_connector.sourcecontainment`
-      # and `t_connector.destcontainment`. The encoding:
+      # Aggregation kind comes from `t_connector.sourceisaggregate` /
+      # `destisaggregate` (via Transformer#containment_for). The encoding:
       #
       #   0 → None (omitted)
       #   1 → Shared (UML aggregation="shared")
@@ -23,6 +20,13 @@ module QeaToXmi
       #
       # Wire-side values are lower-case per the UML XMI schema.
       module Visibility
+        TEXT_SCOPES = {
+          "public" => "public",
+          "private" => "private",
+          "protected" => "protected",
+          "package" => "package",
+        }.freeze
+
         SCOPE_MAP = {
           0 => "public",
           1 => "private",
@@ -44,9 +48,10 @@ module Visibility
         #   so the xmi gem omits the attribute — matching EA's output,
         #   which doesn't emit visibility="public".
         def from_scope(raw)
-          return nil if raw.nil? || raw.to_s.strip.empty?
+          text = raw.to_s.strip
+          return nil if text.empty?
 
-          value = SCOPE_MAP[raw.to_i]
+          value = TEXT_SCOPES[text.downcase] || SCOPE_MAP[text.to_i]
           return nil if value == "public"
 
           value
diff --git a/lib/ea/xmi_guard.rb b/lib/ea/xmi_guard.rb
new file mode 100644
index 0000000..0d0d2c4
--- /dev/null
+++ b/lib/ea/xmi_guard.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "xmi"
+
+module Ea
+  # Boot-time guard against silently-incompatible xmi versions.
+  #
+  # The QEA-to-XMI transformer depends on xmi features that are not in
+  # any released xmi gem yet (`nested_classifier` on
+  # Xmi::Uml::PackagedElement, added by lutaml/xmi#94). The gemspec can
+  # only declare `xmi >= 0.6.2` until xmi 0.7.0 ships, so a consumer
+  # resolving a released xmi would otherwise get SILENT data loss:
+  # nested classes are simply dropped from the output.
+  #
+  # This guard turns that silent loss into a hard, actionable error at
+  # require time. Delete it (and tighten the gemspec to `~> 0.7`) once
+  # xmi 0.7.0 is released.
+  module XmiGuard
+    REQUIRED_FEATURE = :nested_classifier
+
+    module_function
+
+    # @raise [Ea::Error] when the loaded xmi gem lacks nestedClassifier
+    #   support
+    def verify!(feature_present: supported?)
+      return if feature_present
+
+      raise Ea::Error,
+            "ea requires an xmi version with nestedClassifier support " \
+            "(>= 0.7.0); the loaded xmi gem " \
+            "(#{defined?(::Xmi::VERSION) ? ::Xmi::VERSION : "unknown version"}) " \
+            "does not define Xmi::Uml::PackagedElement##{REQUIRED_FEATURE}. " \
+            "Update the xmi gem (until 0.7.0 is released, use the " \
+            "lutaml/xmi feat/nested-classifier-mapping branch)."
+    end
+
+    # @return [Boolean] whether the loaded xmi gem exposes the feature
+    def supported?
+      ::Xmi::Uml::PackagedElement.method_defined?(REQUIRED_FEATURE)
+    end
+  end
+end
+
+Ea::XmiGuard.verify!
diff --git a/spec/ea/cli/command/export_spec.rb b/spec/ea/cli/command/export_spec.rb
new file mode 100644
index 0000000..eaa0286
--- /dev/null
+++ b/spec/ea/cli/command/export_spec.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "ea/cli"
+require "tmpdir"
+
+RSpec.describe Ea::Cli::Command::Export do
+  let(:qea_path) { fixtures_path("basic.qea") }
+  let(:output_path) { File.join(Dir.mktmpdir, "out.xmi") }
+
+  after { FileUtils.rm_rf(File.dirname(output_path)) }
+
+  it "emits MDG stereotype definitions when --mdg is given" do
+    capture_stdout do
+      described_class.new(
+        sub: "xmi", file: qea_path, output: output_path,
+        mdg: [fixtures_path("mdg/CityGML_MDG_Technology.xml")]
+      ).call
+    end
+    xml = File.read(output_path)
+    expect(xml).to include("uml:Stereotype")
+    expect(xml).to include(%(memberEnd="extension_))
+    expect(xml).not_to include(%(<memberEnd xmi:idref="extension_))
+  end
+
+  it "emits no stereotype definitions without --mdg" do
+    capture_stdout do
+      described_class.new(sub: "xmi", file: qea_path, output: output_path).call
+    end
+    expect(File.read(output_path)).not_to include("uml:Stereotype")
+  end
+
+  it "ignores --mdg for non-xmi formats" do
+    json_path = output_path.sub(".xmi", ".json")
+    capture_stdout do
+      described_class.new(
+        sub: "json", file: qea_path, output: json_path,
+        mdg: [fixtures_path("mdg/CityGML_MDG_Technology.xml")]
+      ).call
+    end
+    expect(JSON.parse(File.read(json_path))).to be_a(Hash)
+  end
+end
diff --git a/spec/ea/mdg/registry_from_paths_spec.rb b/spec/ea/mdg/registry_from_paths_spec.rb
new file mode 100644
index 0000000..793ee1c
--- /dev/null
+++ b/spec/ea/mdg/registry_from_paths_spec.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "ea/mdg"
+
+RSpec.describe Ea::Mdg::Registry do
+  describe ".from_paths" do
+    let(:mdg_file) { fixtures_path("mdg/CityGML_MDG_Technology.xml") }
+
+    # Registration also lands in Lutaml::Model::GlobalRegister — sweep
+    # it so examples stay order-independent.
+    def with_registry(paths)
+      registry = described_class.from_paths(paths)
+      yield registry
+    ensure
+      registry&.documents&.map(&:technology_name)&.each { |name| registry.unregister(name) }
+    end
+
+    it "registers each loadable MDG file" do
+      with_registry([mdg_file]) do |registry|
+        expect(registry.documents.size).to eq(1)
+      end
+    end
+
+    it "expands directories recursively" do
+      with_registry([File.dirname(mdg_file)]) do |registry|
+        expect(registry.documents.size).to be >= 1
+      end
+    end
+
+    it "skips unloadable paths without raising" do
+      with_registry(["/nonexistent/mdg.xml"]) do |registry|
+        expect(registry.documents).to be_empty
+      end
+    end
+  end
+end
diff --git a/spec/ea/qea/models/ea_connector_spec.rb b/spec/ea/qea/models/ea_connector_spec.rb
index 7b3795e..1e95a9b 100644
--- a/spec/ea/qea/models/ea_connector_spec.rb
+++ b/spec/ea/qea/models/ea_connector_spec.rb
@@ -108,7 +108,12 @@
       expect(conn).to be_realization
     end
 
-    it "returns false when connector_type is not 'Realization'" do
+    it "recognizes the UK spelling EA databases use" do
+      conn = described_class.new(connector_type: "Realisation")
+      expect(conn).to be_realization
+    end
+
+    it "returns false for unrelated connector types" do
       conn = described_class.new(connector_type: "Association")
       expect(conn).not_to be_realization
     end
diff --git a/spec/ea/qea/models/ea_xref_spec.rb b/spec/ea/qea/models/ea_xref_spec.rb
index 74662e0..c33b1fa 100644
--- a/spec/ea/qea/models/ea_xref_spec.rb
+++ b/spec/ea/qea/models/ea_xref_spec.rb
@@ -235,4 +235,16 @@
       expect(described_class).to be < Ea::Qea::Models::BaseModel
     end
   end
+
+  describe "column mapping" do
+    it "maps the Visibility, Behavior and Partition columns" do
+      xref = described_class.from_db_row(
+        "XrefID" => "{X}", "Visibility" => "Public",
+        "Behavior" => "signal", "Partition" => "0"
+      )
+      expect(xref.visibility).to eq("Public")
+      expect(xref.behavior).to eq("signal")
+      expect(xref.partition).to eq("0")
+    end
+  end
 end
diff --git a/spec/ea/qea/repositories/base_repository_spec.rb b/spec/ea/qea/repositories/base_repository_spec.rb
index ad762b7..e0acc6d 100644
--- a/spec/ea/qea/repositories/base_repository_spec.rb
+++ b/spec/ea/qea/repositories/base_repository_spec.rb
@@ -59,6 +59,18 @@
       result = repository.find(999)
       expect(result).to be_nil
     end
+
+    it "returns the first record when a primary key is duplicated" do
+      # find and find_by_key must not disagree about which record
+      # answers for a duplicated key.
+      duplicate = Ea::Qea::Models::EaObject.new(
+        ea_object_id: 1, name: "Shadow", object_type: "Class",
+        visibility: "Public",
+      )
+      repo = described_class.new([object1, duplicate])
+      expect(repo.find(1)).to eq(repo.find_by_key(:ea_object_id, 1))
+      expect(repo.find(1).name).to eq("ClassA")
+    end
   end
 
   describe "#where" do
diff --git a/spec/ea/transformers/qea_to_xmi/cardinality_spec.rb b/spec/ea/transformers/qea_to_xmi/cardinality_spec.rb
index 7463454..64a941d 100644
--- a/spec/ea/transformers/qea_to_xmi/cardinality_spec.rb
+++ b/spec/ea/transformers/qea_to_xmi/cardinality_spec.rb
@@ -6,15 +6,15 @@
 RSpec.describe Ea::Transformers::QeaToXmi::Cardinality do
   describe ".parse" do
     it "returns UML defaults for nil" do
-      expect(described_class.parse(nil)).to eq(lower: "0", upper: "-1")
+      expect(described_class.parse(nil)).to eq(lower: "0", upper: "*")
     end
 
     it "returns UML defaults for empty string" do
-      expect(described_class.parse("")).to eq(lower: "0", upper: "-1")
+      expect(described_class.parse("")).to eq(lower: "0", upper: "*")
     end
 
     it "returns UML defaults for whitespace-only string" do
-      expect(described_class.parse("   ")).to eq(lower: "0", upper: "-1")
+      expect(described_class.parse("   ")).to eq(lower: "0", upper: "*")
     end
 
     it "treats a single integer as both lower and upper" do
@@ -26,61 +26,86 @@
     end
 
     it "parses a 1..* range" do
-      expect(described_class.parse("1..*")).to eq(lower: "1", upper: "-1")
+      expect(described_class.parse("1..*")).to eq(lower: "1", upper: "*")
     end
 
     it "parses a 0..* range" do
-      expect(described_class.parse("0..*")).to eq(lower: "0", upper: "-1")
+      expect(described_class.parse("0..*")).to eq(lower: "0", upper: "*")
     end
 
     it "treats a bare '*' as 0..-1 (many, lower unspecified)" do
       # Bare * means "many" — lower bound defaults to 0 (UML
       # unspecified), upper is unlimited. Returning lower=-1 would be
       # invalid: LiteralInteger cannot hold -1.
-      expect(described_class.parse("*")).to eq(lower: "0", upper: "-1")
+      expect(described_class.parse("*")).to eq(lower: "0", upper: "*")
+    end
+
+    it "defaults a blank lower bound in a range to 0" do
+      # "..1" must not become lower="*" — LiteralInteger cannot hold *.
+      expect(described_class.parse("..1")).to eq(lower: "0", upper: "1")
+    end
+
+    it "defaults a blank upper bound in a range to unlimited" do
+      expect(described_class.parse("1..")).to eq(lower: "1", upper: "*")
+    end
+
+    it "treats a bare range separator as the UML default" do
+      expect(described_class.parse("..")).to eq(lower: "0", upper: "*")
+    end
+
+    it "defaults an unlimited lower bound in a range to 0" do
+      expect(described_class.parse("*..1")).to eq(lower: "0", upper: "1")
+    end
+
+    it "defaults EA's stored -1 lower bound in a range to 0" do
+      expect(described_class.parse("-1..1")).to eq(lower: "0", upper: "1")
     end
 
     it "strips surrounding whitespace" do
-      expect(described_class.parse("  1..*  ")).to eq(lower: "1", upper: "-1")
+      expect(described_class.parse("  1..*  ")).to eq(lower: "1", upper: "*")
     end
 
     it "parses the unbounded token" do
       result = described_class.parse("unbounded")
-      expect(result[:upper]).to eq("-1")
+      expect(result[:upper]).to eq("*")
+    end
+
+    it "treats EA's bare -1 as the UML default" do
+      expect(described_class.parse("-1")).to eq(lower: "0", upper: "*")
     end
   end
 
   describe ".normalize_upper" do
-    it "returns -1 for nil" do
-      expect(described_class.normalize_upper(nil)).to eq("-1")
+    it "returns * for nil" do
+      expect(described_class.normalize_upper(nil)).to eq("*")
     end
 
-    it "returns -1 for empty string" do
-      expect(described_class.normalize_upper("")).to eq("-1")
+    it "returns * for empty string" do
+      expect(described_class.normalize_upper("")).to eq("*")
     end
 
-    it "returns -1 for *" do
-      expect(described_class.normalize_upper("*")).to eq("-1")
+    it "returns * for *" do
+      expect(described_class.normalize_upper("*")).to eq("*")
     end
 
-    it "returns -1 for *-1" do
-      expect(described_class.normalize_upper("*-1")).to eq("-1")
+    it "returns * for *-1" do
+      expect(described_class.normalize_upper("*-1")).to eq("*")
     end
 
-    it "returns -1 for unbounded" do
-      expect(described_class.normalize_upper("unbounded")).to eq("-1")
+    it "returns * for unbounded" do
+      expect(described_class.normalize_upper("unbounded")).to eq("*")
     end
 
-    it "returns -1 for UNBOUNDED (case insensitive)" do
-      expect(described_class.normalize_upper("UNBOUNDED")).to eq("-1")
+    it "returns * for UNBOUNDED (case insensitive)" do
+      expect(described_class.normalize_upper("UNBOUNDED")).to eq("*")
     end
 
     it "returns the token unchanged for numeric values" do
       expect(described_class.normalize_upper("5")).to eq("5")
     end
 
-    it "returns the token unchanged for negative numbers" do
-      expect(described_class.normalize_upper("-1")).to eq("-1")
+    it "treats EA's stored -1 as unlimited" do
+      expect(described_class.normalize_upper("-1")).to eq("*")
     end
   end
 
@@ -104,6 +129,22 @@
     it "returns the token unchanged for zero" do
       expect(described_class.normalize_lower("0")).to eq("0")
     end
+
+    it "returns 0 for * (LiteralInteger cannot hold it)" do
+      expect(described_class.normalize_lower("*")).to eq("0")
+    end
+
+    it "returns 0 for EA's stored -1" do
+      expect(described_class.normalize_lower("-1")).to eq("0")
+    end
+
+    it "returns 0 for unbounded" do
+      expect(described_class.normalize_lower("unbounded")).to eq("0")
+    end
+
+    it "returns 0 for UNBOUNDED (case insensitive)" do
+      expect(described_class.normalize_lower("UNBOUNDED")).to eq("0")
+    end
   end
 
   describe "defaults constants" do
@@ -112,7 +153,7 @@
     end
 
     it "exposes DEFAULT_UPPER" do
-      expect(described_class::DEFAULT_UPPER).to eq("-1")
+      expect(described_class::DEFAULT_UPPER).to eq("*")
     end
   end
 end
diff --git a/spec/ea/transformers/qea_to_xmi/extension_serializer_spec.rb b/spec/ea/transformers/qea_to_xmi/extension_serializer_spec.rb
index 9799e2e..611189d 100644
--- a/spec/ea/transformers/qea_to_xmi/extension_serializer_spec.rb
+++ b/spec/ea/transformers/qea_to_xmi/extension_serializer_spec.rb
@@ -61,6 +61,10 @@
     it "maps PrimitiveType to uml:PrimitiveType" do
       expect(described_class::UML_TYPE_FOR["PrimitiveType"]).to eq("uml:PrimitiveType")
     end
+
+    it "maps Association to uml:Association" do
+      expect(described_class::UML_TYPE_FOR["Association"]).to eq("uml:Association")
+    end
   end
 
   describe "SKIP_OBJECT_TYPES" do
@@ -76,4 +80,326 @@
       expect(described_class::SKIP_OBJECT_TYPES).to include("ProxyConnector")
     end
   end
+
+  describe "xrefs population" do
+    subject(:output) { serializer.call }
+
+    # Expected values copied verbatim from examples/exports/basic/model.xml.
+    # Token order: $XID $NAM $TYP $VIS [$BEH] $PAR $DES $CLT [$SUP] $ENDXREF;
+    # $BEH only when Behavior is non-blank. Blank Supplier: omitted for
+    # "connector property", "<none>" for element/attribute property rows.
+    it "emits the operation xref inside its operation" do
+      expected = "$XREFPROP=$XID={62F035B9-1A09-47da-9E51-03D8FB66949B}$XID;" \
+                 "$NAM=MOFProps$NAM;$TYP=operation property$TYP;$VIS=Public$VIS;" \
+                 "$BEH=signal$BEH;$PAR=0$PAR;$DES={igna}$DES;" \
+                 "$CLT={5F2256D3-8EEE-4371-8413-83233BCAF0E5}$CLT;" \
+                 "$SUP={A53E4556-FAEE-458d-B9B2-93B41FA424AC}$SUP;$ENDXREF;"
+      expect(output).to include(%(<xrefs value="#{expected}"/>))
+    end
+
+    it "omits $SUP for blank-supplier connector xrefs" do
+      expected = "$XREFPROP=$XID={30D4BD91-0C67-43ff-8EE4-8C32314A4779}$XID;" \
+                 "$NAM=Stereotypes$NAM;$TYP=connector property$TYP;$VIS=Public$VIS;" \
+                 "$PAR=0$PAR;$DES=@STEREO;Name=import;" \
+                 "GUID={4C1D99EB-03DD-45a8-B4EE-765741A43800};@ENDSTEREO;$DES;" \
+                 "$CLT={12D9B35C-220D-4d31-A3DB-81BCEE4A226B}$CLT;$ENDXREF;"
+      expect(output).to include(%(<xrefs value="#{expected}"/>))
+    end
+
+    it "emits all five populated xrefs basic's reference carries" do
+      expect(output.scan(/<xrefs value="/).size).to eq(5)
+    end
+
+    it "renders blank suppliers as <none> on element-property xrefs" do
+      test_db = Ea::Qea.load("examples/qea/test.qea")
+      begin
+        ctx = Ea::Transformers::QeaToXmi::Context.new(database: test_db)
+        test_output = described_class.new(test_db, ctx).call
+        expect(test_output.scan(/<xrefs value="/).size).to eq(22)
+        expect(test_output).to include("$SUP=&lt;none&gt;$SUP;$ENDXREF;")
+      ensure
+        test_db.close_connection
+      end
+    end
+  end
+
+  describe "element entries for signals" do
+    subject(:output) { serializer.call }
+
+    it "uses the uml:Signal xmi:type in the extension section" do
+      expect(output).to include(%(xmi:type="uml:Signal" name="Signal A"))
+      expect(output).not_to include(%(xmi:type="Signal"))
+    end
+  end
+
+  describe "primitivetypes section" do
+    subject(:output) { serializer.call }
+
+    it "emits the EAnone hierarchy with first-use ordering" do
+      expect(output).to include(
+        "\t\t<primitivetypes>\n" \
+        "\t\t\t<packagedElement xmi:type=\"uml:Package\" xmi:id=\"EAPrimitiveTypesPackage\" name=\"EA_PrimitiveTypes_Package\">\n" \
+        "\t\t\t\t<packagedElement xmi:type=\"uml:Package\" xmi:id=\"EAnoneTypesPackage\" name=\"EA_none_Types_Package\">\n" \
+        "\t\t\t\t\t<packagedElement xmi:type=\"uml:PrimitiveType\" xmi:id=\"EAnone_typeOne\" name=\"typeOne\"/>\n" \
+        "\t\t\t\t\t<packagedElement xmi:type=\"uml:PrimitiveType\" xmi:id=\"EAnone_typeTwo\" name=\"typeTwo\"/>\n" \
+        "\t\t\t\t\t<packagedElement xmi:type=\"uml:PrimitiveType\" xmi:id=\"EAnone_typeThree\" name=\"typeThree\"/>\n" \
+        "\t\t\t\t\t<packagedElement xmi:type=\"uml:PrimitiveType\" xmi:id=\"EAnone_void\" name=\"void\"/>\n" \
+        "\t\t\t\t</packagedElement>\n" \
+        "\t\t\t</packagedElement>\n" \
+        "\t\t</primitivetypes>"
+      )
+    end
+  end
+
+  describe "diagram <elements> entries" do
+    subject(:output) { serializer.call }
+
+    # Expected entries copied verbatim from examples/exports/basic/model.xml
+    # (Starter Object Diagram, t_diagramobjects rows for Diagram_ID=6 and the
+    # first t_diagramlinks row). Object placements: geometry from the Rect*
+    # columns (Top/Bottom sign-flipped, img* at fixed +25/+30 offsets),
+    # seqno from Sequence, style from ObjectStyle verbatim. Connector
+    # entries: subject is the CONNECTOR's EAID, geometry is the link's
+    # Geometry plus "Path=<path>;", style is the link's Style plus
+    # "Hidden=<hidden>;".
+    it "emits object placements from t_diagramobjects" do
+      geometry = "Left=315;Top=101;Right=405;Bottom=151;imgL=340;imgT=131;imgR=430;imgB=181;"
+      expect(output).to include(
+        %(<element geometry="#{geometry}" subject="EAID_FD9B2DCF_E737_471f_A86F_37BACFD69978" ) +
+        %(seqno="1" style="DUID=F11A61F4;"/>)
+      )
+    end
+
+    it "emits connector entries with the connector as subject" do
+      style = "Mode=3;EOID=2B4926BE;SOID=79360F3F;Color=-1;LWidth=0;Hidden=0;"
+      expect(output).to include(
+        %(subject="EAID_1137B03A_C00A_443b_A3A8_D5CF6A7AFF13" style="#{style}"/>)
+      )
+    end
+
+    it "rewrites Path waypoint separators to EA's $ form" do
+      # t_diagramlinks stores "165:-230;371:-230;"; EA's reference emits
+      # Path=165:-230$371:-230$; — verbatim from basic's export.
+      expect(output).to include("Path=165:-230$371:-230$;")
+      expect(output).not_to include("Path=165:-230;")
+    end
+
+    it "emits every placement and connector entry EA covers" do
+      expect(output.scan(/<element geometry=/).size).to eq(168)
+    end
+
+    it "orders object placements by sequence before connector entries" do
+      diagrams = output[%r{<diagrams>.*</diagrams>}m]
+      elements = diagrams[%r{<elements>.*?</elements>}m].scan(/<element [^>]*>/)
+      expect(elements[0]).to include(%(seqno="1"))
+      expect(elements[1]).to include(%(seqno="2"))
+    end
+  end
+
+  describe "placements with a NULL Sequence" do
+    # t_diagramobjects.Sequence is nullable with DEFAULT 0.
+    let(:object) do
+      Ea::Qea::Models::EaObject.new(
+        ea_object_id: 10, object_type: "Class", name: "C", package_id: 1,
+        ea_guid: "{BBBBBBBB-1111-2222-3333-444444444444}"
+      )
+    end
+
+    let(:diagram) do
+      Ea::Qea::Models::EaDiagram.new(
+        diagram_id: 7, package_id: 1, name: "D", diagram_type: "Logical",
+        ea_guid: "{CCCCCCCC-1111-2222-3333-444444444444}"
+      )
+    end
+
+    let(:placement) do
+      Ea::Qea::Models::EaDiagramObject.new(
+        diagram_id: 7, ea_object_id: 10, instance_id: 1, sequence: nil
+      )
+    end
+
+    it "renders seqno as 0" do
+      db = build_test_database(objects: [object], diagrams: [diagram], diagram_objects: [placement])
+      context = Ea::Transformers::QeaToXmi::Context.new(database: db)
+      expect(described_class.new(db, context).call).to include(%(seqno="0"))
+    end
+  end
+
+  describe "operation <parameters>" do
+    subject(:output) { serializer.call }
+
+    it "emits one synthesized return parameter per typed operation" do
+      expect(output.scan(/EAID_RETURNID_/).size).to eq(12)
+    end
+
+    it "puts the return parameter first, keyed off the operation id" do
+      block = output[%r{<parameters>.*?</parameters>}m]
+      expect(block.scan(/<parameter [^>]*>/).first)
+        .to include(%(xmi:idref="EAID_RETURNID_))
+      expect(block).to include(%(ea_guid="{RETURNID-))
+    end
+
+    it "orders parameters before xrefs inside an operation" do
+      operation = output[%r{<operation [^>]*>.*?</operation>}m]
+      expect(operation.index("<parameters>")).to be < operation.index("<xrefs")
+    end
+  end
+
+  describe "a typed operation with no ea_guid" do
+    # t_operation.ea_guid is nullable. The synthesized return entry
+    # derives both its idref and its ea_guid from the operation's own
+    # xmi id, so there is nothing to build it from here.
+    let(:owner) do
+      Ea::Qea::Models::EaObject.new(
+        ea_object_id: 10, object_type: "Class", name: "C", package_id: 1,
+        ea_guid: "{BBBBBBBB-1111-2222-3333-444444444444}"
+      )
+    end
+
+    def output_for(ea_guid)
+      operation = Ea::Qea::Models::EaOperation.new(
+        operationid: 3, ea_object_id: 10, name: "count", type: "int",
+        pos: 0, ea_guid: ea_guid
+      )
+      db = build_test_database(objects: [owner], operations: [operation])
+      context = Ea::Transformers::QeaToXmi::Context.new(database: db)
+      described_class.new(db, context).call
+    end
+
+    it "serializes without a return entry when the guid is nil" do
+      expect(output_for(nil)).not_to include("EAID_RETURNID_")
+    end
+
+    it "serializes without a return entry when the guid is empty" do
+      expect(output_for("")).not_to include("EAID_RETURNID_")
+    end
+
+    it "serializes without a return entry when the guid is whitespace" do
+      expect(output_for("   ")).not_to include("EAID_RETURNID_")
+    end
+  end
+
+  describe "an operation whose Type is whitespace only" do
+    # PrimitiveTypes strips type names, so a whitespace-only Type is
+    # absent as far as primitive discovery is concerned. Emitting a
+    # return for it anyway produced type="   " in both trees with no
+    # definition behind it.
+    let(:database) do
+      owner = Ea::Qea::Models::EaObject.new(
+        ea_object_id: 10, object_type: "Class", name: "C", package_id: 1,
+        ea_guid: "{BBBBBBBB-1111-2222-3333-444444444444}"
+      )
+      operation = Ea::Qea::Models::EaOperation.new(
+        operationid: 3, ea_object_id: 10, name: "count", type: "   ",
+        pos: 0, ea_guid: "{CCCCCCCC-1111-2222-3333-444444444444}"
+      )
+      # The package matters: without one the UML tree renders nothing
+      # at all, and the ownedParameter assertion below could not fail.
+      package = Ea::Qea::Models::EaPackage.new(
+        package_id: 1, name: "P", parent_id: 0,
+        ea_guid: "{AAAAAAAA-1111-2222-3333-444444444444}"
+      )
+      build_test_database(objects: [owner], operations: [operation],
+                          packages: [package])
+    end
+
+    it "emits no extension return entry" do
+      context = Ea::Transformers::QeaToXmi::Context.new(database: database)
+      expect(described_class.new(database, context).call)
+        .not_to include("EAID_RETURNID_")
+    end
+
+    it "emits no return ownedParameter in the UML tree" do
+      xml = Ea::Transformers::QeaToXmi::Transformer.new(database)
+                                                   .serialize(with_extensions: false)
+      expect(xml).not_to include(%(direction="return"))
+    end
+  end
+
+  describe "attribute <bounds> with blank EA columns" do
+    # `attr.lowerbound || 1` only caught nil, so a blank string used to
+    # render lower="" here while the UML tree said 1..1.
+    let(:owner) do
+      Ea::Qea::Models::EaObject.new(
+        ea_object_id: 10, object_type: "Class", name: "C", package_id: 1,
+        ea_guid: "{BBBBBBBB-1111-2222-3333-444444444444}"
+      )
+    end
+
+    def output_for(lowerbound, upperbound)
+      attribute = Ea::Qea::Models::EaAttribute.new(
+        id: 5, ea_object_id: 10, name: "a", type: "int",
+        lowerbound: lowerbound, upperbound: upperbound,
+        ea_guid: "{DDDDDDDD-1111-2222-3333-444444444444}"
+      )
+      db = build_test_database(objects: [owner], attributes: [attribute])
+      context = Ea::Transformers::QeaToXmi::Context.new(database: db)
+      described_class.new(db, context).call
+    end
+
+    it "defaults empty strings to EA's explicit 1..1" do
+      expect(output_for("", "")).to include(%(<bounds lower="1" upper="1"/>))
+    end
+
+    it "defaults whitespace-only columns to EA's explicit 1..1" do
+      expect(output_for(" ", " ")).to include(%(<bounds lower="1" upper="1"/>))
+    end
+
+    it "agrees with the UML tree when only one column is set" do
+      expect(output_for("2", "")).to include(%(<bounds lower="2" upper="*"/>))
+    end
+
+    # EA's bound columns are free text, so they carry the same XML
+    # metacharacters every other attribute value here is escaped for.
+    it "escapes markup characters instead of corrupting the document" do
+      expect(output_for("1&2", %(3"4)))
+        .to include(%(<bounds lower="1&amp;2" upper="3&quot;4"/>))
+    end
+
+    it "keeps the whole document well-formed" do
+      attribute = Ea::Qea::Models::EaAttribute.new(
+        id: 5, ea_object_id: 10, name: "a", type: "int",
+        lowerbound: "1&2", upperbound: %(3"4),
+        ea_guid: "{DDDDDDDD-1111-2222-3333-444444444444}"
+      )
+      db = build_test_database(objects: [owner], attributes: [attribute])
+      xml = Ea::Transformers::QeaToXmi::Transformer.new(db).serialize
+      expect(Nokogiri::XML(xml).errors).to be_empty
+    end
+  end
+
+  describe "declared parameter ordering" do
+    # t_operationparams is loaded unordered. The UML tree sorts by Pos,
+    # so the extension block has to as well or the two renderers
+    # disagree about the parameter list.
+    let(:owner) do
+      Ea::Qea::Models::EaObject.new(
+        ea_object_id: 10, object_type: "Class", name: "C", package_id: 1,
+        ea_guid: "{BBBBBBBB-1111-2222-3333-444444444444}"
+      )
+    end
+
+    let(:operation) do
+      Ea::Qea::Models::EaOperation.new(
+        operationid: 7, ea_object_id: 10, name: "m", type: "void",
+        ea_guid: "{0000000A-1111-2222-3333-444444444444}"
+      )
+    end
+
+    def parameter(name, pos, guid)
+      Ea::Qea::Models::EaOperationParam.new(
+        operationid: 7, name: name, type: "int", pos: pos, ea_guid: guid
+      )
+    end
+
+    it "emits them in Pos order regardless of insertion order" do
+      later = parameter("second", 2, "{0000000B-1111-2222-3333-444444444444}")
+      earlier = parameter("first", 1, "{0000000C-1111-2222-3333-444444444444}")
+      db = build_test_database(objects: [owner], operations: [operation],
+                               operation_params: [later, earlier])
+      context = Ea::Transformers::QeaToXmi::Context.new(database: db)
+      output = described_class.new(db, context).call
+      expect(output.scan(/<properties pos="(\d+)"/).flatten).to eq(%w[0 1 2])
+    end
+  end
 end
diff --git a/spec/ea/transformers/qea_to_xmi/guid_format_spec.rb b/spec/ea/transformers/qea_to_xmi/guid_format_spec.rb
index f00620a..0f7df41 100644
--- a/spec/ea/transformers/qea_to_xmi/guid_format_spec.rb
+++ b/spec/ea/transformers/qea_to_xmi/guid_format_spec.rb
@@ -80,6 +80,28 @@
     end
   end
 
+  describe ".return_parameter_xmi_id" do
+    let(:operation_id) { "EAID_AB12CDEF_5678_90AB_CDEF_1234567890AB" }
+
+    it "replaces the operation's first segment with RETURNID" do
+      expect(described_class.return_parameter_xmi_id(operation_id))
+        .to eq("EAID_RETURNID_5678_90AB_CDEF_1234567890AB")
+    end
+
+    it "handles an id with nothing after the first segment" do
+      expect(described_class.return_parameter_xmi_id("EAID_ABCD"))
+        .to eq("EAID_RETURNID_ABCD")
+    end
+
+    # The parameter's ea_guid is the braced form of this id, so the
+    # serializer derives it rather than spelling the shape twice.
+    it "converts to the ea_guid EA writes on the return parameter" do
+      return_id = described_class.return_parameter_xmi_id(operation_id)
+      expect(described_class.xmi_id_to_ea_guid(return_id))
+        .to eq("{RETURNID-5678-90AB-CDEF-1234567890AB}")
+    end
+  end
+
   describe "round-trip" do
     it "xmi_id_to_ea_guid(ea_guid_to_xmi_id(x)) == x for normal forms" do
       ea_guid = "{AB-CD-EF-01-23}"
diff --git a/spec/ea/transformers/qea_to_xmi/id_allocator_spec.rb b/spec/ea/transformers/qea_to_xmi/id_allocator_spec.rb
index 75ded70..c26a753 100644
--- a/spec/ea/transformers/qea_to_xmi/id_allocator_spec.rb
+++ b/spec/ea/transformers/qea_to_xmi/id_allocator_spec.rb
@@ -4,154 +4,87 @@
 require "ea/transformers/qea_to_xmi"
 
 RSpec.describe Ea::Transformers::QeaToXmi::IdAllocator do
-  let(:allocator) { described_class.new }
+  subject(:allocator) { described_class.new }
 
+  # Expected IDs are copied verbatim from examples/exports/basic/model.xml.
+  # EA's scheme: the synthesized ID keeps the owner ID's total width —
+  # "EAID_" + prefix + 6-digit counter + underscore padding + the owner
+  # ID's last 27 characters. LI counts globally from 1 in allocation
+  # order; SL/OE/RT count from 0 per owning element.
   describe "#allocate" do
-    it "returns an EAID_ prefixed identifier" do
-      id = allocator.allocate(prefix: described_class::LITERAL_INTEGER)
-      expect(id).to start_with("EAID_LI")
-    end
-
-    it "zero-pads the counter to 6 digits" do
-      id = allocator.allocate(prefix: described_class::LITERAL_INTEGER)
-      expect(id).to match(/EAID_LI000001\z/)
-    end
-
-    it "increments the counter across allocations" do
-      first = allocator.allocate(prefix: described_class::LITERAL_INTEGER)
-      second = allocator.allocate(prefix: described_class::LITERAL_INTEGER)
-      third = allocator.allocate(prefix: described_class::LITERAL_INTEGER)
-
-      expect(first).to end_with("LI000001")
-      expect(second).to end_with("LI000002")
-      expect(third).to end_with("LI000003")
-    end
-
-    it "accepts different prefixes" do
-      li = allocator.allocate(prefix: described_class::LITERAL_INTEGER)
-      oe = allocator.allocate(prefix: described_class::OPAQUE_EXPRESSION)
-      rt = allocator.allocate(prefix: described_class::RETURN_PARAMETER)
-
-      expect(li).to start_with("EAID_LI")
-      expect(oe).to start_with("EAID_OE")
-      expect(rt).to start_with("EAID_RT")
-    end
-  end
-
-  describe "seed-based memoisation" do
-    it "returns the same ID for the same seed" do
-      id1 = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: "attr-42-upper")
-      id2 = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: "attr-42-upper")
-
-      expect(id1).to eq(id2)
-    end
-
-    it "returns different IDs for different seeds" do
-      upper = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: "attr-42-upper")
-      lower = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: "attr-42-lower")
-
-      expect(upper).not_to eq(lower)
-    end
-
-    it "does not advance the counter when returning a memoised ID" do
-      allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: "x")
-      allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: "x") # memoised
-      next_id = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: "y")
-
-      # Counter advanced exactly twice (once per distinct seed)
-      expect(next_id).to end_with("LI000002")
-    end
-
-    it "still allocates when seed is nil" do
-      id = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: nil)
-      expect(id).to start_with("EAID_LI")
-    end
-
-    it "treats nil seed as non-memoising (each call advances)" do
-      id1 = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: nil)
-      id2 = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: nil)
-
-      expect(id1).to end_with("LI000001")
-      expect(id2).to end_with("LI000002")
-    end
-  end
-
-  describe "parent_guid incorporation (Sparx-conformant suffix)" do
-    let(:guid) { "{6B8DB1D6-D01D-4acc-9C05-79018BCB3FB6}" }
-
-    it "appends the parent GUID tail after the counter" do
-      id = allocator.allocate(
-        prefix: described_class::LITERAL_INTEGER,
-        seed: "test",
-        parent_guid: guid,
+    it "builds the LI ladder for association ends in EA's order" do
+      dst = "EAID_dst2AA131_EEB1_4de7_98F5_670D6EE4A52B"
+      src = "EAID_src2AA131_EEB1_4de7_98F5_670D6EE4A52B"
+      ids = [
+        allocator.allocate(prefix: "LI", owner_id: dst, seed: "dst-lower"),
+        allocator.allocate(prefix: "LI", owner_id: dst, seed: "dst-upper"),
+        allocator.allocate(prefix: "LI", owner_id: src, seed: "src-lower"),
+        allocator.allocate(prefix: "LI", owner_id: src, seed: "src-upper")
+      ]
+      expect(ids).to eq(
+        %w[
+          EAID_LI000001__EEB1_4de7_98F5_670D6EE4A52B
+          EAID_LI000002__EEB1_4de7_98F5_670D6EE4A52B
+          EAID_LI000003__EEB1_4de7_98F5_670D6EE4A52B
+          EAID_LI000004__EEB1_4de7_98F5_670D6EE4A52B
+        ]
       )
-      expect(id).to eq("EAID_LI000001__6B8DB1D6_D01D_4acc_9C05_79018BCB3FB6")
     end
 
-    it "preserves the leading underscore from the opening brace" do
-      # Real Sparx format is `EAID_LI<NN>__<guid_tail>` — the double
-      # underscore is separator + brace-derived. Single underscore
-      # would mean the GUID couldn't be traced back to its parent.
-      id = allocator.allocate(
-        prefix: described_class::LITERAL_INTEGER,
-        seed: "test",
-        parent_guid: guid,
-      )
-      expect(id).to include("LI000001__")
+    it "keeps the global LI counter running across owners" do
+      other_owner = "EAID_dst2AA131_EEB1_4de7_98F5_670D6EE4A52B"
+      attr_id = "EAID_4D665E05_CA01_4c63_8311_0EC8F355E932"
+      8.times { |i| allocator.allocate(prefix: "LI", owner_id: other_owner, seed: "warm-#{i}") }
+      id = allocator.allocate(prefix: "LI", owner_id: attr_id, seed: "lower")
+      expect(id).to eq("EAID_LI000009_CA01_4c63_8311_0EC8F355E932")
     end
 
-    it "different parents with the same counter produce distinct IDs" do
-      other_guid = "{AAAAAAAA-BBBB-cccc-dddd-EEEEEEEEEEEE}"
-      id_a = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: "a", parent_guid: guid)
-      id_b = allocator.allocate(prefix: described_class::LITERAL_INTEGER, seed: "b", parent_guid: other_guid)
-
-      expect(id_a).to include("6B8DB1D6")
-      expect(id_b).to include("AAAAAAAA")
-      expect(id_a).not_to eq(id_b)
-    end
-
-    it "omits the tail when parent_guid is nil" do
-      id = allocator.allocate(
-        prefix: described_class::LITERAL_INTEGER,
-        seed: "test",
-        parent_guid: nil,
-      )
-      expect(id).to eq("EAID_LI000001")
-    end
-
-    it "omits the tail when parent_guid is empty string" do
-      id = allocator.allocate(
-        prefix: described_class::LITERAL_INTEGER,
-        seed: "test",
-        parent_guid: "",
-      )
-      expect(id).to eq("EAID_LI000001")
-    end
-  end
-
-  describe "well-known Sparx prefixes" do
-    it "exposes LITERAL_INTEGER" do
-      expect(described_class::LITERAL_INTEGER).to eq("LI")
+    it "counts SL and OE from zero per owning instance" do
+      instance = "EAID_7169D8F6_9F66_4e33_8E49_469BD346DAA1"
+      expect(allocator.allocate(prefix: "SL", owner_id: instance, seed: "s0"))
+        .to eq("EAID_SL000000_9F66_4e33_8E49_469BD346DAA1")
+      expect(allocator.allocate(prefix: "OE", owner_id: instance, seed: "v0"))
+        .to eq("EAID_OE000000_9F66_4e33_8E49_469BD346DAA1")
+      expect(allocator.allocate(prefix: "SL", owner_id: instance, seed: "s1"))
+        .to eq("EAID_SL000001_9F66_4e33_8E49_469BD346DAA1")
+      expect(allocator.allocate(prefix: "OE", owner_id: instance, seed: "v1"))
+        .to eq("EAID_OE000001_9F66_4e33_8E49_469BD346DAA1")
     end
 
-    it "exposes OPAQUE_EXPRESSION" do
-      expect(described_class::OPAQUE_EXPRESSION).to eq("OE")
+    it "restarts RT at zero for every operation" do
+      op1 = "EAID_11111111_3EE1_4598_9615_F2068D192111"
+      op2 = "EAID_22222222_B122_4b05_863F_1918B52A0C0C"
+      expect(allocator.allocate(prefix: "RT", owner_id: op1, seed: "r1"))
+        .to eq("EAID_RT000000_3EE1_4598_9615_F2068D192111")
+      expect(allocator.allocate(prefix: "RT", owner_id: op2, seed: "r2"))
+        .to eq("EAID_RT000000_B122_4b05_863F_1918B52A0C0C")
     end
 
-    it "exposes SLOT" do
-      expect(described_class::SLOT).to eq("SL")
+    it "memoizes by owner, prefix and seed" do
+      owner = "EAID_4D665E05_CA01_4c63_8311_0EC8F355E932"
+      first = allocator.allocate(prefix: "LI", owner_id: owner, seed: "lower")
+      expect(allocator.allocate(prefix: "LI", owner_id: owner, seed: "lower")).to eq(first)
     end
 
-    it "exposes NAME_LABEL" do
-      expect(described_class::NAME_LABEL).to eq("NL")
+    it "does not advance the LI counter when returning a memoized ID" do
+      owner = "EAID_4D665E05_CA01_4c63_8311_0EC8F355E932"
+      allocator.allocate(prefix: "LI", owner_id: owner, seed: "x")
+      allocator.allocate(prefix: "LI", owner_id: owner, seed: "x")
+      second = allocator.allocate(prefix: "LI", owner_id: owner, seed: "y")
+      expect(second).to eq("EAID_LI000002_CA01_4c63_8311_0EC8F355E932")
     end
 
-    it "exposes DIAGRAM_BOUNDS" do
-      expect(described_class::DIAGRAM_BOUNDS).to eq("DB")
+    it "emits a tailless id when the owner has no usable id" do
+      expect(allocator.allocate(prefix: "LI", owner_id: nil, seed: "s"))
+        .to eq("EAID_LI000001")
     end
 
-    it "exposes RETURN_PARAMETER" do
-      expect(described_class::RETURN_PARAMETER).to eq("RT")
+    it "allocates independently for the same seed under different owners" do
+      op1 = "EAID_11111111_3EE1_4598_9615_F2068D192111"
+      op2 = "EAID_22222222_B122_4b05_863F_1918B52A0C0C"
+      first = allocator.allocate(prefix: "RT", owner_id: op1, seed: "return")
+      second = allocator.allocate(prefix: "RT", owner_id: op2, seed: "return")
+      expect(first).not_to eq(second)
     end
   end
 end
diff --git a/spec/ea/transformers/qea_to_xmi/parity_spec.rb b/spec/ea/transformers/qea_to_xmi/parity_spec.rb
new file mode 100644
index 0000000..3801a8e
--- /dev/null
+++ b/spec/ea/transformers/qea_to_xmi/parity_spec.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "nokogiri"
+require "ea/transformers/qea_to_xmi"
+
+# Issue #32 parity ratchet: ID-set distance between our exports and
+# EA's own reference exports, for EVERY model with a checked-in
+# reference. The pre-fix baseline on basic was 421 only-in-ours /
+# 368 only-in-EA / 237 mismatched. These ceilings hold the current
+# distance — they may only go DOWN as later work closes the remaining
+# gaps (deep-nested LI ordering, EAJava primitive hierarchy, package
+# imports, MDG content, true EA round-trip).
+RSpec.describe "QEA to XMI parity ratchet" do
+  RATCHET = {
+    "basic" => { only_ours: 147, only_ea: 148, mismatched: 100 },
+    "simple" => { only_ours: 1, only_ea: 75, mismatched: 0 },
+    "test" => { only_ours: 17, only_ea: 305, mismatched: 3 },
+    "ArcGISWorkspace_template" => { only_ours: 1, only_ea: 463, mismatched: 2 },
+    "UmlModel_template" => { only_ours: 0, only_ea: 1, mismatched: 0 },
+  }.freeze
+
+  XMI_NS = { "xmi" => "http://www.omg.org/spec/XMI/20110701" }.freeze
+
+  def id_map(xml)
+    map = {}
+    Nokogiri::XML(xml).xpath("//*[@xmi:id]", XMI_NS).each do |element|
+      map[element["xmi:id"]] = [element.name, element.attributes.transform_values(&:value)]
+    end
+    map
+  end
+
+  RATCHET.each do |model, ceiling|
+    context model do
+      it "keeps ID and attribute parity within the ratchet" do
+        database = Ea::Qea.load("examples/qea/#{model}.qea")
+        begin
+          ours = id_map(Ea::Transformers.qea_to_xmi(database))
+          # binread, not read: the references declare windows-1252 and
+          # carry bytes that are not valid UTF-8. Nokogiri honours the
+          # prolog either way, but a UTF-8-tagged invalid string raises
+          # on any later String operation.
+          ref = id_map(File.binread("examples/exports/#{model}/model.xml"))
+          common = ours.keys & ref.keys
+          mismatched = common.count { |id| ours[id] != ref[id] }
+          expect((ours.keys - ref.keys).size).to be <= ceiling[:only_ours]
+          expect((ref.keys - ours.keys).size).to be <= ceiling[:only_ea]
+          expect(mismatched).to be <= ceiling[:mismatched]
+        ensure
+          database.close_connection
+        end
+      end
+    end
+  end
+
+  it "self-parses through the Sparx XMI model" do
+    database = Ea::Qea.load("examples/qea/basic.qea")
+    begin
+      output = Ea::Transformers.qea_to_xmi(database)
+      expect { ::Xmi::Sparx::Root.parse_xml(output) }.not_to raise_error
+    ensure
+      database.close_connection
+    end
+  end
+end
diff --git a/spec/ea/transformers/qea_to_xmi/profile_serializer_spec.rb b/spec/ea/transformers/qea_to_xmi/profile_serializer_spec.rb
index 2071082..a508052 100644
--- a/spec/ea/transformers/qea_to_xmi/profile_serializer_spec.rb
+++ b/spec/ea/transformers/qea_to_xmi/profile_serializer_spec.rb
@@ -89,15 +89,70 @@
       expect(class_codelist.name).to eq("A_Class_CodeList")
     end
 
-    it "has two memberEnds (extension end + base property)" do
-      expect(class_codelist.member_ends.size).to eq(2)
+    it "carries both ends in one memberEnd attribute" do
+      expect(class_codelist.member_end).to eq("extension_CodeList CodeList-base_Class")
     end
 
-    it "has an ExtensionEnd owned end" do
-      ext_end = class_codelist.owned_end.first
+    it "has no memberEnd child elements" do
+      expect(class_codelist.member_ends).to be_nil
+    end
+  end
+
+  describe "extension end shape" do
+    let(:blocks) { described_class.new(registry).call }
+    let(:ext_end) { blocks.find { |b| b.id == "Class_CodeList" }.owned_end.first }
+
+    it "is a uml:ExtensionEnd named after the stereotype" do
       expect(ext_end.type).to eq("uml:ExtensionEnd")
       expect(ext_end.id).to eq("extension_CodeList")
     end
+
+    it "repeats the memberEnd attribute and marks itself composite" do
+      expect(ext_end.member_end).to eq("extension_CodeList CodeList-base_Class")
+      expect(ext_end.is_composite).to be(true)
+    end
+
+    it "points its type child at the stereotype" do
+      expect(ext_end.uml_type.idref).to eq("CodeList")
+      expect(ext_end.association).to be_nil
+    end
+  end
+
+  describe "stereotype names defined by more than one MDG" do
+    let(:iso_document) do
+      Ea::Mdg::Loader.from_path("spec/fixtures/mdg/ISO19103MDG v1.0.0-beta.xml").document
+    end
+
+    def profile(*documents)
+      registry = Ea::Mdg::Registry.new
+      documents.each { |doc| registry.register(doc) }
+      described_class.new(registry).call
+    end
+
+    # Extension-end ids repeat once per metaclass within one MDG —
+    # EA's own exports do the same, so those must survive. They live on
+    # the owned_end children, so an id sweep that stops at the top-level
+    # blocks never sees the ids it claims to protect.
+    def all_ids(*documents)
+      profile(*documents).flat_map { |block| [block.id, *block.owned_end.to_a.map(&:id)] }
+    end
+
+    def duplicate_ids(*documents)
+      all_ids(*documents).tally.select { |_id, count| count > 1 }.keys.sort
+    end
+
+    it "keeps the extension-end ids EA repeats once per metaclass" do
+      expect(duplicate_ids(iso_document)).to include("extension_CodeList", "extension_Union")
+    end
+
+    it "leaves only the duplicate ids the winning document already had" do
+      expect(duplicate_ids(iso_document, document)).to eq(duplicate_ids(iso_document))
+    end
+
+    it "defines each stereotype name once" do
+      names = profile(iso_document, document).select { |b| b.type == "uml:Stereotype" }.map(&:name)
+      expect(names.uniq.size).to eq(names.size)
+    end
   end
 
   describe "Lutaml::Model::GlobalRegister integration" do
diff --git a/spec/ea/transformers/qea_to_xmi/run_state_spec.rb b/spec/ea/transformers/qea_to_xmi/run_state_spec.rb
index f19d12c..d073d3c 100644
--- a/spec/ea/transformers/qea_to_xmi/run_state_spec.rb
+++ b/spec/ea/transformers/qea_to_xmi/run_state_spec.rb
@@ -81,12 +81,18 @@
       expect(binding.body).to eq("Alice")
     end
 
-    it "uses only the first character of multi-character operators" do
-      # EA's Op field sometimes carries the literal characters of the
-      # comparison operator (`==`, `!=`, `<=`, `>=`). Sparx prepends
-      # only the first character to the body value.
+    it "prepends multi-character operators verbatim" do
+      # The mini-language stores equality as `Op==;` (parsed op "="),
+      # comparison ops as their literal text (`Op=<=;` → "<="). EA's
+      # reference export prepends the stored op verbatim:
+      # examples/exports/basic/model.xml contains body="<=valueTwo".
+      binding = described_class::Binding.new("n", "v", "<=")
+      expect(binding.body).to eq("<=v")
+    end
+
+    it "keeps != intact rather than truncating it" do
       binding = described_class::Binding.new("n", "v", "!=")
-      expect(binding.body).to eq("!v")
+      expect(binding.body).to eq("!=v")
     end
   end
 end
diff --git a/spec/ea/transformers/qea_to_xmi/transformer_spec.rb b/spec/ea/transformers/qea_to_xmi/transformer_spec.rb
index 1526fe4..a744269 100644
--- a/spec/ea/transformers/qea_to_xmi/transformer_spec.rb
+++ b/spec/ea/transformers/qea_to_xmi/transformer_spec.rb
@@ -16,6 +16,18 @@ def count_xmi_type(type)
     parsed.xpath(%(//*[@xmi:type="#{type}"])).size
   end
 
+  describe "classifier dispatch registry" do
+    # The capabilities map is read with a default, so an unclassified
+    # kind loses its bounds or its nested children silently — wrong XML,
+    # no exception. This assertion is the only exhaustiveness check that
+    # exists, and it has to fail in both directions: a builder with no
+    # capabilities entry, and an entry with no builder.
+    it "classifies exactly the kinds the builder registry can build" do
+      expect(described_class::CLASSIFIER_CAPABILITIES.keys)
+        .to match_array(described_class::CLASSIFIER_BUILDERS.keys)
+    end
+  end
+
   describe "document framing" do
     it "emits an xmi:XMI root with EA's Sparx namespace declarations" do
       root = parsed.root
@@ -60,11 +72,20 @@ def count_xmi_type(type)
       expect(count_xmi_type("uml:Package")).to eq(expected)
     end
 
-    it "emits one Class packagedElement per Class t_object" do
+    it "emits one Class node per Class t_object" do
+      # Counts every uml:Class node — packaged AND nested (EA nests
+      # child classes as nestedClassifier).
       expected = database.objects.count { |o| o.object_type == "Class" }
       expect(count_xmi_type("uml:Class")).to eq(expected)
     end
 
+    it "nests child classes as nestedClassifier (EA convention)" do
+      # basic.qea: 35 Class rows have a nonzero parentid; EA's reference
+      # packages the other 30 and nests these 35.
+      expect(parsed.xpath(%(//packagedElement[@xmi:type="uml:Class"])).size).to eq(30)
+      expect(parsed.xpath(%(//nestedClassifier[@xmi:type="uml:Class"])).size).to eq(35)
+    end
+
     it "emits one Enumeration per Enumeration t_object" do
       expected = database.objects.count { |o| o.object_type == "Enumeration" }
       expect(count_xmi_type("uml:Enumeration")).to eq(expected)
@@ -131,6 +152,101 @@ def count_xmi_type(type)
     end
   end
 
+  describe "return parameter type spelling" do
+    # EA writes the classifier reference unprefixed. The xmi gem keeps
+    # that slot namespaced for the XMI metaclass discriminator, which is
+    # correct for general UML XMI, so the exporter restores EA's form
+    # here rather than in the shared model.
+    #
+    # Nokogiri keys attributes by local name, so the parity ratchet
+    # cannot see this difference — only a raw string check can.
+    it "writes an unprefixed type, like EA" do
+      # Anchored on the space: `xmi:type="EAnone_void"` contains the
+      # unprefixed spelling as a substring, so a plain include passes
+      # either way.
+      expect(xml).to match(/<ownedParameter\b[^>]*\stype="EAnone_void"/)
+    end
+
+    it "leaves no xmi:type on any ownedParameter" do
+      expect(xml.scan(/<ownedParameter\b[^>]*xmi:type=/)).to be_empty
+    end
+
+    it "matches EA's reference count of unprefixed parameter types" do
+      # The reference carries bytes that are not valid UTF-8; scrub so
+      # String#scan does not raise on them.
+      reference = File.read("examples/exports/basic/model.xml").scrub
+      expected = reference.scan(/<ownedParameter\b[^>]*\stype="/).size
+      expect(xml.scan(/<ownedParameter\b[^>]*\stype="/).size).to eq(expected)
+    end
+
+    it "skips the return parameter when the operation has no usable guid" do
+      # EA derives the RT id's tail from the operation's GUID, so an
+      # operation without one produced a tailless `xmi:id="EAID_RT000000"`
+      # in the UML tree while the extension block emitted nothing —
+      # the two describing different operations.
+      package = Ea::Qea::Models::EaPackage.new(
+        package_id: 1, name: "P", parent_id: 0,
+        ea_guid: "{AAAAAAAA-1111-2222-3333-444444444444}"
+      )
+      owner = synthetic_object(10, type: "Class", name: "C")
+      operation = Ea::Qea::Models::EaOperation.new(
+        operationid: 3, ea_object_id: 10, name: "m", type: "int",
+        pos: 0, ea_guid: nil
+      )
+      database = build_test_database(packages: [package], objects: [owner],
+                                     operations: [operation])
+      output = described_class.new(database).serialize
+      # Assert absence outright: equal counts would also be satisfied by
+      # both renderers emitting one, which is not what "skips" means.
+      expect(output.scan(/direction="return"/)).to be_empty
+      expect(output.scan(/EAID_RETURNID_/)).to be_empty
+      expect(output).not_to include(%(xmi:id="EAID_RT000000"))
+    end
+
+    it "skips it for an empty or whitespace guid too" do
+      # `to_s.strip` is what makes these distinct from nil; pin all three.
+      package = Ea::Qea::Models::EaPackage.new(
+        package_id: 1, name: "P", parent_id: 0,
+        ea_guid: "{AAAAAAAA-1111-2222-3333-444444444444}"
+      )
+      ["", "   "].each do |guid|
+        operation = Ea::Qea::Models::EaOperation.new(
+          operationid: 3, ea_object_id: 10, name: "m", type: "int",
+          pos: 0, ea_guid: guid
+        )
+        database = build_test_database(
+          packages: [package], objects: [synthetic_object(10, type: "Class", name: "C")],
+          operations: [operation]
+        )
+        output = described_class.new(database).serialize
+        expect(output.scan(/direction="return"/)).to be_empty, "guid=#{guid.inspect}"
+        expect(output.scan(/EAID_RETURNID_/)).to be_empty, "guid=#{guid.inspect}"
+      end
+    end
+
+    it "leaves a parameter name containing the literal xmi:type= alone" do
+      # Parameter names are free text out of EA. Substituting on the raw
+      # tag would rewrite this one inside its quotes.
+      package = Ea::Qea::Models::EaPackage.new(
+        package_id: 1, name: "P", parent_id: 0,
+        ea_guid: "{AAAAAAAA-1111-2222-3333-444444444444}"
+      )
+      owner = synthetic_object(10, type: "Class", name: "C")
+      operation = Ea::Qea::Models::EaOperation.new(
+        operationid: 3, ea_object_id: 10, name: "m", type: "int",
+        pos: 0, ea_guid: "{CCCCCCCC-1111-2222-3333-444444444444}"
+      )
+      param = Ea::Qea::Models::EaOperationParam.new(
+        operationid: 3, name: %(literal xmi:type= marker), type: "int", pos: 1,
+        ea_guid: "{DDDDDDDD-1111-2222-3333-444444444444}"
+      )
+      database = build_test_database(packages: [package], objects: [owner],
+                                     operations: [operation], operation_params: [param])
+      output = described_class.new(database).serialize(with_extensions: false)
+      expect(output).to include(%(name="literal xmi:type= marker"))
+    end
+  end
+
   describe "well-formedness" do
     it "parses without XML errors" do
       expect(parsed.errors).to be_empty
@@ -175,7 +291,9 @@ def count_xmi_type(type)
     # visible in the spec.
     def count_xmi_type_recursive(model, type)
       count = model.is_a?(::Xmi::Uml::PackagedElement) && model.type == type ? 1 : 0
-      children = if model.is_a?(::Xmi::Uml::PackagedElement) || model.is_a?(::Xmi::Uml::UmlModel)
+      children = if model.is_a?(::Xmi::Uml::PackagedElement)
+                   model.packaged_element + model.nested_classifier
+                 elsif model.is_a?(::Xmi::Uml::UmlModel)
                    model.packaged_element
                  else
                    []
@@ -220,10 +338,13 @@ def count_xmi_type_recursive(model, type)
 
     it "omits visibility on Property when public (UML default, matches EA)" do
       # EA omits visibility="public" — only non-public visibility is emitted.
-      # Verify the attribute is NOT always present by checking that at least
-      # some ownedAttribute elements exist without visibility.
-      attrs_without_vis = parsed.xpath("//ownedAttribute[not(@visibility)]")
-      expect(attrs_without_vis).not_to be_empty
+      expect(parsed.xpath("//ownedAttribute[@visibility='public']")).to be_empty
+    end
+
+    it "emits visibility=private for Private-scoped attributes" do
+      # Every t_attribute row in basic.qea has Scope="Private"; EA's
+      # reference marks all 102 as visibility="private".
+      expect(parsed.xpath("//ownedAttribute[@visibility='private']").size).to eq(102)
     end
 
     it "emits visibility on Operation only when non-public" do
@@ -247,9 +368,16 @@ def count_xmi_type_recursive(model, type)
       expect(parsed.xpath("//slot").size).to eq(22)
     end
 
-    it "emits each slot with an OpaqueExpression body (Sparx convention)" do
-      bodies = parsed.xpath("//slot/value[@type='uml:OpaqueExpression']/@body").map(&:value)
-      expect(bodies).to all(match(/\A=./))
+    it "emits each slot body with the RunState operator prepended verbatim" do
+      # Exact body set copied from examples/exports/basic/model.xml —
+      # including the one <= operator EA emits verbatim. (The previous
+      # form of this example matched @type instead of @xmi:type and
+      # passed vacuously over an empty node set.)
+      bodies = parsed.xpath("//slot/value[@xmi:type='uml:OpaqueExpression']/@body").map(&:value)
+      expect(bodies.tally).to eq(
+        "=Value One" => 5, "=valueOne" => 5, "=valueTwo" => 4,
+        "=valueThree" => 4, "=Value Two" => 3, "<=valueTwo" => 1
+      )
     end
 
     it "emits definingFeature on slots whose instance has a classifier" do
@@ -298,4 +426,432 @@ def count_xmi_type_recursive(model, type)
       }
     end
   end
+
+  describe "synthesized ID parity with EA" do
+    # Literal IDs copied from examples/exports/basic/model.xml. These
+    # protect the transformer call sites: owner, prefix, and allocation
+    # order (lower before upper, destination end before source end,
+    # global LI counter in document walk order).
+    it "gives the first association's ends the LI000001-4 ladder" do
+      (1..4).each do |n|
+        expect(xml).to include(%(xmi:id="EAID_LI00000#{n}__EEB1_4de7_98F5_670D6EE4A52B"))
+      end
+    end
+
+    it "derives attribute LI tails from the attribute's own GUID" do
+      expect(xml).to include(%(xmi:id="EAID_LI000009_CA01_4c63_8311_0EC8F355E932"))
+    end
+
+    it "numbers slots and values from zero per instance" do
+      expect(xml).to include(%(xmi:id="EAID_SL000000_9F66_4e33_8E49_469BD346DAA1"))
+      expect(xml).to include(%(xmi:id="EAID_OE000000_9F66_4e33_8E49_469BD346DAA1"))
+    end
+
+    it "numbers every return parameter RT000000 scoped to its operation" do
+      expect(xml).to include(%(xmi:id="EAID_RT000000_3EE1_4598_9615_F2068D192111"))
+    end
+  end
+
+  describe "classifier type resolution" do
+    it "resolves integer classifiers to the object's xmi id, never EAID_0" do
+      test_db = Ea::Qea.load("examples/qea/test.qea")
+      begin
+        test_xml = Ea::Transformers.qea_to_xmi(test_db)
+        expect(test_xml).not_to include(%(idref="EAID_0"))
+      ensure
+        test_db.close_connection
+      end
+    end
+
+    it "emits PrimitiveType objects (simple.qea AcmeUmlPrimitive)" do
+      simple_db = Ea::Qea.load("examples/qea/simple.qea")
+      begin
+        simple_xml = Ea::Transformers.qea_to_xmi(simple_db)
+        expect(simple_xml).to include(%(xmi:type="uml:PrimitiveType"))
+        expect(simple_xml).to include("AcmeUmlPrimitive")
+      ensure
+        simple_db.close_connection
+      end
+    end
+  end
+
+  describe "package dependencies" do
+    # Literal values from examples/exports/basic/model.xml: dependencies
+    # between Package objects resolve endpoints to EAPK_ package refs
+    # via the object's PDATA1 → t_package link.
+    it "emits the three package-level uml:Dependency elements" do
+      deps = parsed.xpath(%(//packagedElement[@xmi:type="uml:Dependency"]))
+      expect(deps.size).to eq(3)
+      dep = deps.find { |d| d["xmi:id"] == "EAID_3DC3F2A8_5EA3_4feb_B6D3_397DA58BBEA3" }
+      expect(dep["client"]).to eq("EAPK_F5BFAAC7_BB6F_4f69_8C78_3775A0C86CDB")
+      expect(dep["supplier"]).to eq("EAPK_45D98ADF_46E0_4bf6_B94F_8E504ABD1AB7")
+    end
+  end
+
+  describe "signals and primitive type references" do
+    # Literal expectations copied from examples/exports/basic/model.xml.
+    it "emits the three Signal objects as uml:Signal packagedElements" do
+      expect(parsed.xpath(%(//packagedElement[@xmi:type="uml:Signal"])).size).to eq(3)
+      expect(xml).to include(%(xmi:id="EAID_A53E4556_FAEE_458d_B9B2_93B41FA424AC"))
+    end
+
+    it "references int-typed attributes via the OMG PrimitiveTypes href" do
+      hrefs = parsed.xpath(%(//ownedAttribute/type[@href]))
+      expect(hrefs.size).to eq(90)
+      expect(hrefs.first["href"])
+        .to eq("http://www.omg.org/spec/UML/20110701/PrimitiveTypes.xmi#Integer")
+    end
+
+    it "types return parameters with their EAnone reference" do
+      returns = parsed.xpath(%(//ownedParameter[@direction="return"]))
+      expect(returns.size).to eq(12)
+      expect(returns.map { |p| p["type"] }.uniq).to eq(["EAnone_void"])
+    end
+  end
+
+  describe "interface realizations" do
+    let(:package) do
+      Ea::Qea::Models::EaPackage.new(
+        package_id: 1, name: "P", parent_id: 0,
+        ea_guid: "{AAAAAAAA-1111-2222-3333-444444444444}"
+      )
+    end
+
+    let(:client_class) do
+      Ea::Qea::Models::EaObject.new(
+        ea_object_id: 10, object_type: "Class", name: "C", package_id: 1,
+        ea_guid: "{BBBBBBBB-1111-2222-3333-444444444444}"
+      )
+    end
+
+    let(:supplier_interface) do
+      Ea::Qea::Models::EaObject.new(
+        ea_object_id: 11, object_type: "Interface", name: "I", package_id: 1,
+        ea_guid: "{CCCCCCCC-1111-2222-3333-444444444444}"
+      )
+    end
+
+    def realization_database(connector_type:, end_object_id: 11)
+      connector = Ea::Qea::Models::EaConnector.new(
+        connector_id: 5, connector_type: connector_type,
+        start_object_id: 10, end_object_id: end_object_id,
+        ea_guid: "{DDDDDDDD-1111-2222-3333-444444444444}"
+      )
+      build_test_database(
+        packages: [package],
+        objects: [client_class, supplier_interface],
+        connectors: [connector]
+      )
+    end
+
+    it "serializes a Realization connector as interfaceRealization" do
+      db = realization_database(connector_type: "Realization")
+      xml = described_class.new(db).serialize(with_extensions: false)
+      expect(xml).to include("<interfaceRealization")
+    end
+
+    it "serializes the UK-spelled Realisation the same way" do
+      db = realization_database(connector_type: "Realisation")
+      xml = described_class.new(db).serialize(with_extensions: false)
+      expect(xml).to include("<interfaceRealization")
+    end
+
+    it "skips the realization when the supplier object is missing" do
+      db = realization_database(connector_type: "Realization", end_object_id: 999)
+      xml = described_class.new(db).serialize(with_extensions: false)
+      expect(xml).not_to include("<interfaceRealization")
+    end
+  end
+
+  # Synthetic-model builders for the specs below.
+  def synthetic_package
+    Ea::Qea::Models::EaPackage.new(
+      package_id: 1, name: "P", parent_id: 0,
+      ea_guid: "{AAAAAAAA-1111-2222-3333-444444444444}"
+    )
+  end
+
+  def synthetic_object(id, type:, name:, parentid: 0)
+    Ea::Qea::Models::EaObject.new(
+      ea_object_id: id, object_type: type, name: name, package_id: 1,
+      parentid: parentid, ea_guid: "{#{format("%08d", id)}-1111-2222-3333-444444444444}"
+    )
+  end
+
+  describe "Association t_object rows" do
+    # simple.qea carries AcmeUmlAssociation as a t_object row, not a
+    # connector. EA exports it bare — see examples/exports/simple/
+    # model.xml:13.
+    let(:simple_doc) do
+      simple_db = Ea::Qea.load("examples/qea/simple.qea")
+      begin
+        Nokogiri::XML(Ea::Transformers.qea_to_xmi(simple_db))
+      ensure
+        simple_db.close_connection
+      end
+    end
+
+    let(:association_id) { "EAID_D1D68870_3A7C_4ce3_9F1A_BB7FF5D99E17" }
+
+    it "emits the association as a bare uml:Association packagedElement" do
+      node = simple_doc.at_xpath(%(//packagedElement[@xmi:id="#{association_id}"]))
+      expect(node["xmi:type"]).to eq("uml:Association")
+      expect(node["name"]).to eq("AcmeUmlAssociation")
+      expect(node.element_children).to be_empty
+    end
+
+    it "types its extension element as uml:Association" do
+      node = simple_doc.at_xpath(%(//element[@xmi:idref="#{association_id}"]))
+      expect(node["xmi:type"]).to eq("uml:Association")
+    end
+  end
+
+  describe "operation return types with a blank classifier" do
+    let(:operation) do
+      Ea::Qea::Models::EaOperation.new(
+        operationid: 3, ea_object_id: 10, name: "count", type: "int",
+        classifier: "", pos: 0, ea_guid: "{CCCCCCCC-1111-2222-3333-444444444444}"
+      )
+    end
+
+    let(:xml) do
+      database = build_test_database(packages: [synthetic_package], operations: [operation],
+                                     objects: [synthetic_object(10, type: "Class", name: "C")])
+      described_class.new(database).serialize
+    end
+
+    it "defines the EAnone_ primitive its return parameter references" do
+      expect(xml).to include(%(type="EAnone_int"))
+      expect(xml).to include(%(xmi:id="EAnone_int"))
+    end
+
+    it "leaves no EAnone_ reference undefined" do
+      referenced = xml.scan(/(?:type|idref)="(EAnone_[^"]*)"/).flatten.uniq
+      defined = xml.scan(/xmi:id="(EAnone_[^"]*)"/).flatten.uniq
+      expect(referenced - defined).to be_empty
+    end
+  end
+
+  describe "type names EA stores with surrounding whitespace" do
+    # t_operation.Type is free text. The reference and the
+    # <primitivetypes> definition used to normalize it differently, so
+    # the idref pointed at an id nobody defined.
+    let(:xml) do
+      operation = Ea::Qea::Models::EaOperation.new(
+        operationid: 3, ea_object_id: 10, name: "count", type: "  int  ",
+        classifier: "", pos: 0, ea_guid: "{CCCCCCCC-1111-2222-3333-444444444444}"
+      )
+      database = build_test_database(packages: [synthetic_package], operations: [operation],
+                                     objects: [synthetic_object(10, type: "Class", name: "C")])
+      described_class.new(database).serialize
+    end
+
+    it "references and defines the same stripped id" do
+      expect(xml).to include(%(type="EAnone_int"))
+      expect(xml).to include(%(xmi:id="EAnone_int"))
+    end
+
+    it "leaves no EAnone_ reference undefined" do
+      referenced = xml.scan(/(?:type|idref)="(EAnone_[^"]*)"/).flatten.uniq
+      defined = xml.scan(/xmi:id="(EAnone_[^"]*)"/).flatten.uniq
+      expect(referenced - defined).to be_empty
+    end
+  end
+
+  describe "a classifier id that resolves to nothing" do
+    # KNOWN GAP. The reference falls back to EAnone_int, but the
+    # definition side only defines names whose classifier is blank, so
+    # the idref dangles. Defining it from here instead over-emits:
+    # PrimitiveTypes scans every row in the database, including rows the
+    # walk never exports, and EA's own plateau export defines nothing
+    # for them. See lib/ea/transformers/qea_to_xmi/primitive_types.rb.
+    let(:xml) do
+      operation = Ea::Qea::Models::EaOperation.new(
+        operationid: 3, ea_object_id: 10, name: "count", type: "int",
+        classifier: "999", pos: 0, ea_guid: "{CCCCCCCC-1111-2222-3333-444444444444}"
+      )
+      database = build_test_database(packages: [synthetic_package], operations: [operation],
+                                     objects: [synthetic_object(10, type: "Class", name: "C")])
+      described_class.new(database).serialize
+    end
+
+    it "leaves no EAnone_ reference undefined" do
+      pending "definitions follow a whole-database scan, not the emitted references"
+      referenced = xml.scan(/(?:type|idref)="(EAnone_[^"]*)"/).flatten.uniq
+      defined = xml.scan(/xmi:id="(EAnone_[^"]*)"/).flatten.uniq
+      expect(referenced - defined).to be_empty
+    end
+  end
+
+  describe "attribute types EA maps to the OMG PrimitiveTypes library" do
+    # The href child replaces the idref only when there is no classifier
+    # to point at. A resolvable classifier wins over the href name.
+    def attribute_with(classifier)
+      Ea::Qea::Models::EaAttribute.new(
+        id: 5, ea_object_id: 10, name: "count", type: "int", pos: 0,
+        classifier: classifier, ea_guid: "{DDDDDDDD-1111-2222-3333-444444444444}"
+      )
+    end
+
+    def xml_for(classifier)
+      attribute = attribute_with(classifier)
+      database = build_test_database(
+        packages: [synthetic_package], attributes: [attribute],
+        objects: [synthetic_object(10, type: "Class", name: "C"),
+                  synthetic_object(11, type: "DataType", name: "Int")]
+      )
+      described_class.new(database).serialize
+    end
+
+    it "emits the OMG href when the classifier is blank" do
+      expect(xml_for("")).to include("PrimitiveTypes.xmi#Integer")
+    end
+
+    it "points at the classifier instead when it resolves" do
+      xml = xml_for("11")
+      expect(xml).to include(%(xmi:idref="EAID_00000011_1111_2222_3333_444444444444"))
+      expect(xml).not_to include("PrimitiveTypes.xmi#Integer")
+    end
+  end
+
+  describe "objects whose parent never nests them" do
+    let(:objects) do
+      [synthetic_object(20, type: "Enumeration", name: "E"),
+       synthetic_object(21, type: "Class", name: "UnderEnum", parentid: 20),
+       synthetic_object(30, type: "Class", name: "UnderMissing", parentid: 999),
+       synthetic_object(40, type: "Class", name: "Parent"),
+       synthetic_object(41, type: "Class", name: "UnderClass", parentid: 40)]
+    end
+
+    let(:parsed) do
+      database = build_test_database(packages: [synthetic_package], objects: objects)
+      Nokogiri::XML(described_class.new(database).serialize(with_extensions: false))
+    end
+
+    def names_at(xpath)
+      parsed.xpath(xpath).map { |node| node["name"] }
+    end
+
+    it "keeps children their parent never nests at package level" do
+      expect(names_at("//packagedElement/packagedElement")).to include("UnderEnum", "UnderMissing")
+    end
+
+    it "still nests a child of a class" do
+      expect(names_at("//packagedElement/packagedElement")).not_to include("UnderClass")
+      expect(names_at("//nestedClassifier")).to eq(["UnderClass"])
+    end
+  end
+
+  describe "a grandchild under an orphaned parent" do
+    # The orphan sorts AFTER its own child here, so a walk that decides
+    # orphan-hood from what it has emitted so far would snapshot the
+    # grandchild as un-nested and emit it a second time on the same
+    # xmi:id. Adoption is structural, so it is emitted exactly once.
+    let(:objects) do
+      [synthetic_object(20, type: "Enumeration", name: "E"),
+       synthetic_object(21, type: "Class", name: "OrphanUnderEnum", parentid: 20),
+       synthetic_object(22, type: "Class", name: "GrandchildUnderOrphan", parentid: 21)]
+    end
+
+    let(:nodes) do
+      database = build_test_database(packages: [synthetic_package], objects: objects)
+      parsed = Nokogiri::XML(described_class.new(database).serialize(with_extensions: false))
+      parsed.xpath(%(//*[@name="GrandchildUnderOrphan"]))
+    end
+
+    it "emits the grandchild exactly once" do
+      expect(nodes.size).to eq(1)
+    end
+
+    it "emits it as a nestedClassifier of the orphan" do
+      expect(nodes.first.name).to eq("nestedClassifier")
+      expect(nodes.first.parent["name"]).to eq("OrphanUnderEnum")
+    end
+  end
+
+  describe "a ParentID chain that never terminates" do
+    # A corrupt model can point an object at itself or round a cycle.
+    # Both ends are nesting kinds, so treating them as adopted would
+    # leave every one of them waiting on a parent that is never built —
+    # they would vanish from the export without a word.
+    def emitted_names(objects)
+      database = build_test_database(packages: [synthetic_package], objects: objects)
+      parsed = Nokogiri::XML(described_class.new(database).serialize(with_extensions: false))
+      objects.to_h { |obj| [obj.name, parsed.xpath(%(//*[@name="#{obj.name}"])).size] }
+    end
+
+    it "still emits an object that is its own parent" do
+      expect(emitted_names([synthetic_object(30, type: "Class", name: "Self", parentid: 30)]))
+        .to eq("Self" => 1)
+    end
+
+    it "still emits both halves of a two-object cycle" do
+      objects = [synthetic_object(40, type: "Class", name: "A", parentid: 41),
+                 synthetic_object(41, type: "Class", name: "B", parentid: 40)]
+      expect(emitted_names(objects)).to eq("A" => 1, "B" => 1)
+    end
+  end
+
+  describe "serializing the same transformer twice" do
+    it "returns identical XML both times" do
+      database = build_test_database(
+        packages: [synthetic_package],
+        objects: [synthetic_object(20, type: "Enumeration", name: "E"),
+                  synthetic_object(21, type: "Class", name: "UnderEnum", parentid: 20)]
+      )
+      transformer = described_class.new(database)
+      first = transformer.serialize
+      expect(transformer.serialize).to eq(first)
+    end
+  end
+
+  describe "attribute bounds with only one EA column set" do
+    # The explicit 1..1 is a property of the PAIR — EA applies it when
+    # both t_attribute columns are blank. Defaulting each column on its
+    # own would render the invalid 2..1 here.
+    def bounds_for(lowerbound:, upperbound:)
+      attribute = Ea::Qea::Models::EaAttribute.new(
+        id: 5, ea_object_id: 10, name: "a", type: "int",
+        lowerbound: lowerbound, upperbound: upperbound,
+        ea_guid: "{DDDDDDDD-1111-2222-3333-444444444444}"
+      )
+      database = build_test_database(packages: [synthetic_package], attributes: [attribute],
+                                     objects: [synthetic_object(10, type: "Class", name: "C")])
+      node = Nokogiri::XML(described_class.new(database).serialize(with_extensions: false))
+                     .at_xpath("//ownedAttribute")
+      [node.at_xpath("lowerValue")["value"], node.at_xpath("upperValue")["value"]]
+    end
+
+    it "keeps a set lower bound and falls back to * for a blank upper" do
+      expect(bounds_for(lowerbound: "2", upperbound: nil)).to eq(["2", "*"])
+    end
+
+    it "falls back to 0 for a blank lower and keeps a set upper" do
+      expect(bounds_for(lowerbound: nil, upperbound: "5")).to eq(%w[0 5])
+    end
+
+    it "still writes EA's explicit 1..1 when both columns are blank" do
+      expect(bounds_for(lowerbound: nil, upperbound: nil)).to eq(%w[1 1])
+    end
+  end
+
+  describe "attribute bounds with no EA multiplicity" do
+    # examples/exports/test/model.xml:183-187 — EA writes an explicit
+    # 1..1 for a Property whose t_attribute bounds are NULL.
+    it "emits 1..1 with the reference LI ids for test.qea Union.option1" do
+      test_db = Ea::Qea.load("examples/qea/test.qea")
+      begin
+        doc = Nokogiri::XML(Ea::Transformers.qea_to_xmi(test_db))
+        attr_node = doc.at_xpath(%(//ownedAttribute[@xmi:id="EAID_CDDC5C85_CD8A_48b4_BECD_FBFFBEAC015C"]))
+        lower = attr_node.at_xpath("lowerValue")
+        upper = attr_node.at_xpath("upperValue")
+        expect(lower["xmi:id"]).to eq("EAID_LI000063_CD8A_48b4_BECD_FBFFBEAC015C")
+        expect(lower["value"]).to eq("1")
+        expect(upper["xmi:id"]).to eq("EAID_LI000064_CD8A_48b4_BECD_FBFFBEAC015C")
+        expect(upper["value"]).to eq("1")
+      ensure
+        test_db.close_connection
+      end
+    end
+  end
 end
diff --git a/spec/ea/transformers/qea_to_xmi/visibility_spec.rb b/spec/ea/transformers/qea_to_xmi/visibility_spec.rb
index bb0bf95..0e932d0 100644
--- a/spec/ea/transformers/qea_to_xmi/visibility_spec.rb
+++ b/spec/ea/transformers/qea_to_xmi/visibility_spec.rb
@@ -36,6 +36,16 @@
     it "returns nil for unrecognised codes" do
       expect(described_class.from_scope(99)).to be_nil
     end
+
+    it "maps textual QEA scopes" do
+      expect(described_class.from_scope("Private")).to eq("private")
+      expect(described_class.from_scope("Protected")).to eq("protected")
+      expect(described_class.from_scope("Package")).to eq("package")
+    end
+
+    it "suppresses textual Public as the UML default" do
+      expect(described_class.from_scope("Public")).to be_nil
+    end
   end
 
   describe ".aggregation_from_containment" do
diff --git a/spec/ea/xmi_guard_spec.rb b/spec/ea/xmi_guard_spec.rb
new file mode 100644
index 0000000..bf485bc
--- /dev/null
+++ b/spec/ea/xmi_guard_spec.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Ea::XmiGuard do
+  describe ".supported?" do
+    it "is true for the xmi version in the current bundle" do
+      # The bundle pins the xmi branch that adds nested_classifier
+      # (lutaml/xmi#94); the guard must pass so `require "ea"` works.
+      expect(described_class.supported?).to be true
+    end
+  end
+
+  describe ".verify!" do
+    it "passes silently in the current bundle" do
+      expect { described_class.verify! }.not_to raise_error
+    end
+
+    it "raises an actionable Ea::Error when the feature is absent" do
+      expect { described_class.verify!(feature_present: false) }
+        .to raise_error(
+          Ea::Error,
+          /requires an xmi version with nestedClassifier support \(>= 0\.7\.0\)/
+        )
+    end
+
+    it "names the missing reader and the fix in the error message" do
+      described_class.verify!(feature_present: false)
+    rescue Ea::Error => e
+      expect(e.message).to include("Xmi::Uml::PackagedElement#nested_classifier")
+      expect(e.message).to include("Update the xmi gem")
+    end
+  end
+end