chemicalml 0.1.0 → 0.2.1

data/TODO.align/21-encapsulate-translator.md

@@ -0,0 +1,33 @@
+# 21 — Encapsulate translator internals
+
+**Status:** complete
+**Depends on:** 19, 20
+
+## Goal
+
+The Translator has 17 public class methods today. Only `to_canonical`
+and `from_canonical` are part of the public API. Every helper
+(`molecule_to_canonical`, `atom_from_canonical`, `cml_order_to_kind`,
+etc.) is an implementation detail and should be private.
+
+## Why
+
+- Public API surface = mental load for users. They see 17 methods and
+  wonder which to use.
+- Internal helpers shouldn't be callable from outside — encapsulation
+  violation.
+- Risk: a future refactor (e.g. visitor pattern) would need to keep
+  these as public for backward compat.
+
+## Deliverables
+
+- [ ] Add `private_class_method` for every helper method on
+      `Translator`.
+- [ ] Same for `ValueTranslations::ClassMethods` helpers.
+- [ ] Verify no spec or external code calls the helpers directly.
+
+## Acceptance
+
+- `Chemicalml::Cml::Translator.public_methods(false)` returns only
+  `to_canonical` and `from_canonical`.
+- All specs still pass.

data/TODO.align/22-dry-role-modules.md

@@ -0,0 +1,32 @@
+# 22 — DRY role modules
+
+**Status:** rejected
+**Depends on:** —
+
+## Goal (rejected)
+
+Replace 36 nearly-identical Role module files with a single
+`Elements::ALL.each_key { const_set(class_name, Module.new) }`
+block.
+
+## Why rejected
+
+`const_set(class_name, Module.new)` is **eager** — every role module
+is created when `cml/role.rb` loads. The user's global rule mandates
+**autoload** (lazy file loading), not `const_set`. The two are not
+equivalent:
+
+- `autoload :Foo, "path"` — registers a hook; the file loads only
+  when `Foo` is first referenced. Enables lazy loading, avoids
+  circular dependencies, keeps the load path clean.
+- `const_set(:Foo, Module.new)` — creates the constant eagerly at
+  file-load time. No lazy loading.
+
+The 36 tiny role files are the price of admission for the lazy-load
+guarantee. They stay.
+
+## Acceptance
+
+- Keep the 36 individual role files under `lib/chemicalml/cml/role/`.
+- Keep the autoload declarations in `lib/chemicalml/cml/role.rb`.
+- Do not use `const_set` for role modules.

data/TODO.align/23-final-spec-lint.md

@@ -0,0 +1,25 @@
+# 23 — Final spec + lint pass
+
+**Status:** complete
+**Depends on:** all
+
+## Goal
+
+Run the full suite, audit forbidden patterns, document final state.
+
+## Deliverables
+
+- [ ] `bundle exec rspec spec/chemicalml/` green.
+- [ ] `Chemicalml::Cml::Translator.public_methods(false)` returns only
+      `to_canonical` and `from_canonical`.
+- [ ] No hardcoded `Cml::Foo.new` in translator files.
+- [ ] `from_canonical(schema: :schema24)` produces Schema24 children
+      at every level (spec verification).
+- [ ] `lib/chemicalml/cml/role/` directory removed.
+- [ ] Zero `require_relative`, `respond_to?`, `instance_variable_set`/`get`,
+      private `send` in lib/.
+- [ ] TODO.align/README.round3.md marked complete.
+
+## Acceptance
+
+All checks pass.

data/TODO.align/24-autoload-wire-classes.md

