lutaml-model 0.8.127 → 0.8.129

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e11de7c2a53b5c720a4d8066af0a1b0bfef2107e6c853bfb441d478b32c0d794
-  data.tar.gz: 6f8e67b8df0ab6ee2635b3b2c83a7dc86332e7883d951df45f8422f303b1ca61
+  metadata.gz: 6903f41ec929cb64ce2450b6979f832e0a832f8afbbe82a134af3db157d2fdd8
+  data.tar.gz: 3d2f61efc2e609ade7d440994d318c1b190255c243f33ec96538de2a4cda5774
 SHA512:
-  metadata.gz: 447cbac13172eab2c4fcfa38f03f6777a164dfd31108e9aa3ce46ca8eed631863c9bd584f88a83dae005d80836c6be5ee4ff046676a77492a8c52f509b2cb4e8
-  data.tar.gz: 7b13afe6b4d08b89b4e79143599ac90da0fb6536583f8e315e829f66a6579e6fd22ed8aa87acc46359e06741eada456f7e5ee97db897df5e172fbcb4c43705db
+  metadata.gz: 7f82b33a1e8ac555aa6c756007da45a99dc3e506fd58c1f780446c112397314b3a76b0978566dc3c3279651e76701f0537b87dd1c700accaeb77f789497e20dc
+  data.tar.gz: 1100e41da62097636496a5fe31d1ac6a77f55ac491a8a3313eb96dfa4ceda55c52ba92166eda902f07bceae1ace17fd2224c2190c9b9792c5ca76ff4ce29293f

data/README.adoc

