opencdd 0.1.1

data/lib/opencdd/parcel.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Parcel
+    META_CLASS_TYPES = Opencdd::MetaClasses::TYPE_BY_META_CLASS
+    TYPE_TO_META_CLASS = META_CLASS_TYPES.invert.freeze
+
+    autoload :Metadata,        "opencdd/parcel/metadata"
+    autoload :SheetSchema,     "opencdd/parcel/sheet_schema"
+    autoload :Sheet,           "opencdd/parcel/sheet"
+    autoload :Workbook,        "opencdd/parcel/workbook"
+    autoload :WorkbookReader,  "opencdd/parcel/workbook_reader"
+    autoload :FlatDirReader,   "opencdd/parcel/flat_dir_reader"
+    autoload :ShardedDirReader, "opencdd/parcel/sharded_dir_reader"
+    autoload :LayoutDetector,  "opencdd/parcel/layout_detector"
+    autoload :EntityManifest,  "opencdd/parcel/entity_manifest"
+    autoload :ReferencedIrdis,  "opencdd/parcel/referenced_irdis"
+    autoload :Selector,        "opencdd/parcel/selector"
+    autoload :SheetEmitter,    "opencdd/parcel/sheet_emitter"
+    autoload :Writer,          "opencdd/parcel/writer"
+    autoload :CsvWriter,       "opencdd/parcel/csv_writer"
+    autoload :CsvReader,       "opencdd/parcel/csv_reader"
+    autoload :ScrapeVerifier,  "opencdd/parcel/scrape_verifier"
+
+    module_function
+
+    # Aggregate multiple Parcel-shaped paths into a single Database.
+    # The +paths+ array may contain .xlsx files, .xls files, flat .xls
+    # directories, or sharded per-class subdirs. Each is read
+    # polymorphically via +Opencdd::Reader.detect+ and merged into a
+    # single target database.
+    #
+    # Returns the populated Opencdd::Database.
+    def aggregate(*paths)
+      paths.flatten
+        .map { |p| Opencdd::Database.load(p) }
+        .reduce(Opencdd::Database.new) { |acc, db| acc.merge(db) }
+    end
+
+    # Split +database+ into multiple sub-databases partitioned along
+    # +by+:
+    #
+    #   :entity_type — one partition per entity type
+    #     (the legacy .xls layout, one file per type).
+    #   :root_class — one partition per root class
+    #     (full tree per parcel, lifted cross-type deps).
+    #   :each_class — one partition per class
+    #     (the class + its declared properties / value_lists /
+    #     relations / units).
+    #   callable   — partition key is +callable.call(entity)+;
+    #     the result is a +Hash{ key => Database }+.
+    #
+    # Returns +Hash{ key => Opencdd::Database }+.
+    def split(database, by:, lift_dependencies: true)
+      partitions = case by
+                   when :entity_type then split_by_type(database)
+                   when :root_class  then split_by_root_class(database, lift_dependencies: lift_dependencies)
+                   when :each_class  then split_by_each_class(database, lift_dependencies: lift_dependencies)
+                   when Proc         then split_by_callable(database, by)
+                   else
+                     raise ArgumentError, "split `by:` must be :entity_type, :root_class, :each_class, or a Proc"
+                   end
+      partitions
+    end
+
+    def split_by_type(database)
+      database.entities.group_by(&:type).each_with_object({}) do |(type, entities), h|
+        h[type] = build_partition(database, entities)
+      end
+    end
+
+    def split_by_root_class(database, lift_dependencies: true)
+      roots = database.root_classes
+      roots.each_with_object({}) do |root, h|
+        tree = collect_root_subtree(database, root)
+        entities = lift_dependencies ? lift_for(database, tree) : tree
+        h[root.code || root.irdi.to_s] = build_partition(database, entities)
+      end
+    end
+
+    def split_by_each_class(database, lift_dependencies: true)
+      database.classes.each_with_object({}) do |klass, h|
+        entities = [klass]
+        if lift_dependencies
+          klass_props = database.properties_of(klass)
+          entities.concat(klass_props)
+          entities.concat(database.relations_for(domain: klass.irdi))
+          klass_props.each do |prop|
+            next unless prop.is_a?(Opencdd::Property)
+            if prop.unit_irdi
+              unit = database.find(prop.unit_irdi)
+              entities << unit if unit.is_a?(Opencdd::Unit)
+            end
+            vl = database.value_list_of(prop)
+            entities << vl if vl
+          end
+        end
+        h[klass.code || klass.irdi.to_s] = build_partition(database, entities)
+      end
+    end
+
+    def split_by_callable(database, callable)
+      database.entities.group_by { |e| callable.call(e) }.each_with_object({}) do |(key, entities), h|
+        h[key] = build_partition(database, entities)
+      end
+    end
+
+    def collect_root_subtree(database, root)
+      collected = [root]
+      queue = [root]
+      seen = { root.irdi => true }
+      until queue.empty?
+        current = queue.shift
+        children = current.children
+        children.each do |c|
+          next if seen[c.irdi]
+          seen[c.irdi] = true
+          collected << c
+          queue << c
+        end
+      end
+      collected
+    end
+
+    # Lifts cross-type dependencies for the given set of classes:
+    # declared properties, value_lists those properties reference,
+    # units those properties use, and relations where the class is
+    # in domain or codomain. This makes a per-tree partition
+    # self-sufficient when written out.
+    def lift_for(database, classes)
+      entities = classes.dup
+      classes.each do |klass|
+        database.properties_of(klass).each { |p| entities << p unless entities.include?(p) }
+        database.relations_for(domain: klass.irdi).each { |r| entities << r unless entities.include?(r) }
+        database.relations_for(codomain: klass.irdi).each { |r| entities << r unless entities.include?(r) }
+        database.properties_of(klass).each do |prop|
+          next unless prop.is_a?(Opencdd::Property)
+          if prop.unit_irdi
+            unit = database.find(prop.unit_irdi)
+            entities << unit if unit.is_a?(Opencdd::Unit) && !entities.include?(unit)
+          end
+          vl = database.value_list_of(prop)
+          entities << vl if vl && !entities.include?(vl)
+        end
+      end
+      entities.uniq
+    end
+
+    def build_partition(_database, entities)
+      db = Opencdd::Database.new
+      entities.each { |e| db.add_entity(deep_copy_entity(e)) }
+      db.finalize!
+      db
+    end
+
+    # Returns a detached copy of +entity+ — same +irdi+, +properties+,
+    # +schema+, +meta_class_irdi+, but no +@database+ back-reference and
+    # empty Klass-specific state (+@children+, +@declared_property_irdis+).
+    #
+    # The destination partition Database reattaches the entity and
+    # rebuilds class-tree state via +add_entity+ and +finalize!+.
+    #
+    # We can't use Marshal here because Entity indirectly references its
+    # source Database, which uses Hash.new { ... } (a default proc) for
+    # its indexes — Marshal refuses to dump hashes with default procs.
+    def deep_copy_entity(entity)
+      entity.class.new(
+        irdi: entity.irdi,
+        properties: entity.properties.dup,
+        schema: entity.schema,
+        meta_class_irdi: entity.meta_class_irdi,
+      )
+    end
+  end
+end