@@ -0,0 +1,84 @@
+# 24 — Autoload wire classes (revert round-2 task 12)
+
+**Status:** complete
+**Depends on:** —
+
+## Goal
+
+Replace the `const_set`-based wire class generation in `schema3.rb`
+and `schema24.rb` with per-class files loaded via `autoload`.
+
+## Why
+
+Round 2 task 12 consolidated 72 per-class files into two `const_set`
+loops. The user later pushed back on the same `const_set` pattern in
+role modules — `const_set` is eager, not autoload. The same logic
+applies here: `autoload` is required for lazy loading.
+
+## Design
+
+To avoid 72 nearly-identical boilerplate files, each schema gets a
+`Context` module that provides `lutaml_default_register`:
+
+```ruby
+# lib/chemicalml/cml/schema3/context.rb
+module Chemicalml
+  module Cml
+    module Schema3
+      module Context
+        def lutaml_default_register
+          :chemicalml_schema3
+        end
+      end
+    end
+  end
+end
+```
+
+Each per-class file is then minimal:
+
+```ruby
+# lib/chemicalml/cml/schema3/atom.rb
+module Chemicalml
+  module Cml
+    module Schema3
+      class Atom < Lutaml::Model::Serializable
+        include Base::Atom
+        include Visitable
+        extend Context
+      end
+    end
+  end
+end
+```
+
+And `schema3.rb` declares autoloads:
+
+```ruby
+module Schema3
+  autoload :Atom, "chemicalml/cml/schema3/atom"
+  autoload :Molecule, "chemicalml/cml/schema3/molecule"
+  # ...
+end
+```
+
+## Deliverables
+
+- [ ] `lib/chemicalml/cml/schema3/context.rb` — provides
+      `lutaml_default_register` returning `:chemicalml_schema3`.
+- [ ] `lib/chemicalml/cml/schema24/context.rb` — same for
+      `:chemicalml_schema24`.
+- [ ] 36 per-class files under `lib/chemicalml/cml/schema3/` (one
+      per element in `Elements::ALL`).
+- [ ] 35 per-class files under `lib/chemicalml/cml/schema24/` (no
+      `Module` — schema 2.4 lacks it).
+- [ ] `schema3.rb` / `schema24.rb` rewritten with autoloads only,
+      no `const_set`.
+- [ ] All specs pass.
+
+## Acceptance
+
+- `grep -rn 'const_set' lib/chemicalml/cml/schema3.rb
+      lib/chemicalml/cml/schema24.rb` returns nothing.
+- `Schema3::Atom` loads lazily (only when referenced).
+- All 155+ specs still pass.

data/TODO.align/25-value-container-schema-awareness.md

@@ -0,0 +1,44 @@
+# 25 — value_container schema-awareness
+
+**Status:** complete
+**Depends on:** —
+
+## Goal
+
+`Chemicalml::Cml::Translator::ValueTranslations` provides
+`scalar_from_canonical`, `array_from_canonical`,
+`matrix_from_canonical`, `value_container_from_canonical`, etc. All
+of them hardcode `Cml::Scalar` / `Cml::Array` / `Cml::Matrix` (which
+are Schema3 aliases).
+
+When `Translator.from_canonical(doc, schema: :schema24)` is called
+and the document has properties with scalar values, the scalars end
+up as `Schema3::Scalar` instances inside `Schema24::Property` objects
+— same kind of bug we just fixed for Document → Molecule → Atom.
+
+## Why
+
+Consistency. The Translator's main `from_canonical` is now
+schema-aware via `WireClassRegistry`. The value-container path should
+be too.
+
+## Deliverables
+
+- [ ] `scalar_from_canonical(scalar, schema:)`,
+      `array_from_canonical(array, schema:)`,
+      `matrix_from_canonical(matrix, schema:)` — take schema, look
+      up wire class via `WireClassRegistry`.
+- [ ] `value_container_from_canonical(value, schema:)` — passes
+      schema through.
+- [ ] `property_from_canonical(prop, schema:)`,
+      `parameter_from_canonical(param, schema:)` — passes schema to
+      value_container_from_canonical.
+- [ ] All callers updated.
+- [ ] Spec verifying `Schema24::Property` has `Schema24::Scalar`
+      children.
+
+## Acceptance
+
+- A round-trip canonical → Schema24 wire with a property+scalar
+      produces `Schema24::Property` with a `Schema24::Scalar` value.
+- All specs pass.

data/TODO.align/26-remove-dead-code.md

@@ -0,0 +1,16 @@
+# 26 — Remove dead wire_class_macro.rb
+
+**Status:** complete
+**Depends on:** —
+
+## Goal
+
+`lib/chemicalml/cml/wire_class_macro.rb` is dead code — a leftover
+from the round-2 macro experiment. Nothing references it. Remove.
+
+## Acceptance
+
+- `lib/chemicalml/cml/wire_class_macro.rb` deleted.
+- No references to `WireClassMacro` or `define_wire_classes` in lib/
+  or spec/.
+- All specs pass.

data/TODO.align/27-final-spec-lint.md

