chemicalml 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07b63ae96c1ef6187081c9f14ab76722b91f4438516a46c993abadac25f37a8f
-  data.tar.gz: 5130f3b5538741239be68d6632eaeecc0175ecb44f7a85cdf88e9414657c1689
+  metadata.gz: 5aff6a0c43deeff73ff9684286df7c1a7ef97d61fa919415a381e70de217995c
+  data.tar.gz: 52237d4db8715d8244b88c124cf3bdc1ad43102b4468d8217099ebdec6b89f1b
 SHA512:
-  metadata.gz: 29433a22bbfd290ce7146fefda2d4e68944bda3098902e3d8c6f282d05c7b99ee95de9097685ed55e9ff365799e17eee785bb3b5414dff39076616c65db87189
-  data.tar.gz: 300c20a1df5cf4cbad657ce97fc0b26b6aec9f2ecb84ac524ab4f30a209636aeebbf6756637ee0e3fc6dec96685f4334aa8ee90e34a1058078ea2ccba4d2f4a8
+  metadata.gz: b9f636c62b495c14f5ab10df0c8fd30e49aa23587731587f2fc9f4d87837376da38db8814df48482e1725751090518722ff3e6ca43ea5197fefb53ab5055183a
+  data.tar.gz: c7b42562ce98060bd3ca135d137be215f25a2ae71e2fc2693b70ab7e1030f8c6868744dea7aa9d60d078ba6adc11fc28a7c8d63de4f5f69c0a9b16ff8fe6f65f

data/.github/workflows/docs.yml

@@ -0,0 +1,63 @@
+name: docs
+
+on:
+  push:
+    branches: [main]
+    paths:
+    - 'docs/**'
+  pull_request:
+    paths:
+    - 'docs/**'
+  repository_dispatch:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+          cache-version: 0
+          working-directory: docs
+
+      - name: Setup Pages
+        id: pages
+        uses: actions/configure-pages@v5
+
+      - name: Build with Jekyll
+        run: bundle exec jekyll build --verbose --trace --baseurl "${{ steps.pages.outputs.base_path }}"
+        working-directory: docs
+        env:
+          JEKYLL_ENV: production
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v4
+        with:
+          path: docs/_site
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    if: ${{ github.ref == 'refs/heads/main' }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

data/.github/workflows/links.yml

@@ -0,0 +1,99 @@
+name: links
+
+on:
+  push:
+    branches:
+    - main
+    paths:
+    - 'docs/**'
+  pull_request:
+    paths:
+    - 'docs/**'
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  link_checker:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3.4'
+        bundler-cache: true
+        working-directory: docs
+
+    - name: Build site
+      env:
+        JEKYLL_ENV: production
+      run: bundle exec jekyll build --trace
+      working-directory: docs
+
+    - name: Restore lychee cache
+      uses: actions/cache@v4
+      with:
+        path: .lycheecache
+        key: cache-lychee-${{ github.sha }}
+        restore-keys: cache-lychee-
+
+    - name: Check if site was built
+      run: |
+        if [ ! -d "_site" ]; then
+          echo "Error: _site directory not created"
+          exit 1
+        fi
+        echo "Site built successfully"
+        ls -la _site/
+      working-directory: docs
+
+    - name: Link Checker (Built Site)
+      uses: lycheeverse/lychee-action@v2
+      with:
+        # Check the built HTML site for rendered links
+        # Only check https and http schemes, exclude file:// due to path resolution issues
+        args: >-
+          --verbose
+          --no-progress
+          --config lychee.toml
+          --root-dir "$(pwd)/_site"
+          --scheme https,http
+          '_site/**/*.html'
+        fail: true
+        output: link-check-results.md
+        format: markdown
+        workingDirectory: docs
+
+    - name: Upload link check results
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: link-check-results
+        path: |
+          docs/link-check-results.md
+        retention-days: 30
+
+    - name: Comment PR with results
+      if: failure() && github.event_name == 'pull_request'
+      uses: actions/github-script@v7
+      with:
+        script: |
+          const fs = require('fs');
+          let comment = '## 🔗 Link Check Failed\n\n';
+
+          if (fs.existsSync('docs/link-check-results.md')) {
+            const results = fs.readFileSync('docs/link-check-results.md', 'utf8');
+            comment += '### Built Site Results\n\n' + results + '\n\n';
+          }
+
+          comment += '\n---\n\n*Please fix the broken links and push a new commit.*';
+
+          github.rest.issues.createComment({
+            issue_number: context.issue.number,
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body: comment
+          });

data/.github/workflows/opal.yml

@@ -0,0 +1,34 @@
+name: opal
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install Opal dependencies
+        run: |
+          bundle config set with opal
+          bundle install
+
+      - name: Run Opal smoke tests
+        run: bundle exec rake spec:opal

data/.github/workflows/performance.yml

@@ -0,0 +1,25 @@
+name: performance
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  performance:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.4
+          bundler-cache: true
+
+      - name: Run performance benchmarks
+        run: bundle exec rake performance:compare

data/.github/workflows/rake.yml

@@ -0,0 +1,19 @@
+# Auto-generated by Cimas: Do not edit it manually!
+# See https://github.com/metanorma/cimas
+name: rake
+
+permissions:
+  contents: write
+  packages: write
+
+on:
+  push:
+    branches: [ master, main ]
+    tags: [ v* ]
+  pull_request:
+
+jobs:
+  rake:
+    uses: metanorma/ci/.github/workflows/generic-rake.yml@main
+    secrets:
+      pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}