data/lib/opencdd/parse_helpers.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+# Legacy module. The canonical home for collection parsing is now
+# +Opencdd::StructuredValues+ — see +unwrap_and_split+, +rejoin+,
+# +parse_ref_set+, +parse_synonyms+. ParseHelpers remains as a
+# thin back-compat layer for code that hasn't migrated yet (notably
+# the +Entity+ mixin). Do not add new callers; prefer StructuredValues.
+module Opencdd
+  module ParseHelpers
+    module_function
+
+    # Delegates to StructuredValues — single source of truth for
+    # brace/paren/comma handling. Whitespace-separated forms are a
+    # Parcel-specific quirk preserved here for back-compat.
+    def parse_irdi_list(raw)
+      return [] if raw.nil? || raw.to_s.strip.empty?
+      tokens = Opencdd::StructuredValues.unwrap_and_split(raw)
+      # Some Parcel sources use whitespace as the separator inside
+      # a single "set" cell. Honour both shapes.
+      tokens.flat_map { |t| t.split(/\s+/) }.reject(&:empty?).filter_map do |t|
+        Opencdd::IRDI.parse(t)
+      end
+    end
+
+    def parse_string_list(raw)
+      Opencdd::StructuredValues.unwrap_and_split(raw)
+    end
+
+    def parse_synonym_tuples(raw)
+      return [] if raw.nil? || raw.to_s.strip.empty?
+      Opencdd::StructuredValues.parse_synonyms(raw)
+    end
+
+    # Parses both the {(name,lang),...} structured form and the
+    # legacy flat (lang, name, lang, name, ...) form. Kept on
+    # ParseHelpers because the flat form isn't a synonym-specific
+    # concept — it's an ad-hoc legacy wire shape.
+    def parse_pair_list(raw)
+      return [] if raw.nil? || raw.to_s.strip.empty?
+      s = raw.to_s.strip
+      return parse_synonym_tuples(s) if brace_wrapped?(s)
+      return [[nil, s]] unless paren_wrapped?(s)
+      unwrap_parens(s)
+        .split(",")
+        .each_slice(2)
+        .map { |lang, name| [lang&.strip, name&.strip] }
+    end
+
+    # ── Thin legacy predicates (kept for back-compat) ──────────
+    def unwrap_parens(s)
+      s = s.to_s
+      paren_wrapped?(s) ? s[1..-2] : s
+    end
+
+    def unwrap_delimiters(s)
+      s = s.to_s
+      return s[1..-2] if paren_wrapped?(s) || brace_wrapped?(s)
+      s
+    end
+
+    def paren_wrapped?(s)
+      s = s.to_s
+      s.start_with?("(") && s.end_with?(")")
+    end
+
+    def brace_wrapped?(s)
+      s = s.to_s
+      s.start_with?("{") && s.end_with?("}")
+    end
+  end
+end