@@ -0,0 +1,26 @@
+# 27 — Final spec + lint pass
+
+**Status:** complete
+**Depends on:** all
+
+## Goal
+
+Verify the round-4 changes don't regress anything and the autoload
+rule is now satisfied everywhere it can be.
+
+## Deliverables
+
+- [ ] `bundle exec rspec spec/chemicalml/` green.
+- [ ] `grep -rn 'const_set' lib/chemicalml/cml/schema3.rb
+      lib/chemicalml/cml/schema24.rb` clean.
+- [ ] `grep -rn 'require_relative' lib/` clean.
+- [ ] `grep -rn '^require .chemicalml' lib/` clean.
+- [ ] `grep -rn 'respond_to?' lib/` clean.
+- [ ] `grep -rn 'instance_variable_set\|instance_variable_get' lib/`
+      clean.
+- [ ] `grep -rnE '[^a-zA-Z_\.]send[ ]*\(' lib/` clean.
+- [ ] TODO.align/README.round4.md shows every workstream complete.
+
+## Acceptance
+
+All checks pass.

data/TODO.align/28-stereo-model.md

@@ -0,0 +1,40 @@
+# 28 — Model::AtomParity + Model::BondStereo
+
+**Status:** complete
+**Depends on:** —
+
+## Goal
+
+Add canonical Model classes for the CML stereo elements `<atomParity>`
+and `<bondStereo>`. Wire classes exist; the canonical layer is
+missing.
+
+## Why
+
+CML's molecular convention uses `<atomParity>` (atom-centre chirality)
+and `<bondStereo>` (cis/trans + wedge/hatch) to represent
+stereochemistry. Without canonical classes, the gem can parse these
+elements but can't represent them in the format-agnostic model —
+forcing callers to drop stereo info when going through canonical.
+
+## Deliverables
+
+- [ ] `lib/chemicalml/model/atom_parity.rb` — Model::AtomParity with
+      `atom_refs4` (four atom IDs as array) and `value` (typically
+      `"1"`, `"-1"`, `"0"`).
+- [ ] `lib/chemicalml/model/bond_stereo.rb` — Model::BondStereo with
+      `atom_refs2` (optional array), `atom_refs4` (optional array),
+      `dict_ref` (optional), `value` (the convention letter: `"W"`,
+      `"H"`, `"C"`, `"T"`, `"other"`).
+- [ ] Both classes inherit from `Model::Node` and implement
+      `value_attributes`.
+- [ ] Autoloads declared in `lib/chemicalml/model.rb`.
+- [ ] Specs.
+
+## Acceptance
+
+- `Chemicalml::Model::AtomParity.new(atom_refs4: %w[a1 a2 a3 a4], value: "1")`
+      works.
+- `Chemicalml::Model::BondStereo.new(atom_refs4: %w[a1 a2 a3 a4], value: "C")`
+      works.
+- Specs pass.

data/TODO.align/29-stereo-wire-children.md

@@ -0,0 +1,30 @@
+# 29 — Wire Atom/Bond to carry stereo children
+
+**Status:** complete
+**Depends on:** 28
+
+## Goal
+
+Today `Base::Atom` doesn't declare an `atom_parity` child attribute.
+Same for `Base::Bond` and `bond_stereo`. So parsing a fixture with
+`<atom><atomParity .../></atom>` silently drops the parity. Add the
+child attributes to the Base mixins.
+
+## Why
+
+Without this, the wire classes can't represent stereo even though
+their dedicated wire classes (AtomParity, BondStereo) exist.
+
+## Deliverables
+
+- [ ] `Base::Atom` declares `attribute :atom_parity, :atomParity`
+      and `xml do map_element "atomParity", to: :atom_parity end`.
+- [ ] `Base::Bond` declares `attribute :bond_stereo, :bondStereo`
+      and `xml do map_element "bondStereo", to: :bond_stereo end`.
+- [ ] Parse a fixture with `<atomParity>` and confirm it's loaded.
+- [ ] Round-trip preserves the child.
+
+## Acceptance
+
+- Parsing `ethene_with_bond_stereo.cml` retains the bondStereo.
+- Parsing `chiral_center.cml` retains the atomParity.

data/TODO.align/30-stereo-translator.md