data/.github/workflows/release.yml

@@ -0,0 +1,34 @@
+# Auto-generated by Cimas: Do not edit it manually!
+# See https://github.com/metanorma/cimas
+name: release
+
+permissions:
+  contents: write
+  packages: write
+  id-token: write
+
+on:
+  workflow_dispatch:
+    inputs:
+      next_version:
+        description: |
+          Next release version. Possible values: x.y.z, major, minor, patch (or pre|rc|etc).
+          Also, you can pass 'skip' to skip 'git tag' and do 'gem push' for the current version
+        required: true
+        default: 'skip'
+      acknowledge_breaking_in_patch:
+        description: 'Override the patch-release breaking-change guard when the trip is a known false-positive'
+        required: false
+        type: boolean
+        default: false
+  repository_dispatch:
+    types: [ do-release ]
+
+jobs:
+  release:
+    uses: metanorma/ci/.github/workflows/rubygems-release.yml@main
+    with:
+      next_version: ${{ github.event.inputs.next_version }}
+      acknowledge_breaking_in_patch: ${{ inputs.acknowledge_breaking_in_patch }}
+    secrets:
+      rubygems-api-key: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }}

data/CHANGELOG.md

@@ -1,21 +1,61 @@
 # Changelog
 
-All notable changes to ChemML are documented here.
+All notable changes to Chemicalml are documented here.
 This project follows [Semantic Versioning](https://semver.org/).
 
-## [Unreleased]
+## [0.2.0] - 2026-07-14
 
 ### Added
+
+- Full CML Schema 3 element coverage (121 elements).
+- Dual schema support: Schema 2.4 and Schema 3 wire classes with
+  real class hierarchies, shared declarations via `Base::*` mixins,
+  and `Role::*` type marker modules.
+- `Chemicalml.parse(xml, schema:)` polymorphic entry point with
+  auto-detection of root element (any of the 121 CML elements).
+- `Chemicalml::Cml::Translator` with schema-aware translation:
+  `to_canonical` / `from_canonical` handle both Schema3 and
+  Schema24 wire classes at every nesting level via
+  `WireClassRegistry`.
+- Convention framework: 5 built-in conventions (molecular, compchem,
+  dictionary, unit-dictionary, unitType-dictionary) with 17
+  registered constraint classes.
+- Dictionary model: 8 built-in YAML dictionaries (compchem, cml,
+  cml_name, cml_formula, cif, unit_si, unit_non_si, unit_type)
+  with 193+ entries.
+- Atom coordinate support: 2D (x2/y2), 3D (x3/y3/z3), and
+  fractional (xFract/yFract/zFract) coordinates round-trip through
+  canonical.
+- Stereo support: `AtomParity` and `BondStereo` round-trip through
+  canonical Model.
+- Compchem module support: `<module>`-rooted documents parse and
+  round-trip through canonical.
+- Property/Formula/Label as children of Molecule — no more silent
+  data loss on `<property>` inside `<molecule>`.
+- `Visitable` mixin: uniform interface for constraint walker
+  (`wire_children`, `node_id`, `element_name`).
+- Canon-based semantic XML comparison in specs.
+- Attribution: NOTICES.adoc credits xml-cml.org editors and
+  CC-BY-3.0 license for upstream content.
+
+### Changed
+
+- Namespace renamed from `ChemicalML` to `Chemicalml`.
+- Wire classes load lazily via `autoload` — every file, every
+  constant.
+- Serialization goes through `lutaml-model` only — no hand-rolled
+  XML.
+- Schema 2.4 correctly lacks `<module>` (schema 3 only).
+
+## [0.1.0] - 2026-07-13
+
+### Added
+
 - Initial gem scaffold: autoload tree, version, errors.
-- CML namespace declaration (`Chemicalml::Cml::Namespace`) for the CML
-  default XML namespace.
-- CML model classes for the core CML element set:
-  `Document`, `Molecule`, `AtomArray`, `Atom`, `BondArray`, `Bond`,
-  `Reaction`, `ReactantList`, `Reactant`, `ProductList`, `Product`,
-  `ReactionList`, `Name`, `Identifier`.
-- AsciiChem extension namespace (`Chemicalml::Ext::Namespace`) for
-  attributes CML doesn't natively cover (lone pairs, radical
-  electrons, stereochemistry).
-- Round-trip specs covering canonical CML fragments.
+- CML namespace declaration.
+- CML model classes for the core element set.
+- Round-trip specs.
 
 [Unreleased]: https://github.com/lutaml/chemicalml/commits/main