data/lib/opencdd/property.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class Property < Opencdd::Entity
+    # Wire-format aliases for the data_type string. Used by #data_type
+    # to canonicalize the raw value before exposing it.
+    DATA_TYPE_ALIASES = {
+      "STRING_TYPE"              => :string,
+      "TRANSLATABLE_STRING_TYPE" => :translatable_string,
+      "REAL_MEASURE_TYPE"        => :real_measure,
+      "INTEGER_MEASURE_TYPE"     => :integer_measure,
+      "INT_MEASURE_TYPE"         => :integer_measure,
+      "REAL_TYPE"                => :real,
+      "INTEGER_TYPE"             => :integer,
+      "INT_TYPE"                 => :integer,
+      "BOOLEAN_TYPE"             => :boolean,
+      "DATE_TYPE"                => :date,
+      "DATETIME_TYPE"            => :date_time,
+      "DATE_TIME_TYPE"           => :date_time,
+      "TIME_TYPE"                => :time,
+      "IRDI_TYPE"                => :irdi,
+      "ICID_STRING"              => :irdi,
+      "ICID_STRING_TYPE"         => :irdi,
+      "URL_TYPE"                 => :url,
+      "MIME_TYPE"                => :mime,
+      "FILE_TYPE"                => :file,
+      "COMPLEX_TYPE"             => :complex,
+    }.freeze
+
+    # ── Pure field reads (value_kind + multilingual resolved from
+    #     PropertyIds::REGISTRY). Explicit :string override where the
+    #     original code returned the raw value (REGISTRY kind would
+    #     otherwise coerce to IRDI etc.). ──────────────────────────
+    field :symbol_in_text,         "MDC_P025_1", :string
+    field :value_format,           "MDC_P024",   :string
+    field :constraint,             "MDC_P068",   :string
+    field :type_classification,    "MDC_P033",   :string
+    field :source_document,        "MDC_P006_1", :string
+    field :coded_name,             "MDC_P018",  :string
+    field :definition_class_irdi,  "MDC_P021"
+    field :class_value_assignment, "MDC_P017"
+    field :unit_irdi,              "MDC_P041"
+    field :alternative_unit_irdis, "MDC_P042"
+
+    # ── Computed fields with block-form readers (synthetic: true).
+    #     Blocks are evaluated via instance_exec on the entity, so
+    #     they have access to private helpers without send dispatch.
+    # `data_type` is NOT a DSL field — the model's #data_type method
+    # returns a symbol (:real, :string, etc.) for callers. The wire-
+    # format string ("REAL_TYPE") comes from parsed_data_type.to_s
+    # and is emitted explicitly by Exporters::Json#property_node.
+    PARSED_DATA_TYPE_BLOCK = lambda {
+      Opencdd::DataType.parse_or_string(properties[Opencdd::PropertyIds::MDC_P022])
+    }
+    DATA_ELEMENT_TYPE_BLOCK = lambda {
+      @property_data_element_type ||=
+        Opencdd::PropertyDataTypeElement.parse(properties[Opencdd::PropertyIds::MDC_P020])
+    }
+
+    field :parsed_data_type,       synthetic: true, &PARSED_DATA_TYPE_BLOCK
+    field :data_element_type,      synthetic: true, as: "data_element_type", &DATA_ELEMENT_TYPE_BLOCK
+    field :property_data_element_type,
+          synthetic: true, &DATA_ELEMENT_TYPE_BLOCK
+    field :parsed_value_format,    synthetic: true do
+      Opencdd::ValueFormat.parse(properties[Opencdd::PropertyIds::MDC_P024])
+    end
+    field :condition_raw,          "MDC_P028", synthetic: true do
+      properties[Opencdd::PropertyIds::MDC_P028]
+    end
+    field :condition,              synthetic: true do
+      @condition ||= Opencdd::Condition.parse(properties[Opencdd::PropertyIds::MDC_P028])
+    rescue ArgumentError
+      # IEC CDD occasionally stores a bare class-reference set in the
+      # condition column (e.g. "{0112/2///62683#ACE132}") instead of
+      # a `left OP right` boolean expression. Condition's grammar
+      # rejects that shape; treat it as nil rather than crashing the
+      # import. Tracked in TODO.full-cdd/17-condition-grammar-fix.md.
+      @condition = nil
+    end
+    field :formula,                synthetic: true do
+      properties[Opencdd::PropertyIds::MDC_P027_1] ||
+        properties[Opencdd::PropertyIds::MDC_P027_2]
+    end
+
+    # Model-side data_type — returns the canonical symbol form.
+    def data_type
+      raw = properties[Opencdd::PropertyIds::MDC_P022]
+      DATA_TYPE_ALIASES[raw] || raw
+    end
+
+    # ── Predicates and methods with arguments stay as regular
+    #     methods. The DSL is for fields, not behavior. ───────────
+
+    def class_reference?
+      parsed_data_type.is_a?(Opencdd::DataType::ClassReference)
+    end
+
+    def enum?
+      parsed_data_type.is_a?(Opencdd::DataType::EnumStringType) ||
+        parsed_data_type.is_a?(Opencdd::DataType::EnumReferenceType)
+    end
+
+    def conditional?
+      det = property_data_element_type
+      det && (det.condition? || det.dependent?)
+    end
+
+    def active_for?(bindings)
+      return true unless conditional?
+      cond = condition
+      cond ? cond.satisfied_by?(bindings) : true
+    end
+
+    def attaches_to(*_args)
+      raise NotImplementedError,
+            "Property#attaches_to is provided by Opencdd::Database; use db.properties_of(klass)"
+    end
+    alias_method :applies_to, :attaches_to
+  end
+end