@@ -0,0 +1,32 @@
+# 30 — Translator rules for stereo
+
+**Status:** complete
+**Depends on:** 28, 29
+
+## Goal
+
+Add Translator rules so stereo elements round-trip through the
+canonical Model:
+
+- `atom_parity_to_canonical` / `atom_parity_from_canonical`
+- `bond_stereo_to_canonical` / `bond_stereo_from_canonical`
+
+And wire them into `molecule_to_canonical` / `molecule_from_canonical`
+so atoms and bonds carry their stereo children across the translation.
+
+## Deliverables
+
+- [ ] Translator methods for both elements, schema-aware via
+      WireClassRegistry.
+- [ ] `molecule_to_canonical` reads `cml_atom.atom_parity` and
+      translates it.
+- [ ] `molecule_from_canonical` writes the parity back to the wire atom.
+- [ ] Same for bonds and `bond_stereo`.
+- [ ] Spec round-tripping a chiral molecule through canonical.
+
+## Acceptance
+
+- Round-trip a chiral_center fixture through canonical preserves
+      the atomParity value.
+- Round-trip ethene_with_bond_stereo through canonical preserves
+      the bondStereo.

data/TODO.align/31-final-spec-lint.md

@@ -0,0 +1,20 @@
+# 31 — Final spec + lint pass
+
+**Status:** complete
+**Depends on:** all
+
+## Goal
+
+Verify the stereo additions don't regress anything.
+
+## Deliverables
+
+- [ ] `bundle exec rspec spec/chemicalml/` green.
+- [ ] Round-trip of chiral_center.cml and ethene_with_bond_stereo.cml
+      preserves the stereo elements.
+- [ ] Zero forbidden patterns in lib/.
+- [ ] TODO.align/README.round5.md marked complete.
+
+## Acceptance
+
+All checks pass.

data/TODO.align/32-polymorphic-translator.md

@@ -0,0 +1,43 @@
+# 32 — Polymorphic Translator
+
+**Status:** complete
+**Depends on:** —
+
+## Goal
+
+`Translator.to_canonical` and `from_canonical` currently only handle
+Document roots. A compchem `<module>` root can't go through the
+canonical round-trip via the public API — callers must know to use
+`module_to_canonical` / `module_from_canonical` directly.
+
+Make both methods polymorphic: dispatch on the input's class via
+Role module checks.
+
+## Why
+
+Consistency with the rest of the gem. `WireClassRegistry` already
+abstracts over schema versions; the Translator should abstract over
+root element kinds too. Users shouldn't need to know upfront whether
+their CML is `<cml>`-rooted or `<module>`-rooted.
+
+## Deliverables
+
+- [ ] `Translator.to_canonical(node)`:
+      - if `node.is_a?(Chemicalml::Cml::Role::Document)` → existing
+        document translation
+      - if `node.is_a?(Chemicalml::Cml::Role::Module)` →
+        `module_to_canonical(node)`
+      - else raise `ArgumentError`
+- [ ] `Translator.from_canonical(node, schema:)`:
+      - if `node.is_a?(Chemicalml::Model::Document)` → existing
+        document translation
+      - if `node.is_a?(Chemicalml::Model::Module)` →
+        `module_from_canonical(node, schema: schema)`
+      - else raise `ArgumentError`
+
+## Acceptance
+
+- Compchem fixture's wire Module translates to canonical Module
+      through the public `to_canonical` API.
+- Canonical Module translates back through `from_canonical`.
+- Unknown input raises `ArgumentError`.

data/TODO.align/33-polymorphic-parse.md

@@ -0,0 +1,43 @@
+# 33 — Polymorphic Chemicalml.parse
+
+**Status:** complete
+**Depends on:** 32
+
+## Goal
+
+`Chemicalml.parse(xml)` today only handles `<cml>`-rooted documents.
+Compchem documents rooted at `<module>` silently parse as empty
+Documents — the content is dropped without warning.
+
+Detect the root element via a regex peek and dispatch to the right
+parser.
+
+## Why
+
+Silent data loss. Today's behavior:
+```
+Chemicalml.parse(File.read("h2_dft.cml"))
+# => #<Chemicalml::Cml::Schema3::Document molecules=[] reactions=[]>
+```
+
+The caller has no indication that all the jobList / job / init / fin
+content was dropped. Should be either parsed correctly or raise an
+error.
+
+## Deliverables
+
+- [ ] `Chemicalml.parse(xml, schema:)` peeks the root tag.
+- [ ] `cml`, `molecule`, `reactionList`, `reaction` → Document parser.
+- [ ] `module` → Module parser (Schema3 only — Schema 2.4 lacks it).
+- [ ] Unknown root → `ArgumentError`.
+- [ ] Return type matches the root: Document or Module.
+- [ ] `Chemicalml.serialize(node)` remains polymorphic — already
+      just calls `node.to_xml`.
+
+## Acceptance
+
+- `Chemicalml.parse(File.read("h2_dft.cml"))` returns a Schema3 Module
+      with the jobList intact.
+- `Chemicalml.parse(File.read("water.cml"))` continues to return a
+      Schema3 Document.
+- Unknown root raises `ArgumentError`.

