lutaml-lml 0.1.8 → 0.2.1

data/lib/lutaml/lml/layout/elk_svg_renderer.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Layout
+    # Renders a laid-out Elkrb::Graph (nodes positioned by the layout) as
+    # standalone SVG: rounded-rect nodes with text-line labels and
+    # polyline edges with per-type arrow markers.
+    class ElkSvgRenderer
+      include ElkSvgMarkers
+
+      EDGE_STROKE = ElkSvgMarkers::EDGE_STROKE
+
+      HEADER = <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="%<width>s" height="%<height>s" viewBox="0 0 %<width>s %<height>s">
+      XML
+      NODE_FILL = '#f8f8f8'
+      NODE_STROKE = '#333333'
+
+      def render(graph)
+        @graph = graph
+        @out = +''
+        @out << format(HEADER, width: bounds_width, height: bounds_height)
+        @out << "<defs>\n#{defs}\n</defs>\n"
+        nodes
+        edges
+        @out << "</svg>\n"
+        @out
+      end
+
+      private
+
+      def nodes
+        @graph.children.each { |node| render_node(node) }
+      end
+
+      def render_node(node)
+        @out << %(<g transform="translate(#{node.x.to_i},#{node.y.to_i})">)
+        @out << node_rect(node)
+        node.labels.each_with_index { |label, i| @out << node_label(label, i) }
+        @out << '</g>'
+      end
+
+      def node_rect(node)
+        %(<rect width="#{node.width.to_i}" height="#{node.height.to_i}" rx="6" ) +
+          %(fill="#{NODE_FILL}" stroke="#{NODE_STROKE}"/>)
+      end
+
+      def node_label(label, index)
+        y = ((index + 0.7) * ElkGraphBuilder::LINE_HEIGHT).round(1)
+        weight = index.zero? ? ' font-weight="bold"' : ''
+        %(<text x="7" y="#{y}" font-family="Helvetica" font-size="12"#{weight}>#{escape(label.text)}</text>)
+      end
+
+      def edges
+        @graph.edges.each { |edge| render_edge(edge) }
+      end
+
+      def render_edge(edge)
+        points = edge_points(edge)
+        return if points.empty?
+
+        @out << edge_polyline(edge, points)
+        edge_label(edge, points)
+      end
+
+      def edge_polyline(edge, points)
+        pts = points.map { |p| "#{p.x.round(1)},#{p.y.round(1)}" }.join(' ')
+        %(<polyline fill="none" stroke="#{EDGE_STROKE}" marker-end="url(##{arrow_marker(edge)})" points="#{pts}"/>)
+      end
+
+      def edge_label(edge, points)
+        label = Array(edge.labels).first
+        return unless label&.text
+
+        @out << edge_label_text(label, edge_anchor(points))
+      end
+
+      def edge_anchor(points)
+        mid = points[points.size / 2]
+        { x: (mid.x + 4).round(1), y: (mid.y - 4).round(1) }
+      end
+
+      def edge_label_text(label, anchor)
+        %(<text x="#{anchor[:x]}" y="#{anchor[:y]}" font-family="Helvetica" ) +
+          %(font-size="10" fill="#{EDGE_STROKE}">#{escape(label.text)}</text>)
+      end
+
+      def edge_points(edge)
+        sections = Array(edge.sections)
+        return [] if sections.empty?
+
+        points = [sections.first.start_point]
+        sections.each do |section|
+          points.concat(Array(section.bend_points))
+          points << section.end_point
+        end
+        points.compact
+      end
+
+      def bounds_width
+        extent(:x, :width) + 20
+      end
+
+      def bounds_height
+        extent(:y, :height) + 20
+      end
+
+      def extent(pos, size)
+        values = @graph.children.map { |n| n.public_send(pos).to_f + n.public_send(size).to_f }
+        [values.max || 0, 0].max.round
+      end
+
+      def escape(text)
+        text.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+      end
+    end
+  end
+end

data/lib/lutaml/lml/layout/graph_viz_engine.rb

@@ -7,7 +7,7 @@ module Lutaml
   module Layout
     class GraphVizEngine < Engine
       def render(type)
-        Open3.popen3("dot -T#{type}") do |stdin, stdout, _stderr, _wait|
+        Open3.popen3("dot", "-T#{type}") do |stdin, stdout, _stderr, _wait|
           stdout.binmode
           stdin.puts(input)
           stdin.close

data/lib/lutaml/lml/layout.rb

@@ -4,5 +4,9 @@ module Lutaml
   module Layout
     autoload :Engine, "lutaml/lml/layout/engine"
     autoload :GraphVizEngine, "lutaml/lml/layout/graph_viz_engine"
+    autoload :ElkEngine, "lutaml/lml/layout/elk_engine"
+    autoload :ElkGraphBuilder, "lutaml/lml/layout/elk_graph_builder"
+    autoload :ElkSvgRenderer, "lutaml/lml/layout/elk_svg_renderer"
+    autoload :ElkSvgMarkers, "lutaml/lml/layout/elk_svg_markers"
   end
 end

data/lib/lutaml/lml/model_compiler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Lutaml
   module Lml
     class ModelCompiler
@@ -7,9 +9,13 @@ module Lutaml
 
       TYPE_MAP = {
         'String' => :string,
+        'string' => :string,
         'Integer' => :integer,
+        'integer' => :integer,
         'Boolean' => :boolean,
+        'boolean' => :boolean,
         'Float' => :float,
+        'float' => :float,
         'Date' => :date,
         'date_time' => :date_time,
         'DateTime' => :date_time,
@@ -21,13 +27,17 @@ module Lutaml
       # declarations. Anything else must parse as an Integer.
       UNBOUNDED_TOKENS = %w[* n N unbounded].freeze
 
-      def initialize(namespace: nil, artifact_paths: {})
+      def initialize(namespace: nil, artifact_paths: {}, default_artifact: nil)
         @namespace = namespace
         @artifact_paths = artifact_paths
+        @default_artifact = default_artifact
         @compiled = {}
         @forward_refs = {}
         @enum_names = Set.new
         @enum_classes = {}
+        @declared_namespaces = []
+        @serialization_mappings = []
+        @namespace_classes = {}
       end
 
       def compile(input)
@@ -135,6 +145,20 @@ module Lutaml
         klass.new(**attrs)
       end
 
+      # An inline map's cargo is {key_value_map: [{key:, value:}, ...]} with
+      # literal-shaped keys/values ({string: ..}, {number: ..}, {boolean: ..});
+      # materialize it as a plain Hash (issue #17: maps hydrate as data).
+      def hydrate_map_cargo(cargo)
+        cargo[:key_value_map].to_h do |pair|
+          [hydrate_scalar(pair[:key]).to_s, hydrate_scalar(pair[:value])]
+        end
+      end
+
+      def hydrate_scalar(literal)
+        literal = literal.value if literal.respond_to?(:value)
+        literal.is_a?(Hash) ? literal.values.first : literal
+      end
+
       def resolve_instance_type(instance)
         # L6: the explicit isa keyword is the type override; a `type`
         # attribute is ordinary data (pubid's identifier-kind field)
@@ -168,7 +192,14 @@ module Lutaml
       end
 
       def resolve_instance_value(value, nested, attr_def = nil)
+        value = value.value if value.respond_to?(:value)
+        return hydrate_map_cargo(value) if value.is_a?(Hash) && value.key?(:key_value_map)
+
         if nested.any?
+          # A scalar attribute with a single nested instance hydrates to
+          # the object itself; the declaration is the truth (issue #17).
+          return hydrate_instance(nested.first) if !attr_def&.collection && nested.one?
+
           nested.map { |i| hydrate_instance(i) }
         elsif value.is_a?(Array)
           value
@@ -183,14 +214,30 @@ module Lutaml
       end
 
       def compile_document(doc)
+        @declared_namespaces = Array(doc.namespaces)
+        @serialization_mappings = Array(doc.serialization_mappings)
         doc.classes.each { |c| compile_class(c) }
+        hoist_class_serialization_mappings(doc)
         doc.enums.each { |e| compile_enum(e) }
         doc.data_types.each { |dt| compile_data_type(dt) }
         resolve_forward_references
         apply_xml_mappings
+        apply_key_value_mappings
         register_string_formats(doc)
       end
 
+      # In-class `mapping <format> { … }` is the shortcut for a sibling
+      # mapping targeting the enclosing class; hoist them so emission is
+      # uniform.
+      def hoist_class_serialization_mappings(doc)
+        (Array(doc.classes) + Array(doc.data_types)).each do |klass_def|
+          Array(klass_def.serialization_mappings).each do |mapping|
+            mapping.target = klass_def.name.to_s
+            @serialization_mappings << mapping
+          end
+        end
+      end
+
       def resolve_forward_references
         @forward_refs.each do |class_name, deferred_attrs|
           klass = @compiled[class_name]
@@ -232,6 +279,7 @@ module Lutaml
 
       def compile_enum(enum_def)
         name = enum_def.name.to_s
+        expand_from_table(enum_def)
         values = extract_enum_values(enum_def)
 
         payload_fields = Array(enum_def.member_fields).map(&:name).map(&:to_s)
@@ -246,7 +294,8 @@ module Lutaml
         end
 
         values.each do |value|
-          compiled_klass.define_singleton_method(value.name) do
+          accessor = value.name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
+          compiled_klass.define_singleton_method(accessor) do
             new({ value: value.name, description: value.description }.merge(value.payload || {}))
           end
         end
@@ -297,6 +346,9 @@ module Lutaml
         @compiled.each do |name, klass|
           next if @enum_names.include?(name)
 
+          custom = serialization_mapping_for(name, 'xml')
+          next apply_custom_xml_mapping(klass, custom) if custom
+
           apply_xml_mapping(klass, name)
         end
       end
@@ -306,23 +358,133 @@ module Lutaml
         return if attr_names.empty?
 
         klass.xml do |mapping|
-          mapping.root(root_name)
+          mapping.element(root_name)
           attr_names.each do |attr_name|
             mapping.map_element(attr_name.to_s, to: attr_name)
           end
         end
       end
 
+      # RS 3010 extension: key-value mapping blocks for the declared
+      # formats (yaml/json/toml share lutaml-model's key_value model).
+      def apply_key_value_mappings
+        @compiled.each do |name, klass|
+          next if @enum_names.include?(name)
+
+          custom = serialization_mapping_for(name, 'key_value')
+          apply_custom_key_value_mapping(klass, custom) if custom
+        end
+      end
+
+      def serialization_mapping_for(target, format)
+        @serialization_mappings.find do |m|
+          m.target.to_s == target && serialization_format(m.format) == format
+        end
+      end
+
+      def serialization_format(format)
+        %w[yaml json toml].include?(format.to_s) ? 'key_value' : format.to_s
+      end
+
+      def apply_custom_xml_mapping(klass, mapping)
+        check_namespace_ambiguity(mapping)
+        ns_class = namespace_class_for(mapping.namespace_ref) if mapping.namespace_ref
+        rule_ns = mapping.rules.select { |r| r.kind == 'namespace' }
+                               .to_h { |r| [r.field, namespace_class_for(r.field)] }
+        klass.xml do |m|
+          m.element(mapping.element_name) if mapping.element_name
+          m.namespace(ns_class) if ns_class
+          m.mixed_content if mapping.mixed_content
+          mapping.rules.each do |rule|
+            case rule.kind
+            when 'element' then m.map_element(rule.wire, to: rule.field.to_sym)
+            when 'attribute' then m.map_attribute(rule.wire, to: rule.field.to_sym)
+            when 'content' then m.map_content(to: rule.field.to_sym)
+            when 'namespace' then m.namespace(rule_ns[rule.field])
+            end
+          end
+        end
+      end
+
+      def apply_custom_key_value_mapping(klass, mapping)
+        formats = mapping.format.to_s == 'key_value' ? %w[yaml json toml] : [mapping.format.to_s]
+        klass.instance_eval do
+          formats.each do |format|
+            public_send(format) do |m|
+              mapping.rules.each do |rule|
+                case rule.kind
+                when 'map' then m.map(rule.wire, to: rule.field.to_sym)
+                when 'key' then m.map_key(to_instance: rule.field.to_sym)
+                when 'value'
+                  if rule.mode == 'as_attribute'
+                    m.map_value(as_attribute: rule.field.to_sym)
+                  else
+                    m.map_value(to_instance: rule.field.to_sym)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def check_namespace_ambiguity(mapping)
+        return unless mapping.format.to_s == 'xml'
+        return if mapping.namespace_ref || @declared_namespaces.length < 2
+
+        raise ArgumentError,
+              "mapping #{mapping.format} #{mapping.target}: ambiguous default " \
+              "namespace — #{@declared_namespaces.length} namespaces in scope " \
+              "(#{@declared_namespaces.map(&:name).join(', ')}); declare one with " \
+              "'namespace <name>'"
+      end
+
+      def namespace_class_for(ref)
+        return nil if ref.nil?
+
+        require 'lutaml/xml/namespace' unless defined?(Lutaml::Xml::Namespace)
+
+        ns_class = @namespace_classes[ref]
+        return ns_class if ns_class
+
+        declared = @declared_namespaces.find { |ns| ns.name.to_s == ref }
+        raise ArgumentError, "unknown namespace '#{ref}'" unless declared
+
+        ns_class = Class.new(Lutaml::Xml::Namespace)
+        uri = declared.uri
+        prefix = declared.prefix.to_s
+        ns_class.define_singleton_method(:uri) { uri }
+        ns_class.define_singleton_method(:prefix_default) { prefix }
+        @namespace_classes[ref] = ns_class
+      end
+
       def build_attributes(klass_def)
         Array(klass_def.attributes).map do |attr|
           attr_name = attr.name.to_sym
-          raw_type = attr.type.to_s
+          raw_type = resolve_values_type(klass_def, attr)
           type = resolve_type(raw_type)
           options = build_options(attr)
           [attr_name, raw_type, type, options]
         end
       end
 
+      # RS 3001 §Attribute: `values { v1, v2 }` expands into an anonymous
+      # enum baked from the inline set; the attribute is typed with it.
+      def resolve_values_type(klass_def, attr)
+        return attr.type.to_s unless attr.value_set&.any?
+
+        enum_name = anonymous_enum_name(klass_def.name, attr.name)
+        members = attr.value_set.map { |v| ::Lutaml::Lml::TopElementAttribute.new(name: v.to_s) }
+        compile_enum(::Lutaml::Lml::Enum.new(name: enum_name, attributes: members))
+        enum_name
+      end
+
+      def anonymous_enum_name(class_name, attr_name)
+        base = class_name.to_s.split('::').last
+        attr_part = attr_name.to_s.split('_').map(&:capitalize).join
+        "#{base}#{attr_part}Values"
+      end
+
       def resolve_type(type_name)
         if TYPE_MAP.key?(type_name)
           TYPE_MAP[type_name]
@@ -391,18 +553,74 @@ module Lutaml
         raise ValidationError, "Unrecognized cardinality token: #{val.inspect}"
       end
 
+      # L7a point 3: from_table members are baked at compile time — the
+      # artifact table's rows become the values, validated against the
+      # declared member_fields (unknown field = error; missing = nil).
+      # The member name comes from the row's "name" column.
+      def expand_from_table(enum_def)
+        return unless enum_def.from_table_name
+
+        rows = artifact_table_rows(enum_def)
+        known = Array(enum_def.member_fields).map { |f| f.name.to_s }
+        rows.each do |row|
+          row = row.transform_keys(&:to_s)
+          member_name = row.fetch('name')
+          unknown = row.keys - known - ['name']
+          if unknown.any?
+            raise ArgumentError,
+                  "enum #{enum_def.name}: table row #{member_name.inspect} has " \
+                  "undeclared fields #{unknown.inspect} (declared: #{known.inspect})"
+          end
+          payload = row.slice(*known).compact
+          enum_def.attributes << TopElementAttribute.new(
+            name: member_name,
+            properties: payload.map do |field, value|
+              TopElementAttribute.new(name: field, value: value)
+            end
+          )
+        end
+      end
+
+      def artifact_table_rows(enum_def)
+        reference = enum_def.from_table_artifact || @default_artifact
+        path = artifact_path_for(reference.to_s)
+        unless path
+          raise ArgumentError,
+                "enum #{enum_def.name}: from_table artifact #{reference.inspect} not found"
+        end
+
+        envelope = JSON.parse(File.read(path))
+        table = envelope['tables'].to_h[enum_def.from_table_name]
+        unless table
+          raise ArgumentError,
+                "enum #{enum_def.name}: table #{enum_def.from_table_name.inspect} " \
+                "not found in artifact #{reference.inspect}"
+        end
+
+        table['rows'].to_a
+      end
+
       def extract_enum_values(enum_def)
         member_fields = Array(enum_def.member_fields).map do |f|
           [f.name.to_s, f.type.to_s]
         end
         enum_def.attributes.map do |attr|
-          description = Array(attr.attributes).find do |nested|
-            nested.name == 'description'
-          end
+          description = member_description(attr)
           payload = extract_member_payload(attr)
           validate_member_payload(enum_def, attr, payload, member_fields)
-          EnumValue.new(attr.name.to_s, description&.type, payload)
+          EnumValue.new(attr.name.to_s, description, payload)
+        end
+      end
+
+      # The member description rides a nested attribute named `description`
+      # (bare-member form) or `definition` (RS 3001 `value` blocks); both
+      # spellings are accepted.
+      def member_description(attr)
+        nested = Array(attr.attributes).find do |n|
+          %w[description definition].include?(n.name.to_s)
         end
+        text = nested&.type || nested&.definition || nested&.value
+        text.is_a?(Hash) && text.key?(:string) ? text[:string] : text
       end
 
       # L7a: per-member payload lines ride the keyword-attribute
@@ -457,18 +675,12 @@ module Lutaml
       def register_string_formats(doc)
         defaults = doc.packages.flat_map(&:default_string_formats)
         doc.classes.each do |class_def|
-          Array(class_def.string_formats).each do |fmt|
-            register_string_format(class_def.name.to_s, fmt)
-          end
-          next if Array(class_def.string_formats).any? do |f|
-            f.format == defaults.first&.format
-          end
+          declared = Array(class_def.string_formats)
+          declared.each { |fmt| register_string_format(class_def.name.to_s, fmt) }
 
-          defaults.each do |fmt|
-            next if Array(class_def.string_formats).map(&:format).include?(fmt.format)
-
-            register_string_format(class_def.name.to_s, fmt)
-          end
+          declared_formats = declared.map(&:format)
+          defaults.reject { |fmt| declared_formats.include?(fmt.format) }
+                  .each { |fmt| register_string_format(class_def.name.to_s, fmt) }
         end
       end
 

data/lib/lutaml/lml/models/data_type.rb

@@ -7,6 +7,7 @@ module Lutaml
       attribute :name, :string
       attribute :wire_mappings, "Lutaml::Lml::Mapping", collection: true, default: -> { [] }
       attribute :derived_fields, "Lutaml::Lml::DerivedField", collection: true, default: -> { [] }
+      attribute :serialization_mappings, "Lutaml::Lml::SerializationMapping", collection: true, default: -> { [] }
       attribute :definition, Lutaml::Lml::Types::TextType
       attribute :keyword, :string, default: "dataType"
       attribute :stereotype, :string, collection: true, default: -> { [] }

data/lib/lutaml/lml/models/document.rb

@@ -16,6 +16,11 @@ module Lutaml
       attribute :data_types, "Lutaml::Lml::DataType", collection: true, default: -> { [] }
       attribute :enums, "Lutaml::Lml::Enum", collection: true, default: -> { [] }
       attribute :packages, "Lutaml::Lml::Package", collection: true, default: -> { [] }
+      attribute :namespaces, "Lutaml::Lml::Namespace", collection: true, default: -> { [] }
+      # `models <Name> version "x.y.z"` headers: model name -> declared
+      # version (issue #16, the co-release identity line).
+      attribute :model_versions, :hash, default: -> { {} }
+      attribute :serialization_mappings, "Lutaml::Lml::SerializationMapping", collection: true, default: -> { [] }
       attribute :primitives, "Lutaml::Lml::PrimitiveType", collection: true, default: -> { [] }
       attribute :associations, "Lutaml::Lml::Association", collection: true, default: -> { [] }
       attribute :diagrams, "Lutaml::Lml::Diagram", collection: true, default: -> { [] }
@@ -25,6 +30,32 @@ module Lutaml
       attribute :instance, "Lutaml::Lml::Instance"
       attribute :requires, :string, collection: true, default: -> { [] }
       attribute :instances, "Lutaml::Lml::InstanceCollection"
+
+      # Repeated `instances` blocks accumulate (issue #17): instances,
+      # imports, exports and collections concat; a duplicate collection
+      # name is an error (same name is a mistake, distinct names intent).
+      def instances=(collection)
+        collection = Lutaml::Lml::InstanceCollection.new(**collection) if collection.is_a?(Hash)
+        if @instances.nil? || (@instances.instances.empty? && @instances.imports.empty? &&
+            @instances.exports.empty? && @instances.collections.empty?)
+          @instances = collection
+        else
+          merge_instances(collection)
+        end
+      end
+
+      def merge_instances(incoming)
+        names = @instances.collections.map(&:name)
+        incoming.collections.each do |collection|
+          if names.include?(collection.name)
+            raise Lutaml::Lml::Error, "duplicate collection name '#{collection.name}'"
+          end
+        end
+        @instances.instances.concat(incoming.instances)
+        @instances.imports.concat(incoming.imports)
+        @instances.exports.concat(incoming.exports)
+        @instances.collections.concat(incoming.collections)
+      end
       attribute :view_imports, "Lutaml::Lml::ViewImport", collection: true, default: -> { [] }
       attribute :show_filter, "Lutaml::Lml::ViewFilter"
       attribute :hide_filter, "Lutaml::Lml::ViewFilter"

data/lib/lutaml/lml/models/enum.rb

@@ -18,6 +18,8 @@ module Lutaml
                                                                    default: -> { [] }
       attribute :modifier, :string
       attribute :member_fields, "Lutaml::Lml::MemberField", collection: true, default: -> { [] }
+      attribute :from_table_name, :string
+      attribute :from_table_artifact, :string
       attribute :operations, "Lutaml::Lml::Operation", collection: true, default: -> { [] }
       attribute :values, "Lutaml::Lml::Value", collection: true, default: -> { [] }
 

data/lib/lutaml/lml/models/instance.rb

@@ -3,6 +3,7 @@
 module Lutaml
   module Lml
     class Instance < Lutaml::Model::Serializable
+      attribute :name, :string
       attribute :type, :string
       attribute :isa, :string
       attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true

data/lib/lutaml/lml/models/instance_collection.rb

@@ -3,6 +3,7 @@
 module Lutaml
   module Lml
     class InstanceCollection < Lutaml::Model::Serializable
+      attribute :name, :string
       attribute :instances, "Lutaml::Lml::Instance", collection: true, default: []
       attribute :imports, "Lutaml::Lml::InstancesImport", collection: true, default: []
       attribute :exports, "Lutaml::Lml::InstancesExport", collection: true, default: []

data/lib/lutaml/lml/models/mapping_rule.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # One line of a serialization mapping: what kind of mapping (element,
+    # attribute, content, map, key, value), the serialization-side wire
+    # name, the model attribute it binds, and the qualifier mode for
+    # key/value collections (to_instance, as_attribute).
+    class MappingRule < Lutaml::Model::Serializable
+      attribute :kind, :string
+      attribute :wire, :string
+      attribute :field, :string
+      attribute :mode, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/namespace.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # RS 3010 extension: a declared XML namespace (uri + optional prefix).
+    # The compiler generates the corresponding Lutaml::Model::XmlNamespace
+    # subclass for the compiled model namespace.
+    class Namespace < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :uri, :string
+      attribute :prefix, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/operation_parameter.rb

@@ -6,6 +6,7 @@ module Lutaml
       attribute :name, :string
       attribute :type, :string
       attribute :direction, :string, default: "in"
+      attribute :default, :string
     end
   end
 end

data/lib/lutaml/lml/models/reference.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # RS 3001 par. Value type: a reference to another instance
+    # (`reference:(path)` / `ref:(path)`). The attribute's value slot keeps
+    # its primitive wire shape (a `reference` hash); this is the typed
+    # domain view of it, built at one canonical point
+    # (TopElementAttribute#reference) so validation and serialization
+    # consume structured references instead of re-sniffing hashes.
+    class Reference < Lutaml::Model::Serializable
+      attribute :path, :string
+
+      def segments
+        @segments ||= path.to_s.split('.')
+      end
+
+      def to_s
+        path.to_s
+      end
+    end
+  end
+end

data/lib/lutaml/lml/models/serialization_mapping.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # RS 3010 extension: a serialization mapping declared separately from
+    # its class and linked by target name —
+    #   mapping xml Ceramic { element "ceramic" … }
+    class SerializationMapping < Lutaml::Model::Serializable
+      attribute :format, :string
+      attribute :target, :string
+      attribute :element_name, :string
+      attribute :namespace_ref, :string
+      attribute :mixed_content, :boolean, default: false
+      attribute :rules, 'Lutaml::Lml::MappingRule', collection: true, default: -> { [] }
+    end
+  end
+end