@@ -857,8 +857,16 @@ Every type has a corresponding Ruby class and a serialization format type.
 
 The NIST Metaschema simple data types are supported as first-class value
 types (https://pages.nist.gov/metaschema/specification/datatypes/). Each
-type carries the normative metaschema-datatypes pattern and answers
-`valid?` for a value; casting follows the lenient base-type behavior.
+type carries the normative metaschema-datatypes pattern, answers `valid?`
+for a value, and declares it as a restriction facet: attributes typed
+with these types are validated by `model.validate`, and schema
+generation emits the pattern/bounds as restriction facets in every
+supported schema language — `xs:pattern`/`xs:minInclusive` in generated
+XSD, `pattern`/`minimum` plus the NIST `format` keywords (`ipv4`,
+`ipv6`, `email`, `uri-reference`, `duration`, `date`, `date-time`) in
+generated JSON and YAML schemas. Casting follows the lenient
+base-type behavior; TOML has no schema language, so its surface for
+these types is the cast/serialize lane.
 
 .Source types
 [cols="3,4,2"]

data/docs/_pages/value_types.adoc

@@ -35,6 +35,19 @@ Every type has a corresponding Ruby class and a serialization format type.
 | `:qname`              | `Lutaml::Model::Type::QName` | `xs:QName`    | `string`  | `string`  | `"prefix:localName"`
 | `:base64_binary`      | `String`                 | `xs:base64Binary` | `string`  | `string`  | `"SGVsbG8gV29ybGQ="`
 | `:hex_binary`         | `String`                 | `xs:hexBinary`    | `string`  | `string`  | `"48656c6c6f"`
+| `:email_address`      | `String`                 | `xs:string`       | `string`  | `string`  | `"user@example.com"`
+| `:hostname`           | `String`                 | `xs:string`       | `string`  | `string`  | `"example.com"`
+| `:ip_v4_address`      | `String`                 | `xs:string`       | `string`  | `string`  | `"192.168.0.1"`
+| `:ip_v6_address`      | `String`                 | `xs:string`       | `string`  | `string`  | `"2001:db8::2:1"`
+| `:token`              | `String`                 | `xs:string`       | `string`  | `string`  | `"label_3.v2"`
+| `:uri_reference`      | `String`                 | `xs:anyURI`       | `string`  | `string`  | `"path/to/resource"`
+| `:uuid`               | `String`                 | `xs:string`       | `string`  | `string`  | `"a3bb189e-8bf9-4888-9912-ace4e6543002"`
+| `:non_negative_integer` | `Integer`              | `xs:nonNegativeInteger` | `number` | `integer` | `7`
+| `:positive_integer`   | `Integer`                | `xs:positiveInteger` | `number` | `integer` | `7`
+| `:date_with_timezone` | `Date`/`DateTime`        | `xs:date`         | `string`  | `string`  | `"2019-12-02-08:00"`
+| `:date_time_with_timezone` | `DateTime`         | `xs:dateTime`     | `string`  | `string`  | `"2019-12-02T16:39:57-08:00"`
+| `:day_time_duration`  | `Lutaml::Model::Type::Duration` | `xs:dayTimeDuration` | `string` | `string` | `"P1DT12H45M"`
+| `:year_month_duration` | `Lutaml::Model::Type::Duration` | `xs:yearMonthDuration` | `string` | `string` | `"P1Y6M"`
 | `:hash`               | `Hash`                   | complex element   | object    | map       | `{key: "value"}`
 | (nil value)           | `nil`                    | `xs:anyType`      | `null`    | `null`    | `null`
 | `{ ref: [Model, :attr] }` | `Reference`          | `xs:string`       | `string`  | `string`  | `"model-id"`
@@ -120,6 +133,56 @@ puts event.start_date.class
 
 
 [[xml-namespace-types]]
+=== NIST Metaschema types
+
+The NIST Metaschema simple data types are supported as first-class value
+types (https://pages.nist.gov/metaschema/specification/datatypes/). Each
+type carries the normative metaschema-datatypes pattern, answers `valid?`
+for a value, and declares it as a restriction facet: attributes typed
+with these types are validated by `model.validate`, and schema
+generation emits the pattern/bounds as restriction facets in every
+supported schema language — `xs:pattern`/`xs:minInclusive` in generated
+XSD, `pattern`/`minimum` plus the NIST `format` keywords (`ipv4`,
+`ipv6`, `email`, `uri-reference`, `duration`, `date`, `date-time`) in
+generated JSON and YAML schemas. Casting follows the lenient
+base-type behavior; TOML has no schema language, so its surface for
+these types is the cast/serialize lane.
+
+.Metaschema type codes and their restrictions
+[cols="3,4,2"]
+|===
+| Type code | Metaschema datatype | Restriction
+
+| `:email_address` | `email-address` | contains an at-sign
+| `:hostname` | `hostname` | non-empty, trimmed
+| `:ip_v4_address` | `ip-v4-address` | dotted-quad IPv4
+| `:ip_v6_address` | `ip-v6-address` | RFC3513 IPv6 (incl. zones, embedded IPv4)
+| `:token` | `token` | NMTOKEN-like letter/number/punctuation run
+| `:uri_reference` | `uri-reference` | relative or absolute URI reference
+| `:uuid` | `uuid` | RFC4122 UUID, version 4 or 5
+| `:non_negative_integer` | `non-negative-integer` | integer >= 0
+| `:positive_integer` | `positive-integer` | integer >= 1
+| `:date_with_timezone` | `date-with-timezone` | date with `Z` or offset
+| `:date_time_with_timezone` | `date-time-with-timezone` | date-time with `Z` or offset
+| `:day_time_duration` | `day-time-duration` | duration without years/months
+| `:year_month_duration` | `year-month-duration` | duration without time components
+|===
+
+.Using metaschema type attributes
+[example]
+====
+[source,ruby]
+----
+class Asset < Lutaml::Model::Serializable
+  attribute :id, :uuid
+  attribute :owner, :email_address
+  attribute :host, :hostname
+  attribute :address, :ip_v4_address
+  attribute :renewal, :year_month_duration
+end
+----
+====
+
 === Additional XSD types
 
 Lutaml::Model supports additional XSD types for specialized data handling:
@@ -1325,6 +1388,45 @@ All built-in types have default XSD type mappings:
 | [`Type::HexBinary`](lib/lutaml/model/type/hex_binary.rb)
 | `xs:hexBinary`
 
+| [`Type::EmailAddress`](lib/lutaml/model/type/email_address.rb)
+| `xs:string`
+
+| [`Type::Hostname`](lib/lutaml/model/type/hostname.rb)
+| `xs:string`
+
+| [`Type::IpV4Address`](lib/lutaml/model/type/ip_v4_address.rb)
+| `xs:string`
+
+| [`Type::IpV6Address`](lib/lutaml/model/type/ip_v6_address.rb)
+| `xs:string`
+
+| [`Type::Token`](lib/lutaml/model/type/token.rb)
+| `xs:string`
+
+| [`Type::UriReference`](lib/lutaml/model/type/uri_reference.rb)
+| `xs:anyURI`
+
+| [`Type::Uuid`](lib/lutaml/model/type/uuid.rb)
+| `xs:string`
+
+| [`Type::NonNegativeInteger`](lib/lutaml/model/type/non_negative_integer.rb)
+| `xs:nonNegativeInteger`
+
+| [`Type::PositiveInteger`](lib/lutaml/model/type/positive_integer.rb)
+| `xs:positiveInteger`
+
+| [`Type::DateWithTimezone`](lib/lutaml/model/type/date_with_timezone.rb)
+| `xs:date`
+
+| [`Type::DateTimeWithTimezone`](lib/lutaml/model/type/date_time_with_timezone.rb)
+| `xs:dateTime`
+
+| [`Type::DayTimeDuration`](lib/lutaml/model/type/day_time_duration.rb)
+| `xs:dayTimeDuration`
+
+| [`Type::YearMonthDuration`](lib/lutaml/model/type/year_month_duration.rb)
+| `xs:yearMonthDuration`
+
 | [`Type::Hash`](lib/lutaml/model/type/hash.rb)
 | `xs:anyType`
 

data/lib/lutaml/key_value/transform.rb

@@ -215,18 +215,26 @@ module Lutaml
 
         mapping = model_class.mappings_for(format, register)
         return false if mapping.nil?
-        # The catch-all collect runs on the interpretive walk only —
-        # the compiled hydration must not skip unknown keys silently.
-        return false if mapping.unmapped_attribute
 
         attrs = model_class.attributes(register)
+        # The catch-all compiles as a row: unclaimed document keys are
+        # collected into the target attribute after the rules hydrate,
+        # mirroring the interpretive collect's position and merge. A
+        # typo'd target raises here, exactly as the walk raises at
+        # first parse.
+        unmapped_target = mapping.unmapped_attribute
+        if unmapped_target && !attrs.key?(unmapped_target)
+          raise ArgumentError,
+                "map_unmapped target :#{unmapped_target} is not a " \
+                "declared attribute of #{model_class}"
+        end
         rows = nil
+        claimed = nil
         mapping.mappings(register).each do |rule|
           eligible = !rule.name.nil? && !rule.multiple_mappings? &&
             rule.delegate.nil? &&
             !rule.has_custom_method_for_deserialization? &&
             !rule.raw_mapping? && !rule.root_mapping? &&
-            !rule.hash_mappings && rule.child_mappings.nil? &&
             rule.when_attribute.empty? &&
             !(if rule.polymorphic.is_a?(::Hash)
                 !rule.polymorphic.empty?
@@ -252,6 +260,24 @@ module Lutaml
           return false if Lutaml::Model::GlobalContext.context(register)
             .substitution_for(type).any?
 
+          if rule.hash_mappings
+            # #1003: compiled child-map row. The compiled ChildMapPlan
+            # reproduces translate_mappings' per-child lookups; shapes
+            # the compile cannot cover (unmappable child attribute,
+            # singular target, non-model child type) keep the whole
+            # model interpretive.
+            return false unless attr.collection? &&
+              type.is_a?(Class) && type.include?(Lutaml::Model::Serialize)
+
+            child_plan = compile_group_child_plan(type, format, register,
+                                                  rule.hash_mappings)
+            return false unless child_plan
+
+            rows ||= []
+            rows << [rule, attr, :child_map, child_plan, nil, nil]
+            next
+          end
+
           if type.is_a?(Class) && type.include?(Lutaml::Model::Serialize)
             child_register = Lutaml::Model::Register
               .resolve_for_child(type, register)
@@ -272,10 +298,45 @@ module Lutaml
             return false
           end
         end
+        if unmapped_target
+          claimed = {}
+          mapping.mappings(register).each do |rule|
+            Array(rule.name).each { |name| claimed[name.to_s] = true } if rule.name
+          end
+          claimed.freeze
+          (rows ||= []) << [nil, nil, :unmapped, unmapped_target, claimed,
+                            nil]
+        end
         # No eligible rows at all (empty mapping) — nothing to gain.
         rows
       end
 
+      # Class-level twin of the walk's child-map compile: the registry
+      # lookups (child rules, per-attribute wire names, path casts)
+      # resolve once per plan instead of once per node per child. nil
+      # keeps the model interpretive (preserving the walk's raise
+      # timing for declaration errors).
+      def self.compile_group_child_plan(child_class, format, register,
+child_mappings)
+        child_rules = child_class.mappings_for(format, register)
+        wire_names = {}
+        paths = {}
+        child_mappings.each do |attr_name, path|
+          attr_rule = child_rules.find_by_to!(attr_name)
+          wire_names[attr_name] = attr_rule.from.to_s
+          paths[attr_name] = case path
+                             when :key then :key
+                             when :value then :value
+                             else Array(path).map(&:to_s).freeze
+                             end
+        end
+        ChildMapPlan.new(child_mappings, wire_names, paths,
+                         child_mappings.values == [:key], child_rules,
+                         child_class)
+      rescue Lutaml::Model::NoMappingFoundError
+        nil
+      end
+
       # Build values bottom-up, then ONE instance per model: present
       # keys through the casting setters, ABSENT rules through the real
       # per-rule walk (their extractor/defaults/sentinel semantics are
@@ -289,7 +350,13 @@ module Lutaml
         # Lazy: the present-key hot path never pushes, and this runs
         # once per hydrated model instance.
         absent = nil
+        unmapped = nil
         rows.each do |rule, attr, kind, type, child_rows, child_register|
+          if kind == :unmapped
+            unmapped = [type, child_rows]
+            next
+          end
+
           # One hash pass per row: fetch with a sentinel distinguishes
           # absent keys from present-nil values (both read as nil), so
           # the separate string_or_symbol_key? probe goes away.
@@ -299,6 +366,33 @@ module Lutaml
             next
           end
 
+          if kind == :child_map
+            # Compiled translate_mappings (#1003): per-child lookups
+            # are plan constants. Children hydrate through their own
+            # compiled walk (the mappings: option routes them there);
+            # parent/root wiring rides the shared children pass. A
+            # non-Hash value falls back to the walk, which owns that
+            # error.
+            return nil unless v.is_a?(::Hash)
+
+            built = []
+            keys_only = type.keys_only && v.values.all?(::Hash)
+            v.each do |child_key, child_value|
+              child_hash = {}
+              type.child_mappings.each_key do |attr_name|
+                child_hash[type.wire_names[attr_name]] =
+                  extract_compiled_child_value(type.paths[attr_name],
+                                               child_key, child_value)
+              end
+              child_hash.update(child_value) if keys_only
+              built << self.class.data_to_model(type.attr_type,
+child_hash, format, { mappings: type.child_rules })
+            end
+            setters << [rule.kv_setter, built]
+            children.concat(built)
+            next
+          end
+
           if kind == :scalar
             setters << [rule.kv_setter, v]
             next
@@ -345,6 +439,20 @@ module Lutaml
           child.lutaml_parent = instance
           child.lutaml_root ||= instance.lutaml_root || instance
         end
+        if unmapped
+          target, claimed = unmapped
+          extras = nil
+          doc.each do |key, value|
+            next if claimed.key?(key.to_s)
+
+            (extras ||= {})[key] = value
+          end
+          if extras
+            existing = instance.public_send(target)
+            merged = existing.is_a?(::Hash) ? existing.merge(extras) : extras
+            instance.public_send(:"#{target}=", merged)
+          end
+        end
         instance
       end
 

data/lib/lutaml/model/schema/generator/property.rb

@@ -96,8 +96,35 @@ module Lutaml
           def get_constraints(attr)
             constraints = {}
 
-            # Add pattern validation
-            constraints["pattern"] = attr.pattern.source if attr.pattern
+            # Add pattern validation (attribute option conjunctive with the
+            # resolved type's restriction facets; a single JSON Schema
+            # pattern cannot express conjunction, mirroring the XSD emitter)
+            patterns = constraint_patterns(attr)
+            if patterns.size > 1
+              raise Lutaml::Model::Error,
+                    "Cannot export #{patterns.size} conjunctive patterns on " \
+                    "#{attr.name} to a single JSON Schema pattern: sibling " \
+                    "patterns are alternatives (OR), and JSON Schema cannot " \
+                    "express conjunction (AND) without allOf, which is not " \
+                    "yet supported."
+            end
+            # Attribute-option patterns export verbatim (author contract);
+            # type-facet patterns carry Ruby \A/\z anchoring, which ECMA
+            # regexes lack — express the full-match intent with ^...$.
+            if (pattern, from_facet = patterns.first)
+              constraints["pattern"] =
+                from_facet ? json_schema_pattern(pattern) : pattern.source
+            end
+
+            # Add the resolved type's restriction facets and format
+            type = attr.type(register)
+            if type.is_a?(Class) && type <= Lutaml::Model::Type::Value
+              facets = type.facets
+              constraints["minimum"] = facets[:min_inclusive] if facets[:min_inclusive]
+              constraints["maximum"] = facets[:max_inclusive] if facets[:max_inclusive]
+              constraints["exclusiveMinimum"] = facets[:min_exclusive] if facets[:min_exclusive]
+              constraints["exclusiveMaximum"] = facets[:max_exclusive] if facets[:max_exclusive]
+            end
 
             # Add default value
             resolved = attr.default_value(register, nil)
@@ -108,21 +135,45 @@ module Lutaml
             # Add enumeration values
             constraints["enum"] = attr.enum_values if attr.enum?
 
+            # Add the format keyword for types that declare one (e.g. the
+            # NIST Metaschema types: ipv4, ipv6, email, uri-reference)
+            format = type.json_schema_format if type.is_a?(Class) &&
+              type <= Lutaml::Model::Type::Value
+            constraints["format"] = format if format
+
             constraints
           end
 
+          def constraint_patterns(attr)
+            patterns = []
+            patterns << [attr.pattern, false] if attr.pattern
+            type = attr.type(register)
+            if type.is_a?(Class) && type <= Lutaml::Model::Type::Value
+              type.facets[:pattern].to_a.each { |re| patterns << [re, true] }
+            end
+            patterns
+          end
+
+          # JSON Schema (ECMA) regexes have no \A/\z; full-match intent is
+          # expressed with ^...$ anchoring (the NIST JSON forms do the same).
+          def json_schema_pattern(regexp)
+            source = regexp.source
+            source = source.delete_prefix('\\A').delete_suffix('\\z')
+            "^#{source}$"
+          end
+
           def polymorphic?(attr)
             Utils.present?(attr.options[:polymorphic])
           end
 
           def get_type(type)
-            {
-              Lutaml::Model::Type::String => "string",
-              Lutaml::Model::Type::Integer => "integer",
-              Lutaml::Model::Type::Boolean => "boolean",
-              Lutaml::Model::Type::Float => "number",
-              Lutaml::Model::Type::Hash => "object",
-            }[type] || "string" # Default to string for unknown types
+            return "integer" if type.is_a?(Class) && type <= Lutaml::Model::Type::Integer
+            return "boolean" if type.is_a?(Class) && type <= Lutaml::Model::Type::Boolean
+            return "number" if type.is_a?(Class) && type <= Lutaml::Model::Type::Float
+            return "number" if type.is_a?(Class) && type <= Lutaml::Model::Type::Decimal
+            return "object" if type.is_a?(Class) && type <= Lutaml::Model::Type::Hash
+
+            "string" # Strings and all other scalar types
           end
         end
       end

data/lib/lutaml/model/schema/xml_compiler.rb

@@ -71,9 +71,10 @@ module Lutaml
         end
 
         def as_models(schema, options: {})
-          unless Config.xml_adapter.name.end_with?("NokogiriAdapter")
-            raise Error, XML_ADAPTER_NOT_SET_MESSAGE
-          end
+          # The schema builder resolves its own DOM builder from the
+          # configured adapter type (falling back to nokogiri); a stale
+          # adapter-class name check here rejected every caller after
+          # Config.xml_adapter became symbol-based (#251).
 
           parsed_schema = Lutaml::Xml::Schema::Xsd.parse(
             schema, location: options[:location]

data/lib/lutaml/model/type/date_time_with_timezone.rb

@@ -15,6 +15,10 @@ module Lutaml
           value.is_a?(::String) ? value.match?(TIMEZONE) : !cast(value).nil?
         end
 
+        def self.json_schema_format
+          "date-time"
+        end
+
         def self.default_xsd_type
           "xs:dateTime"
         end

data/lib/lutaml/model/type/date_with_timezone.rb

@@ -15,6 +15,10 @@ module Lutaml
           value.is_a?(::String) ? value.match?(TIMEZONE) : !cast(value).nil?
         end
 
+        def self.json_schema_format
+          "date"
+        end
+
         def self.default_xsd_type
           "xs:date"
         end

data/lib/lutaml/model/type/day_time_duration.rb

@@ -5,23 +5,27 @@ module Lutaml
     module Type
       # NIST Metaschema day-time-duration datatype (#107): an ISO 8601
       # duration expressed in days, hours, minutes, and seconds (no
-      # years or months), per the xs:dayTimeDuration form.
+      # years or months), per the xs:dayTimeDuration form. Built by
+      # interpolation with no formatting whitespace, so the pattern's
+      # source is export-clean for xs:pattern facets.
       #
       # @example Using DayTimeDuration type
       #   attribute :elapsed, :day_time_duration
       class DayTimeDuration < Duration
         ELAPSED_TIME =
-          /(?:[0-9]+H(?:[0-9]+M)?(?:[0-9]+(?:\.[0-9]+)?S)?
-                 |[0-9]+M(?:[0-9]+(?:\.[0-9]+)?S)?
-                 |[0-9]+(?:\.[0-9]+)?S)/x
-        PATTERN = /
-          \A-?P(?:[0-9]+D(?:T#{ELAPSED_TIME.source})?|T#{ELAPSED_TIME.source})\z
-        /x
+          "(?:[0-9]+H(?:[0-9]+M)?(?:[0-9]+(?:\\.[0-9]+)?S)?" \
+          "|[0-9]+M(?:[0-9]+(?:\\.[0-9]+)?S)?" \
+          "|[0-9]+(?:\\.[0-9]+)?S)"
+        PATTERN = /\A-?P(?:[0-9]+D(?:T#{ELAPSED_TIME})?|T#{ELAPSED_TIME})\z/
 
         def self.valid?(value)
           value.is_a?(::String) ? value.match?(PATTERN) : !cast(value).nil?
         end
 
+        def self.json_schema_format
+          "duration"
+        end
+
         def self.default_xsd_type
           "xs:dayTimeDuration"
         end

data/lib/lutaml/model/type/email_address.rb

@@ -13,6 +13,12 @@ module Lutaml
 
         PATTERN = /\A.+@.+\z/
 
+        pattern PATTERN
+
+        def self.json_schema_format
+          "email"
+        end
+
         def self.default_xsd_type
           "xs:string"
         end

data/lib/lutaml/model/type/hostname.rb

@@ -15,6 +15,12 @@ module Lutaml
 
         PATTERN = /\A\S(.*\S)?\z/
 
+        pattern PATTERN
+
+        def self.json_schema_format
+          "idn-hostname"
+        end
+
         def self.default_xsd_type
           "xs:string"
         end

data/lib/lutaml/model/type/ip_v4_address.rb

@@ -14,6 +14,10 @@ module Lutaml
         OCTET = /(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])/
         PATTERN = /\A#{OCTET.source}\.#{OCTET.source}\.#{OCTET.source}\.#{OCTET.source}\z/
 
+        def self.json_schema_format
+          "ipv4"
+        end
+
         def self.default_xsd_type
           "xs:string"
         end

data/lib/lutaml/model/type/ip_v6_address.rb

@@ -6,7 +6,9 @@ module Lutaml
       # NIST Metaschema ip-v6-address datatype (#107): RFC3513 IPv6 text
       # form, per the metaschema-datatypes pattern (the generalized
       # StackOverflow IPv6 expression with metaschema customizations,
-      # including link-local zones and embedded IPv4).
+      # including link-local zones and embedded IPv4). Built by
+      # interpolation with no formatting whitespace, so the pattern's
+      # source is export-clean for xs:pattern facets.
       #
       # @example Using IpV6Address type
       #   attribute :address, :ip_v6_address
@@ -16,22 +18,25 @@ module Lutaml
         HEX4 = "[0-9a-fA-F]{1,4}"
         OCTET = "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])"
         EMBEDDED_V4 = "(#{OCTET}\\.){3,3}#{OCTET}".freeze
-        PATTERN = /
-          \A(
-            (#{HEX4}:){7,7}#{HEX4}
-            |([0-9a-fA-F]{1,4}:){1,7}:
-            |([0-9a-fA-F]{1,4}:){1,6}:#{HEX4}
-            |([0-9a-fA-F]{1,4}:){1,5}(:#{HEX4}){1,2}
-            |([0-9a-fA-F]{1,4}:){1,4}(:#{HEX4}){1,3}
-            |([0-9a-fA-F]{1,4}:){1,3}(:#{HEX4}){1,4}
-            |([0-9a-fA-F]{1,4}:){1,2}(:#{HEX4}){1,5}
-            |#{HEX4}:((:#{HEX4}){1,6})
-            |:((:#{HEX4}){1,7}|:)
-            |[fF][eE]80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}
-            |::([fF]{4}(:0{1,4}){0,1}:){0,1}#{EMBEDDED_V4}
-            |([0-9a-fA-F]{1,4}:){1,4}:#{EMBEDDED_V4}
-          )\z
-        /x
+        GROUPS = "(#{HEX4}:){7,7}#{HEX4}" \
+                 "|([0-9a-fA-F]{1,4}:){1,7}:" \
+                 "|([0-9a-fA-F]{1,4}:){1,6}:#{HEX4}" \
+                 "|([0-9a-fA-F]{1,4}:){1,5}(:#{HEX4}){1,2}" \
+                 "|([0-9a-fA-F]{1,4}:){1,4}(:#{HEX4}){1,3}" \
+                 "|([0-9a-fA-F]{1,4}:){1,3}(:#{HEX4}){1,4}" \
+                 "|([0-9a-fA-F]{1,4}:){1,2}(:#{HEX4}){1,5}" \
+                 "|#{HEX4}:((:#{HEX4}){1,6})" \
+                 "|:((:#{HEX4}){1,7}|:)" \
+                 "|[fF][eE]80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}" \
+                 "|::([fF]{4}(:0{1,4}){0,1}:){0,1}#{EMBEDDED_V4}" \
+                 "|([0-9a-fA-F]{1,4}:){1,4}:#{EMBEDDED_V4}".freeze
+        PATTERN = /\A(#{GROUPS})\z/
+
+        pattern PATTERN
+
+        def self.json_schema_format
+          "ipv6"
+        end
 
         def self.default_xsd_type
           "xs:string"

data/lib/lutaml/model/type/metaschema_pattern.rb

@@ -4,17 +4,15 @@ module Lutaml
   module Model
     module Type
       # Pattern machinery shared by the NIST Metaschema string types (#107).
-      # Each including class defines a PATTERN regexp; values cast to
-      # strings and validate full-match against it.
+      # Each including class defines a PATTERN regexp (also declared as the
+      # type's `pattern` facet, feeding runtime validation and XSD
+      # restriction emission); values cast to strings and `valid?` checks
+      # full-match against it.
       module MetaschemaPattern
-        def pattern
-          self::PATTERN
-        end
-
         def valid?(value)
           return false if value.nil?
 
-          pattern.match?(value.to_s)
+          self::PATTERN.match?(value.to_s)
         end
 
         def cast(value, _options = {})

data/lib/lutaml/model/type/non_negative_integer.rb

@@ -9,6 +9,7 @@ module Lutaml
       # @example Using NonNegativeInteger type
       #   attribute :index, :non_negative_integer
       class NonNegativeInteger < Integer
+        inclusive(min: 0)
         def self.valid?(value)
           cast_value = cast(value)
 

data/lib/lutaml/model/type/positive_integer.rb

@@ -9,6 +9,7 @@ module Lutaml
       # @example Using PositiveInteger type
       #   attribute :ordinal, :positive_integer
       class PositiveInteger < Integer
+        inclusive(min: 1)
         def self.valid?(value)
           cast_value = cast(value)
 

data/lib/lutaml/model/type/token.rb

@@ -14,6 +14,8 @@ module Lutaml
 
         PATTERN = /\A(\p{L}|_)(\p{L}|\p{N}|[.\-_])*\z/
 
+        pattern PATTERN
+
         def self.default_xsd_type
           "xs:string"
         end

data/lib/lutaml/model/type/uri_reference.rb

@@ -14,6 +14,12 @@ module Lutaml
 
         PATTERN = /\A\S(.*\S)?\z/
 
+        pattern PATTERN
+
+        def self.json_schema_format
+          "uri-reference"
+        end
+
         def self.default_xsd_type
           "xs:anyURI"
         end

data/lib/lutaml/model/type/uuid.rb

@@ -14,6 +14,8 @@ module Lutaml
 
         PATTERN = %r{\A[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[45][0-9A-Fa-f]{3}-[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}\z}
 
+        pattern PATTERN
+
         def self.default_xsd_type
           "xs:string"
         end

data/lib/lutaml/model/type/value.rb

@@ -126,6 +126,15 @@ from: nil)
                   "conflicting `#{key}` facets: #{existing} and #{incoming}"
           end
 
+          # The JSON Schema `format` keyword for this type, or nil. The NIST
+          # Metaschema types declare the format the metaschema JSON
+          # representations use (ipv4, ipv6, email, uri-reference, duration,
+          # date, date-time); core types default to nil and their schemas
+          # carry no format keyword.
+          def json_schema_format
+            nil
+          end
+
           # Constrain ordered values via min/maxInclusive.
           def inclusive(min: nil, max: nil)
             min = cast_facet_value(min)

data/lib/lutaml/model/type/year_month_duration.rb

@@ -16,6 +16,10 @@ module Lutaml
           value.is_a?(::String) ? value.match?(PATTERN) : !cast(value).nil?
         end
 
+        def self.json_schema_format
+          "duration"
+        end
+
         def self.default_xsd_type
           "xs:yearMonthDuration"
         end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.127"
+    VERSION = "0.8.129"
   end
 end

data/lib/lutaml/xml/schema/xsd/list.rb

@@ -18,6 +18,7 @@ module Lutaml
             map_attribute :id, to: :id
             map_attribute :itemType, to: :item_type
             map_element :annotation, to: :annotation
+            map_element :simpleType, to: :simple_type
           end
 
           Lutaml::Xml::Schema::Xsd.register_model(self, :list)

data/spec/lutaml/model/metaschema_types_spec.rb

@@ -221,4 +221,147 @@ RSpec.describe "NIST Metaschema simple data types" do
       .to eq("xs:yearMonthDuration")
     expect(Lutaml::Model::Type::Uuid.default_xsd_type).to eq("xs:string")
   end
+
+  describe "wiring into validation and schema emission" do
+    it "declares the patterns and bounds as Layer-2 facets" do
+      expect(Lutaml::Model::Type::Uuid.facets[:pattern])
+        .to include(Lutaml::Model::Type::Uuid::PATTERN)
+      expect(Lutaml::Model::Type::NonNegativeInteger.facets[:min_inclusive])
+        .to eq(0)
+      expect(Lutaml::Model::Type::PositiveInteger.facets[:min_inclusive])
+        .to eq(1)
+    end
+
+    it "validates metaschema-typed attributes through model validation" do
+      stub_const("WiredNode", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :uuid
+        attribute :contact, :email_address
+        attribute :retries, :positive_integer
+
+        json do
+          map "id", to: :id
+          map "contact", to: :contact
+          map "retries", to: :retries
+        end
+      end)
+
+      good = WiredNode.new(id: "a3bb189e-8bf9-4888-9912-ace4e6543002",
+                           contact: "ops@example.com", retries: 2)
+      expect(good.validate).to be_empty
+
+      bad = WiredNode.new(id: "not-a-uuid", contact: "no-at-sign", retries: 0)
+      messages = bad.validate.map(&:message)
+
+      expect(messages).to all(be_a(String))
+      expect(messages.join("\n")).to include("id")
+      expect(messages.join("\n")).to include("contact")
+      expect(messages.join("\n")).to include("retries")
+    end
+
+    it "exports the metaschema restrictions in generated XSD" do
+      stub_const("XsdNode", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :uuid
+        attribute :contact, :email_address
+        attribute :retries, :positive_integer
+
+        xml do
+          element "node"
+          map_attribute "id", to: :id
+          map_element "contact", to: :contact
+          map_element "retries", to: :retries
+        end
+      end)
+
+      xsd = Lutaml::Model::Schema.to_xsd(XsdNode)
+
+      expect(xsd).to include("[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[45]")
+      expect(xsd).to include(".+@.+")
+      expect(xsd).to include('minInclusive value="1"')
+    end
+
+    it "exports the NIST JSON representations in generated JSON and YAML schemas" do
+      stub_const("JsonWiredNode", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :uuid
+        attribute :contact, :email_address
+        attribute :address, :ip_v4_address
+        attribute :retries, :positive_integer
+        attribute :term, :year_month_duration
+
+        json do
+          map "id", to: :id
+          map "contact", to: :contact
+          map "address", to: :address
+          map "retries", to: :retries
+          map "term", to: :term
+        end
+      end)
+
+      properties = JSON.parse(Lutaml::Model::Schema.to_json(JsonWiredNode))
+        .fetch("$defs").fetch("JsonWiredNode").fetch("properties")
+
+      expect(properties.fetch("id").fetch("pattern"))
+        .to eq("^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[45][0-9A-Fa-f]{3}-" \
+               "[89ABab][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}$")
+      expect(properties.fetch("contact")).to include("format" => "email")
+      expect(properties.fetch("address")).to include("format" => "ipv4")
+      expect(Array(properties.fetch("retries").fetch("type")))
+        .to include("integer")
+      expect(properties.fetch("retries")).to include("minimum" => 1)
+      expect(properties.fetch("term")).to include("format" => "duration")
+
+      yaml_properties = YAML.safe_load(
+        Lutaml::Model::Schema.to_yaml(JsonWiredNode),
+      ).fetch("$defs").fetch("JsonWiredNode").fetch("properties")
+
+      expect(yaml_properties.fetch("id")["pattern"]).to include("[45]")
+      expect(yaml_properties.fetch("retries")["minimum"]).to eq(1)
+    end
+
+    it "round-trips metaschema-typed models through every format" do
+      stub_const("FormatNode", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :uuid
+        attribute :host, :hostname
+        attribute :address, :ip_v4_address
+        attribute :renewal, :year_month_duration
+
+        xml do
+          element "node"
+          map_attribute "id", to: :id
+          map_element "host", to: :host
+          map_element "address", to: :address
+          map_element "renewal", to: :renewal
+        end
+
+        json do
+          map "id", to: :id
+          map "host", to: :host
+          map "address", to: :address
+          map "renewal", to: :renewal
+        end
+      end)
+
+      node = FormatNode.new(id: "a3bb189e-8bf9-4888-9912-ace4e6543002",
+                            host: "example.com", address: "10.0.0.7",
+                            renewal: "P1Y6M")
+
+      xml_round_trip = FormatNode.from_xml(node.to_xml)
+      expect(xml_round_trip).to eq(node)
+
+      json_round_trip = FormatNode.from_json(node.to_json)
+      expect(json_round_trip).to eq(node)
+
+      yaml_round_trip = FormatNode.from_yaml(node.to_yaml)
+      expect(yaml_round_trip).to eq(node)
+
+      toml_round_trip = FormatNode.from_toml(node.to_toml)
+      expect(toml_round_trip).to eq(node)
+    end
+
+    it "keeps the metaschema pattern sources export-clean" do
+      [Lutaml::Model::Type::IpV6Address,
+       Lutaml::Model::Type::DayTimeDuration].each do |type|
+        expect(type::PATTERN.source).not_to match(/\s/)
+      end
+    end
+  end
 end

data/spec/lutaml/model/schema/xml_compiler_runtime_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema"
+require "tmpdir"
+
+# Runtime XSD-to-classes compilation (#251): Schema.from_xml compiles a
+# schema into generated Serializable classes, and with load_classes: the
+# classes are available in-process for direct parsing and serialization —
+# no generated files on disk.
+RSpec.describe "runtime XSD class loading" do
+  let(:xsd) do
+    <<~XSD
+      <?xml version="1.0" encoding="UTF-8"?>
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:complexType name="EntryType">
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="year" type="xs:integer"/>
+          </xs:sequence>
+          <xs:attribute name="id" type="xs:string" use="required"/>
+        </xs:complexType>
+        <xs:element name="entry" type="EntryType"/>
+      </xs:schema>
+    XSD
+  end
+
+  let(:instance_xml) do
+    <<~XML
+      <entry id="e1"><name>Alpha</name><year>2024</year></entry>
+    XML
+  end
+
+  it "compiles a schema, loads the classes, and round-trips an instance" do
+    Dir.mktmpdir do |dir|
+      Lutaml::Model::Schema.from_xml(
+        xsd, output_dir: File.join(dir, "runtime_pilot_models"),
+             load_classes: true
+      )
+
+      doc = RuntimePilotModels::EntryType.from_xml(instance_xml)
+
+      expect(doc.name).to eq("Alpha")
+      expect(doc.year).to eq(2024)
+      expect(doc.id).to eq("e1")
+
+      expect(doc.to_xml).to include("<name>Alpha</name>")
+      expect(doc.to_xml).to include("<year>2024</year>")
+      expect(doc.to_xml).to include('id="e1"')
+    end
+  end
+end

data/spec/lutaml/xml/schema/xsd/list_simple_type_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe "xs:list nested simpleType mapping" do
+  it "maps the inline simpleType of a list from the parsed XSD" do
+    xsd = <<~XSD
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:element name="r">
+          <xs:simpleType>
+            <xs:list>
+              <xs:simpleType>
+                <xs:restriction base="xs:string">
+                  <xs:enumeration value="a"/>
+                </xs:restriction>
+              </xs:simpleType>
+            </xs:list>
+          </xs:simpleType>
+        </xs:element>
+      </xs:schema>
+    XSD
+
+    schema = Lutaml::Xml::Schema::Xsd.parse(xsd)
+    list = schema.element.first.simple_type.list
+
+    expect(list.simple_type).to be_a(Lutaml::Xml::Schema::Xsd::SimpleType)
+    values = Array(list.simple_type.restriction.enumeration).map(&:value)
+    expect(values).to eq(["a"])
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.127
+  version: 0.8.129
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1837,6 +1837,7 @@ files:
 - spec/lutaml/model/schema/renderers/namespace_spec.rb
 - spec/lutaml/model/schema/renderers/restricted_type_spec.rb
 - spec/lutaml/model/schema/renderers/union_spec.rb
+- spec/lutaml/model/schema/xml_compiler_runtime_spec.rb
 - spec/lutaml/model/schema/xsd_schema_spec.rb
 - spec/lutaml/model/schema/yaml_schema_spec.rb
 - spec/lutaml/model/sequence_choice_compositor_spec.rb
@@ -2054,6 +2055,7 @@ files:
 - spec/lutaml/xml/schema/xsd/liquid_methods/element_spec.rb
 - spec/lutaml/xml/schema/xsd/liquid_methods/schema_spec.rb
 - spec/lutaml/xml/schema/xsd/liquid_methods/simple_content_spec.rb
+- spec/lutaml/xml/schema/xsd/list_simple_type_spec.rb
 - spec/lutaml/xml/schema/xsd/namespace_uri_remapping_spec.rb
 - spec/lutaml/xml/schema/xsd/schema_helper_methods_spec.rb
 - spec/lutaml/xml/schema/xsd/schema_mapping_spec.rb