data/lib/opencdd/property_data_element_type.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class PropertyDataTypeElement
+    VALUES = %w[NON_DEPENDENT_P_DET CONDITION_DET DEPENDENT_P_DET].freeze
+
+    attr_reader :value
+
+    def initialize(value)
+      v = value.to_s.strip.upcase
+      raise ArgumentError, "unknown property data element type: #{value.inspect}" unless VALUES.include?(v)
+      @value = v
+    end
+
+    def non_dependent? = @value == "NON_DEPENDENT_P_DET"
+    def condition?      = @value == "CONDITION_DET"
+    def dependent?      = @value == "DEPENDENT_P_DET"
+
+    def conditional?
+      condition? || dependent?
+    end
+
+    def to_s   = @value
+    def to_sym = @value.downcase.to_sym
+
+    def ==(other)
+      other.is_a?(Opencdd::PropertyDataTypeElement) && @value == other.value
+    end
+    alias_method :eql?, :==
+
+    def hash
+      @value.hash
+    end
+
+    alias_method :inspect, :to_s
+
+    def self.parse(raw)
+      return nil if raw.nil? || raw.to_s.strip.empty?
+      s = raw.to_s.strip.upcase
+      return nil unless VALUES.include?(s)
+      new(s)
+    end
+  end
+end