+[0.2.0]: https://github.com/lutaml/chemicalml/releases/tag/v0.2.0
+[0.1.0]: https://github.com/lutaml/chemicalml/releases/tag/v0.1.0

data/CLAUDE.md

@@ -33,23 +33,30 @@ is regenerated by RSpec on every run, and `Gemfile.lock` is development-only.
 
 ## Architecture (big picture)
 
-There are **five namespaces** under `Chemicalml`, deliberately kept
+There are **four namespaces** under `Chemicalml`, deliberately kept
 independent:
 
 ```
 Chemicalml
 ├── parse(xml, schema: :schema3)   # top-level entry point
-├── Model                          # canonical, format-agnostic chemistry objects
-├── Cml                            # CML XML wire-format classes
-│  ├── Base::*                     # shared attribute+mapping mixins
-│  ├── Schema3::*                  # Schema 3 wire classes
-│  ├── Schema24::*                 # Schema 2.4 wire classes
-│  └── Translator                  # the only adapter between Model and Cml
+├── Cml                            # CML model (lutaml-model Serializables)
+│  ├── Base::*                     # shared attribute + xml-mapping mixins
+│  ├── Schema3::*                  # Schema 3 classes (121 elements)
+│  ├── Schema24::*                 # Schema 2.4 classes (121 + 3 legacy)
+│  ├── Role::*                     # type-marker modules (schema-version-agnostic)
+│  ├── Visitable                   # constraint-walker interface
+│  └── WireClassRegistry           # (schema, role) → class lookup
 ├── Schema                         # version registry
 ├── Convention                     # 5 conventions + constraint framework
 └── Dictionary                     # dictionary model + YAML store
 ```
 
+The Cml classes ARE the model — every one is a
+`Lutaml::Model::Serializable` subclass with `attribute` declarations
+and an `xml do ... end` mapping block. lutaml-model handles XML
+parsing and serialization directly. There is no separate "canonical"
+layer and no translator.
+
 ### Schema-versioned wire classes (mirrors `mml` V3/V4 pattern)
 
 Both Schema 3 and Schema 2.4 have **real, distinct** class hierarchies