data/TODO.align/34-polymorphic-specs.md

@@ -0,0 +1,16 @@
+# 34 — Polymorphic API specs
+
+**Status:** complete
+**Depends on:** 32, 33
+
+## Goal
+
+Specs covering:
+- Compchem fixture parses to a non-empty Schema3 Module.
+- Polymorphic Translator dispatches Document and Module correctly.
+- Unknown roots / inputs raise ArgumentError.
+- Round-trip compchem → canonical → compchem preserves structure.
+
+## Acceptance
+
+All specs green.

data/TODO.align/35-final-spec-lint.md

@@ -0,0 +1,10 @@
+# 35 — Final spec + lint pass
+
+**Status:** complete
+**Depends on:** all
+
+## Acceptance
+
+- `bundle exec rspec spec/chemicalml/` green.
+- Zero forbidden patterns in lib/.
+- TODO.align/README.round6.md marked complete.

data/TODO.align/36-molecular-convention-coverage.md

@@ -0,0 +1,46 @@
+# 36 — Molecular convention: full upstream constraint coverage
+
+## Why
+
+`reference-docs/conventions/molecular.md` mandates more rules than the
+gem currently enforces. The walker framework already exists; this is
+purely additive constraint registration.
+
+## Current constraints (13)
+
+AtomArrayMustContainAtoms, AtomIdsUniqueWithinMolecule,
+BondMustReferenceAtomsInSameMolecule, AtomMustHaveId,
+AtomMustHaveElementType, BondMustHaveAtomRefs2, BondMustHaveOrder,
+MoleculeMustHaveId, AtomCoordinatesMustBePaired,
+PropertyMustHaveDictRef, ScalarMustHaveDataType,
+BondOrderShouldNotBeNumeric, AtomIdMustMatchPattern.
+
+## Missing rules per upstream spec
+
+- `count` attribute MUST NOT appear on top-level molecules (only on
+  children of another molecule).
+- `atomArray` — at most one per molecule; mutually exclusive with
+  child `<molecule>` elements.
+- `bondArray` — at most one per molecule; mutually exclusive with
+  child `<molecule>` elements.
+- `bondStereo` value `W` or `H` MUST have `atomRefs2`, MUST NOT have
+  `atomRefs4`.
+- `bondStereo` value `C` or `T` MUST have `atomRefs4`, MUST NOT have
+  `atomRefs2`.
+- `bondStereo` value `other` MUST have `dictRef`.
+- `bond` `id` MUST be unique within the eldest containing molecule.
+- `bond` with `order="other"` MUST have `dictRef`.
+- `atomArray` MUST be a child of `molecule` or `formula`.
+- `bondArray` MUST be a child of `molecule`.
+
+## Implementation
+
+Each rule → one Constraint subclass + `register` call in
+`lib/chemicalml/convention/molecular.rb`. New files autoloaded from
+`lib/chemicalml/convention/molecular/constraints.rb`.
+
+## Acceptance
+
+- 10 new constraint classes registered.
+- Per-class spec under `spec/chemicalml/convention/molecular/`.
+- Full suite still green.

data/TODO.align/37-compchem-convention-coverage.md