data/lib/opencdd/property_ids.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module PropertyIds
+    Entry = Struct.new(:id, :aliases, :applies_to, :multilingual, :value_kind, keyword_init: true)
+
+    REGISTRY = {
+      # ── Identity & version (applies_to: :all) ─────────────────────────
+      "MDC_P001"    => Entry.new(id: "MDC_P001",    aliases: %w[code_generic],            applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_1"  => Entry.new(id: "MDC_P001_1",  aliases: %w[code_dictionary],         applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_2"  => Entry.new(id: "MDC_P001_2",  aliases: %w[code_supplier],           applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_5"  => Entry.new(id: "MDC_P001_5",  aliases: %w[code],                    applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_6"  => Entry.new(id: "MDC_P001_6",  aliases: %w[code_property],           applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_7"  => Entry.new(id: "MDC_P001_7",  aliases: %w[code_datatype],           applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_8"  => Entry.new(id: "MDC_P001_8",  aliases: %w[code_document],           applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_10" => Entry.new(id: "MDC_P001_10", aliases: %w[code_unit],               applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_11" => Entry.new(id: "MDC_P001_11", aliases: %w[code_value_term],         applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_12" => Entry.new(id: "MDC_P001_12", aliases: %w[code_value_list],         applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P001_13" => Entry.new(id: "MDC_P001_13", aliases: %w[code_relation],           applies_to: :all, multilingual: false, value_kind: :string),
+      "EXT_P001"    => Entry.new(id: "EXT_P001",    aliases: %w[code_view_control],       applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P002_1"  => Entry.new(id: "MDC_P002_1",  aliases: %w[version],                 applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P002_2"  => Entry.new(id: "MDC_P002_2",  aliases: %w[revision],               applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P003_1"  => Entry.new(id: "MDC_P003_1",  aliases: %w[original_definition_date], applies_to: :all, multilingual: false, value_kind: :date),
+      "MDC_P003_2"  => Entry.new(id: "MDC_P003_2",  aliases: %w[current_version_date],    applies_to: :all, multilingual: false, value_kind: :date),
+      "MDC_P003_3"  => Entry.new(id: "MDC_P003_3",  aliases: %w[current_revision_date],   applies_to: :all, multilingual: false, value_kind: :date),
+
+      # ── Names & definitions (applies_to: :all, mostly multilingual) ──
+      "MDC_P004"   => Entry.new(id: "MDC_P004",   aliases: %w[preferred_name],            applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P004_1" => Entry.new(id: "MDC_P004_1", aliases: %w[preferred_name_localized],  applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P004_2" => Entry.new(id: "MDC_P004_2", aliases: %w[synonymous_names],          applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P004_3" => Entry.new(id: "MDC_P004_3", aliases: %w[short_name_localized],      applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P004_4" => Entry.new(id: "MDC_P004_4", aliases: %w[name_icon],                 applies_to: :all, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P005"   => Entry.new(id: "MDC_P005",   aliases: %w[short_name],                applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P005_1" => Entry.new(id: "MDC_P005_1", aliases: %w[short_name_variant],        applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P006"   => Entry.new(id: "MDC_P006",   aliases: %w[definition],                applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P006_1" => Entry.new(id: "MDC_P006_1", aliases: %w[source_document_of_definition], applies_to: :all, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P007"   => Entry.new(id: "MDC_P007",   aliases: %w[synonym],                   applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P007_1" => Entry.new(id: "MDC_P007_1", aliases: %w[note_localized],            applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P007_2" => Entry.new(id: "MDC_P007_2", aliases: %w[remark_localized],          applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P008"   => Entry.new(id: "MDC_P008",   aliases: %w[note],                      applies_to: :all, multilingual: true,  value_kind: :string),
+      "MDC_P008_1" => Entry.new(id: "MDC_P008_1", aliases: %w[simplified_drawing],        applies_to: :all, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P008_2" => Entry.new(id: "MDC_P008_2", aliases: %w[graphics],                  applies_to: :all, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P009"   => Entry.new(id: "MDC_P009",   aliases: %w[remark],                    applies_to: :all, multilingual: true,  value_kind: :string),
+
+      # ── Class-level (applies_to: :class) ──────────────────────────────
+      "MDC_P010"   => Entry.new(id: "MDC_P010",   aliases: %w[superclass],                          applies_to: :class, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P010_1" => Entry.new(id: "MDC_P010_1", aliases: %w[superclass_localized known_superclasses], applies_to: :class, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P011"   => Entry.new(id: "MDC_P011",   aliases: %w[class_type],                          applies_to: :class, multilingual: false, value_kind: :string),
+      "MDC_P012"   => Entry.new(id: "MDC_P012",   aliases: %w[supplier_class_ref],                  applies_to: :class, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P013"   => Entry.new(id: "MDC_P013",   aliases: %w[is_case_of],                          applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P014"   => Entry.new(id: "MDC_P014",   aliases: %w[applicable_properties],               applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P014_1" => Entry.new(id: "MDC_P014_1", aliases: %w[known_applicable_properties],         applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P014_2" => Entry.new(id: "MDC_P014_2", aliases: %w[visible_properties],                  applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P015"   => Entry.new(id: "MDC_P015",   aliases: %w[applicable_types],                    applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P015_1" => Entry.new(id: "MDC_P015_1", aliases: %w[known_applicable_types],              applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P015_2" => Entry.new(id: "MDC_P015_2", aliases: %w[visible_types],                       applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P016"   => Entry.new(id: "MDC_P016",   aliases: %w[sub_class_selection],                 applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P033"   => Entry.new(id: "MDC_P033",   aliases: %w[type_classification],                 applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P040"   => Entry.new(id: "MDC_P040",   aliases: %w[det_classification],                  applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P090"   => Entry.new(id: "MDC_P090",   aliases: %w[imported_properties],                 applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P091"   => Entry.new(id: "MDC_P091",   aliases: %w[imported_types],                      applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P093"   => Entry.new(id: "MDC_P093",   aliases: %w[imported_documents],                  applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P094"   => Entry.new(id: "MDC_P094",   aliases: %w[applicable_documents],                applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P094_1" => Entry.new(id: "MDC_P094_1", aliases: %w[known_applicable_documents],          applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P094_2" => Entry.new(id: "MDC_P094_2", aliases: %w[visible_documents],                   applies_to: :class, multilingual: false, value_kind: :set_of_refs),
+
+      # ── Property-level (applies_to: :property unless noted) ──────────
+      "MDC_P017"   => Entry.new(id: "MDC_P017",   aliases: %w[class_value_assignment],    applies_to: :property, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P018"   => Entry.new(id: "MDC_P018",   aliases: %w[coded_name],               applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P018_1" => Entry.new(id: "MDC_P018_1", aliases: %w[value_term_data_type],     applies_to: :all,       multilingual: false, value_kind: :class_ref),
+      "MDC_P020"   => Entry.new(id: "MDC_P020",   aliases: %w[property_data_element_type property_det], applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P021"   => Entry.new(id: "MDC_P021",   aliases: %w[definition_class],         applies_to: :property, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P022"   => Entry.new(id: "MDC_P022",   aliases: %w[data_type],                applies_to: :property, multilingual: false, value_kind: :class_ref),
+      "MDC_P023"   => Entry.new(id: "MDC_P023",   aliases: %w[unit_structure unit_symbol], applies_to: :property, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P023_1" => Entry.new(id: "MDC_P023_1", aliases: %w[unit_in_text],             applies_to: :property, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P023_2" => Entry.new(id: "MDC_P023_2", aliases: %w[unit_in_sgml],             applies_to: :property, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P024"   => Entry.new(id: "MDC_P024",   aliases: %w[value_format],             applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P025_1" => Entry.new(id: "MDC_P025_1", aliases: %w[symbol preferred_symbol_text symbol_in_text], applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P025_2" => Entry.new(id: "MDC_P025_2", aliases: %w[preferred_symbol_sgml],    applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P025_3" => Entry.new(id: "MDC_P025_3", aliases: %w[synonymous_symbol],        applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P026"   => Entry.new(id: "MDC_P026",   aliases: [],                           applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P026_1" => Entry.new(id: "MDC_P026_1", aliases: [],                           applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P027_1" => Entry.new(id: "MDC_P027_1", aliases: %w[formula_text property_formula], applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P027_2" => Entry.new(id: "MDC_P027_2", aliases: %w[formula_sgml property_formula_localized], applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P028"   => Entry.new(id: "MDC_P028",   aliases: %w[condition],                applies_to: :property, multilingual: false, value_kind: :condition),
+      "MDC_P030"   => Entry.new(id: "MDC_P030",   aliases: [],                           applies_to: :property, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P031"   => Entry.new(id: "MDC_P031",   aliases: [],                           applies_to: :property, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P032"   => Entry.new(id: "MDC_P032",   aliases: [],                           applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P041"   => Entry.new(id: "MDC_P041",   aliases: %w[unit unit_irdi codefor_unit], applies_to: :property, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P042"   => Entry.new(id: "MDC_P042",   aliases: %w[alternative_units codefor_alt_unit], applies_to: :property, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P043"   => Entry.new(id: "MDC_P043",   aliases: %w[enumerated_terms term_irdis], applies_to: :value_list, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P044"   => Entry.new(id: "MDC_P044",   aliases: %w[enumerated_values code_list], applies_to: :value_list, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P045"   => Entry.new(id: "MDC_P045",   aliases: %w[selection_count],          applies_to: :value_list, multilingual: false, value_kind: :string),
+      "MDC_P046"   => Entry.new(id: "MDC_P046",   aliases: %w[list_type],                applies_to: :value_list, multilingual: false, value_kind: :string),
+      "MDC_P068"   => Entry.new(id: "MDC_P068",   aliases: %w[constraint property_constraint], applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P096"   => Entry.new(id: "MDC_P096",   aliases: %w[property_classification],  applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P097"   => Entry.new(id: "MDC_P097",   aliases: %w[requirement],              applies_to: :property, multilingual: false, value_kind: :string),
+      "MDC_P101"   => Entry.new(id: "MDC_P101",   aliases: %w[alternate_id],             applies_to: :all,       multilingual: false, value_kind: :string),
+      "MDC_P102"   => Entry.new(id: "MDC_P102",   aliases: %w[alternate_class_id],       applies_to: :all,       multilingual: false, value_kind: :string),
+      "MDC_P110"   => Entry.new(id: "MDC_P110",   aliases: %w[super_property],           applies_to: :property, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P111"   => Entry.new(id: "MDC_P111",   aliases: %w[alternative_units_list],   applies_to: :property, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P112"   => Entry.new(id: "MDC_P112",   aliases: %w[description],              applies_to: :all,       multilingual: true,  value_kind: :string),
+      "MDC_P113"   => Entry.new(id: "MDC_P113",   aliases: %w[example],                  applies_to: :all,       multilingual: false, value_kind: :string),
+      "MDC_P114"   => Entry.new(id: "MDC_P114",   aliases: %w[quantity],                 applies_to: :property, multilingual: false, value_kind: :identifier_ref),
+
+      # ── Relation-level (applies_to: :relation) ────────────────────────
+      "MDC_P200"   => Entry.new(id: "MDC_P200",   aliases: %w[relation_type],            applies_to: :relation, multilingual: false, value_kind: :string),
+      "MDC_P201"   => Entry.new(id: "MDC_P201",   aliases: %w[domain domain_of_relation], applies_to: :relation, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P202"   => Entry.new(id: "MDC_P202",   aliases: %w[domain_of_function],       applies_to: :relation, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P203"   => Entry.new(id: "MDC_P203",   aliases: %w[codomain codomain_of_function], applies_to: :relation, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P204"   => Entry.new(id: "MDC_P204",   aliases: %w[formula relation_formula],  applies_to: :relation, multilingual: false, value_kind: :string),
+      "MDC_P205"   => Entry.new(id: "MDC_P205",   aliases: %w[formula_language],         applies_to: :relation, multilingual: false, value_kind: :string),
+      "MDC_P206"   => Entry.new(id: "MDC_P206",   aliases: %w[external_solver],          applies_to: :relation, multilingual: false, value_kind: :string),
+      "MDC_P207"   => Entry.new(id: "MDC_P207",   aliases: %w[trigger_event],            applies_to: :relation, multilingual: false, value_kind: :string),
+      "MDC_P208"   => Entry.new(id: "MDC_P208",   aliases: %w[domain_element_type],      applies_to: :relation, multilingual: false, value_kind: :string),
+      "MDC_P209"   => Entry.new(id: "MDC_P209",   aliases: %w[codomain_element_type],    applies_to: :relation, multilingual: false, value_kind: :string),
+      "MDC_P210"   => Entry.new(id: "MDC_P210",   aliases: %w[role],                     applies_to: :relation, multilingual: false, value_kind: :string),
+      "MDC_P211"   => Entry.new(id: "MDC_P211",   aliases: %w[segment],                  applies_to: :relation, multilingual: false, value_kind: :string),
+      "MDC_P212"   => Entry.new(id: "MDC_P212",   aliases: %w[super_relation_irdi super_relation], applies_to: :relation, multilingual: false, value_kind: :identifier_ref),
+      "MDC_P230"   => Entry.new(id: "MDC_P230",   aliases: %w[applicable_relations],     applies_to: :relation, multilingual: false, value_kind: :set_of_refs),
+      "MDC_P231"   => Entry.new(id: "MDC_P231",   aliases: %w[applicable_terms],         applies_to: :relation, multilingual: false, value_kind: :set_of_refs),
+
+      # ── CIM extension ─────────────────────────────────────────────────
+      "CIM_P001"   => Entry.new(id: "CIM_P001",   aliases: %w[cim_uml_id],               applies_to: :all, multilingual: false, value_kind: :string),
+      "CIM_P002"   => Entry.new(id: "CIM_P002",   aliases: %w[cim_package],              applies_to: :all, multilingual: false, value_kind: :string),
+      "CIM_P003"   => Entry.new(id: "CIM_P003",   aliases: %w[cim_property_type],        applies_to: :all, multilingual: false, value_kind: :string),
+      "CIM_P004"   => Entry.new(id: "CIM_P004",   aliases: %w[cim_basic_datatype],       applies_to: :all, multilingual: false, value_kind: :string),
+      "CIM_P005"   => Entry.new(id: "CIM_P005",   aliases: %w[cim_multiplicity],         applies_to: :all, multilingual: false, value_kind: :string),
+
+      # ── Global (applies_to: :all) ─────────────────────────────────────
+      "MDC_P066"   => Entry.new(id: "MDC_P066",   aliases: %w[data_object_identifier],   applies_to: :all, multilingual: false, value_kind: :string),
+      "MDC_P067"   => Entry.new(id: "MDC_P067",   aliases: %w[time_stamp],               applies_to: :all, multilingual: false, value_kind: :date_time),
+
+      # ── View-control extension ────────────────────────────────────────
+      "EXT_P002"   => Entry.new(id: "EXT_P002",   aliases: %w[controlled_classes],       applies_to: :view_control, multilingual: false, value_kind: :set_of_refs),
+      "EXT_P003"   => Entry.new(id: "EXT_P003",   aliases: %w[shown_properties],         applies_to: :view_control, multilingual: false, value_kind: :set_of_refs),
+    }.freeze
+
+    # PARCEL_VARIANT_TO_CANONICAL moved to
+    # Opencdd::Parcel::SheetSchema::VARIANT_TO_CANONICAL (format-
+    # specific mapping belongs in the format module, not the
+    # ontology registry). Kept here as an alias for back-compat.
+    PARCEL_VARIANT_TO_CANONICAL = Opencdd::Parcel::SheetSchema::VARIANT_TO_CANONICAL
+
+    REGISTRY.each_key do |id|
+      const_set(id, id.freeze) unless const_defined?(id, false)
+    end
+
+    def self.entry(id)
+      REGISTRY[id.to_s]
+    end
+
+    def self.canonical_id(name)
+      key = name.to_s
+      return key if REGISTRY.key?(key)
+      alias_map[key]
+    end
+
+    def self.multilingual?(id)
+      e = entry(id)
+      e ? e.multilingual : false
+    end
+
+    def self.applies_to(id)
+      e = entry(id)
+      e ? e.applies_to : nil
+    end
+
+    def self.value_kind(id)
+      e = entry(id)
+      e ? e.value_kind : nil
+    end
+
+    def self.all_ids
+      @all_ids ||= REGISTRY.keys.freeze
+    end
+
+    def self.alias_map
+      @alias_map ||= REGISTRY.each_with_object({}) do |(_id, e), h|
+        e.aliases.each { |a| h[a] = e.id }
+      end.freeze
+    end
+
+    def self.normalize(raw_id)
+      return nil if raw_id.nil?
+      s = raw_id.to_s.strip
+      return nil if s.empty?
+      match = s.match(/\.(?<lang>[A-Za-z0-9-]+)\z/)
+      base = match ? match.pre_match : s
+      lang = match && match[:lang]
+      canonical = canonical_id(base) || base
+      lang ? "#{canonical}.#{lang}" : canonical
+    end
+
+    # Back-compat delegate. The canonical implementation lives at
+    # Opencdd::Parcel::SheetSchema.canonical_id (format-specific
+    # concern, not ontology).
+    def self.canonical_parcel_id(raw_id)
+      Opencdd::Parcel::SheetSchema.canonical_id(raw_id)
+    end
+  end
+end