@@ -83,43 +90,41 @@ Chemicalml::Cml::Schema3.parse(xml)      # version-specific
 Chemicalml::Cml::Schema24.parse(xml)     # version-specific
 ```
 
-### The canonical model (`Chemicalml::Model::*`)
-
-Plain Ruby `Node` subclasses. **No XML, no JSON, no YAML**. Format-agnostic.
-Every adapter speaks this model; adapters never talk to each other directly.
-`Node` provides `accept(visitor)`, `value_attributes`, `children`, and
-class-level `short_name` so visitors written against the canonical model
-work across every adapter.
+### The CML model (`Chemicalml::Cml::*`)
 
-### The CML wire layer (`Chemicalml::Cml::*`)
+Every CML element is a `Lutaml::Model::Serializable` subclass — these
+ARE the model. lutaml-model is format-agnostic (XML/JSON/YAML/TOML
+via adapters), so the same class supports whatever serialization
+lutaml-model supports. Each class includes three mixins:
 
-Every CML element is a `Lutaml::Model::Serializable` subclass that
-includes three mixins: a `Base::*` module (shared declarations +
-xml mapping + `namespace Chemicalml::Cml::Namespace`), a
-`Role::*` marker module (type identity used by constraints and the
-translator — independent of which schema version's class it is), and
-`Cml::Visitable` (uniform interface for the constraint walker —
-`wire_children`, `node_id`, `element_name`).
+- a `Base::*` module (shared `attribute` declarations + `xml do ... end`
+  mapping block + `namespace Chemicalml::Cml::Namespace`)
+- a `Role::*` marker module (type identity used by constraints —
+  independent of which schema version's class it is)
+- `Cml::Visitable` (uniform interface for the constraint walker —
+  `wire_children`, `node_id`, `element_name`)
 
 Wire classes are generated in-place by each schema module from the
-shared `Chemicalml::Cml::Elements::ALL` table — no 70+ boilerplate
-files. Adding a new CML element = adding one entry to `Elements::ALL`,
-one `Base::*` mixin, and one `Role::*` module. Both `Schema3::*` and
-`Schema24::*` pick up the new element automatically (unless it's
-listed in `Elements::SCHEMA3_ONLY`).
+shared `Chemicalml::Cml::Elements::ALL` table — 121 entries spanning
+the entire Schema 3 XSD. Adding a new CML element = adding one entry
+to `Elements::ALL`, one `Base::*` mixin, and one `Role::*` module.
+Both `Schema3::*` and `Schema24::*` pick up the new element
+automatically unless it's listed in `Elements::SCHEMA3_ONLY`
+(currently `%i[AnyCml]` — the only element in Schema 3 that Schema 2.4
+lacks; verified by direct XSD diff).
+
+Schema 2.4 actually declares 137 elements (a superset of Schema 3 in
+most respects); 17 legacy elements (`alternative`, `annotation`,
+`appinfo`, `arg`, `complexObject`, `enumeration`, `expression`,
+`float`, `floatArray`, `integer`, `integerArray`, `operator`,
+`relatedEntry`, `string`, `stringArray`, `tcell`, `trow`) are
+Schema-2.4-only. Three of them (`annotation`, `appinfo`,
+`enumeration`) are explicitly modeled in `Elements::SCHEMA24_ONLY`
+because they carry semantic meaning; the rest are redundant with
+Schema 3's unified `scalar`/`array`/`table` machinery.
 
 The framework handles (de)serialization; **never** add `def to_xml` /
-`def from_xml` /
-`def to_h` to these classes.
-
-### The translator (`Chemicalml::Cml::Translator`)
-
-Pure transformation. `to_canonical(wire_doc)` accepts either Schema3
-or Schema24 wire documents (dispatches via `is_a?`).
-`from_canonical(model_doc, schema: :schema3)` produces the requested
-schema's wire format. It is the **only** place that imports both
-`Chemicalml::Model` and `Chemicalml::Cml`. Adding a new CML element
-means updating translator rules — the two namespaces stay decoupled.
+`def from_xml` / `def to_h` to these classes.
 
 ### Schema versions
 
@@ -172,9 +177,11 @@ These are non-negotiable and apply in addition to the user's global rules:
    or `respond_to?` for type checks.** Use `is_a?` or design the type
    hierarchy so the check isn't needed.
 
-5. **One concern, one place (MECE).** Adding a CML element = adding one
-   model class + one Cml class + one translator rule + specs. Don't
-   entangle them.
+5. **One concern, one place (MECE).** Adding a CML element = adding
+   one `Base::*` mixin + one `Role::*` module + one entry to
+   `Elements::ALL` + (if needed) one entry to `SCHEMA3_ONLY` or
+   `SCHEMA24_ONLY`. Both Schema3::* and Schema24::* pick it up
+   automatically.
 
 ## Reference docs (in-tree)
 

data/Gemfile

@@ -4,10 +4,11 @@ source "https://rubygems.org"
 
 gemspec
 
+gem "rake", "~> 13.2"
+
 group :development do
   gem "canon"
   gem "nokogiri"
-  gem "rake", "~> 13.2"
   gem "rspec", "~> 3.13"
   gem "rubocop", "~> 1.66", require: false
   gem "simplecov", "~> 0.22", require: false

data/Rakefile

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+  task :default do
+    warn "rspec not available — skipping specs"
+  end
+end

data/TODO.align/18-wire-class-registry.md

@@ -0,0 +1,46 @@
+# 18 — WireClassRegistry
+
+**Status:** complete
+**Depends on:** —
+
+## Goal
+
+A central registry that, given a schema symbol and a Role module,
+returns the right wire class. Eliminates the hardcoded `Cml::Foo`
+references in the Translator (which are all Schema3 aliases).
+
+```ruby
+Chemicalml::Cml::WireClassRegistry.for(:schema24, Chemicalml::Cml::Role::Molecule)
+# => Chemicalml::Cml::Schema24::Molecule
+
+Chemicalml::Cml::WireClassRegistry.for(:schema3, Chemicalml::Cml::Role::Atom)
+# => Chemicalml::Cml::Schema3::Atom
+```
+
+## Why
+
+The Translator today hardcodes `Cml::Molecule` (which is an alias for
+`Schema3::Molecule`). When the user asks for a Schema24 document,
+`Translator.from_canonical(doc, schema: :schema24)` returns a
+`Schema24::Document` but its `molecules` collection contains
+`Schema3::Molecule` instances. **This is a correctness bug.**
+
+The registry centralizes the lookup so every helper can resolve the
+right class for the requested schema.
+
+## Deliverables
+
+- [ ] `lib/chemicalml/cml/wire_class_registry.rb` — module with
+      `for(schema, role)` class method.
+- [ ] Raises `ArgumentError` on unknown schema or role.
+- [ ] Lazily resolves via `Schema3::Foo` / `Schema24::Foo` constants
+      (no eager loading).
+- [ ] Spec coverage.
+
+## Acceptance
+
+- `WireClassRegistry.for(:schema24, Role::Molecule)` returns
+  `Chemicalml::Cml::Schema24::Molecule`.
+- `WireClassRegistry.for(:schema3, Role::Atom)` returns
+  `Chemicalml::Cml::Schema3::Atom`.
+- Unknown schema raises `ArgumentError`.

data/TODO.align/19-schema-aware-translator.md

@@ -0,0 +1,33 @@
+# 19 — Schema-aware translator helpers
+
+**Status:** complete
+**Depends on:** 18
+
+## Goal
+
+Replace every `Cml::Foo.new(...)` in the Translator with
+`WireClassRegistry.for(schema, Role::Foo).new(...)`. Pass the schema
+through every `*_from_canonical` helper.
+
+## Why
+
+Today `Translator.from_canonical(doc, schema: :schema24)` returns a
+Schema24 Document whose children are Schema3 instances — silent
+correctness bug. Fixing it requires the WireClassRegistry (task 18)
+plus threading `schema:` through every helper.
+
+## Deliverables
+
+- [ ] Every `*_from_canonical` helper takes `schema:` keyword.
+- [ ] `from_canonical` itself passes its `schema:` to each helper.
+- [ ] No hardcoded `Cml::Foo` in `lib/chemicalml/cml/translator.rb`
+      or `value_translations.rb`.
+- [ ] Spec verifying `from_canonical(schema: :schema24)` produces
+      Schema24 children at every level (Document, Molecule, Atom,
+      Bond, Name, Identifier, etc.).
+
+## Acceptance
+
+- Round-trip canonical → Schema24 wire → canonical yields equal doc.
+- `wire.molecules.first` is a `Schema24::Molecule` (not Schema3).
+- `wire.molecules.first.atom_array.atoms.first` is a `Schema24::Atom`.

data/TODO.align/20-missing-translator-rules.md

@@ -0,0 +1,44 @@
+# 20 — Missing translator rules
+
+**Status:** complete
+**Depends on:** 19
+
+## Goal
+
+The Translator today handles: Document, Molecule, AtomArray,
+Atom, BondArray, Bond, Name, Identifier, Reaction, ReactionList,
+ReactantList, Reactant, ProductList, Product, Substance, plus
+value containers (Scalar, Array, Matrix, Property, Parameter),
+Label, Metadata, Formula via the ValueTranslations module.
+
+Missing: **Module** (compchem), **PropertyList**, **ParameterList**,
+**MetadataList**, **AtomParity**, **BondStereo**, **Dictionary**,
+**DictionaryEntry**, **Unit**, **UnitList**, **UnitType**,
+**UnitTypeList**, **List**.
+
+Add canonical ↔ wire rules for each so compchem modules and
+dictionaries can round-trip through canonical.
+
+## Why
+
+- Compchem modules can't be translated today — the wire class exists
+  but no canonical mapping does.
+- Dictionary / Unit / UnitType wire classes have no canonical
+  counterpart. They could reuse `Chemicalml::Dictionary::Model` etc.
+  but the Translator doesn't connect them.
+
+## Deliverables
+
+- [ ] `module_to_canonical` / `module_from_canonical` — handles
+      nested modules, parameter_lists, property_lists,
+      metadata_lists, molecules, lists.
+- [ ] `property_list_to_canonical` / `property_list_from_canonical`.
+- [ ] `parameter_list_to_canonical` / `parameter_list_from_canonical`.
+- [ ] `metadata_list_to_canonical` / `metadata_list_from_canonical`.
+- [ ] Specs covering each new rule.
+
+## Acceptance
+
+- Round-trip a compchem module fixture through canonical → wire →
+  canonical yields equal model.
+- Specs green.