@@ -0,0 +1,55 @@
+# 37 — CompChem convention: full upstream constraint coverage
+
+## Why
+
+`reference-docs/conventions/compchem.md` defines a deep module
+structure (jobList → job → initialization/calculation/finalization/
+environment) and value-container rules. The gem currently ships only
+2 of the ~19 rules.
+
+## Current constraints (2)
+
+CompchemModuleMustContainJobList, JobMustContainInitialization.
+
+## Missing structural rules
+
+- `jobList` module MUST have `id` unique within compchem module.
+- `job` module MUST have `id` unique within compchem module.
+- `job` module MUST contain at most one `finalization`.
+- `job` module MUST contain at most one `environment`.
+- If a `calculation` is present in a `job`, a `finalization` MUST
+  also be present (co-constraint).
+- `initialization` module MUST NOT contain `property`/`propertyList`.
+- `initialization` module MUST NOT contain more than one `molecule`.
+- `initialization` module MUST NOT contain more than one
+  `parameterList`.
+- `finalization` module MUST NOT contain `parameter`/`parameterList`.
+- `finalization` module MUST NOT contain more than one `molecule`.
+- `finalization` module MUST NOT contain more than one `propertyList`.
+- `environment` module MUST NOT contain more than one `propertyList`.
+- `environment` module MUST NOT contain `parameter`/`parameterList`
+  directly.
+
+## Missing value-container rules
+
+- `scalar` with `dataType` `xsd:integer` or `xsd:double` MUST have
+  `units`.
+- `scalar` with `dataType` `xsd:string` MUST NOT have `units`.
+- `array` MUST have `size` ≥ 1; `dataType` MUST be integer or double;
+  MUST have `units`.
+- `matrix` MUST have `rows` ≥ 1 and `columns` ≥ 1; `dataType` MUST
+  be integer or double; MUST have `units`.
+
+## Implementation
+
+Use `DocumentConstraint` for cross-node rules (calculation→finalization
+co-constraint), `NodeConstraint` for single-node rules.
+
+CompChem modules are `<module dictRef="compchem:*">`. Match by
+`node.is_a?(Chemicalml::Cml::Role::Module)` then check `dict_ref`.
+
+## Acceptance
+
+- 17 new constraint classes registered.
+- Per-class spec under `spec/chemicalml/convention/compchem/`.
+- Full suite still green.

data/TODO.align/38-dictionary-convention-coverage.md

@@ -0,0 +1,34 @@
+# 38 — Dictionary convention: full upstream constraint coverage
+
+## Why
+
+`reference-docs/conventions/dictionary.md` requires namespace,
+definition children, id patterns, and unitType/units co-constraints.
+Currently 2 of 7 rules enforced.
+
+## Current constraints (2)
+
+EntryMustHaveIdAndTerm, EntryIdsUniqueWithinDictionary.
+
+## Missing rules
+
+- `dictionary` MUST have `namespace` attribute.
+- `dictionary` `namespace` SHOULD end with `/` or `#` (warning).
+- `entry` MUST contain a single `definition` child.
+- `entry` `id` MUST match `[A-Za-z][A-Za-z0-9._-]*`.
+- `entry` MUST have `unitType` attribute.
+- If `unitType` is `unknown`, `units` MUST NOT be present.
+- If `unitType` is `none`, `units` MUST be present and point to
+  `http://www.xml-cml.org/unit/si#none`.
+
+## Implementation
+
+New files under
+`lib/chemicalml/convention/dictionary/constraints/`, registered in
+`lib/chemicalml/convention/dictionary.rb`.
+
+## Acceptance
+
+- 7 new constraint classes registered.
+- Per-class spec under `spec/chemicalml/convention/dictionary/`.
+- Full suite still green.

data/TODO.align/39-unit-dictionary-convention-coverage.md

@@ -0,0 +1,33 @@
+# 39 — Unit-dictionary convention: full upstream constraint coverage
+
+## Why
+
+`reference-docs/conventions/unit-dictionary.md` requires 8 attributes
+on every `<unit>`. The gem currently ships 1 rule.
+
+## Current constraints (1)
+
+UnitMustHaveSymbolAndUnitType.
+
+## Missing rules
+
+- `unitList` MUST have `namespace` attribute.
+- `unit` MUST have `id` (unique within unitList — already implied by
+  pattern rules but enforce presence).
+- `unit` MUST have `title` attribute.
+- `unit` MUST have `parentSI` attribute.
+- `unit` MUST have at least one of `multiplierToSI` or `constantToSI`.
+- `unit` MUST contain a single `definition` child.
+- `unitList` MUST contain at least one `unit` child.
+
+## Implementation
+
+NodeConstraint subclasses. Register in
+`lib/chemicalml/convention/unit_dictionary.rb`.
+
+## Acceptance
+
+- 7 new constraint classes registered (some may consolidate with
+  existing UnitMustHaveSymbolAndUnitType).
+- Per-class spec under `spec/chemicalml/convention/unit_dictionary/`.
+- Full suite still green.