chemicalml 0.2.1 → 0.3.0

data/TODO.align/68-detection-coverage.md

@@ -0,0 +1,33 @@
+# 68 — Detection coverage for all 8 conventions
+
+## Why
+
+`Convention::Detection.convention_of` lists 6 root roles (Document,
+Module, Molecule, Dictionary, UnitList, UnitTypeList). With 8
+conventions now registered, several conventions have no auto-detection
+path:
+
+| Convention   | Expected root role | Currently detected? |
+|--------------|--------------------|---------------------|
+| molecular    | Document / Module / Molecule | yes |
+| compchem     | Module             | yes |
+| dictionary   | Dictionary         | yes |
+| unit-dictionary | UnitList        | yes |
+| unitType-dictionary | UnitTypeList | yes |
+| spectroscopy | Spectrum / SpectrumList | **no** |
+| cascade      | ReactionScheme / ReactionList | **no** |
+| simpleUnit   | UnitList           | yes |
+
+## Work
+
+1. Extend `CONVENTION_ROOTS` to include:
+   - `Role::Spectrum`, `Role::SpectrumList`
+   - `Role::ReactionScheme`, `Role::ReactionList`
+2. Add specs covering each convention's auto-detection from a root
+   element with the right `convention` attribute.
+
+## Acceptance
+
+- `Detection.convention_of(spectrum)` returns the convention string
+  when the spectrum declares one.
+- All 8 conventions are auto-detectable from at least one root role.

data/TODO.align/69-json-yaml-roundtrip.md

@@ -0,0 +1,27 @@
+# 69 — JSON / YAML round-trip proof
+
+## Why
+
+CLAUDE.md claims "lutaml-model is format-agnostic (XML/JSON/YAML/TOML
+via adapters), so the same class supports whatever serialization
+lutaml-model supports". We have no specs proving this. If a downstream
+caller wants to serialize CML to JSON (e.g. for a REST API), we should
+verify it actually works.
+
+## Work
+
+Add `spec/chemicalml/cml/json_yaml_roundtrip_spec.rb` that:
+
+1. Constructs a representative CML model (Document with a Molecule
+   containing an AtomArray).
+2. Calls `to_json` / `from_json`.
+3. Calls `to_yaml` / `from_yaml`.
+4. Asserts the round-tripped model has the same data.
+5. Asserts `from_json(to_json(model))` is structurally equivalent to
+   `from_xml(to_xml(model))` for the same source model.
+
+## Acceptance
+
+- JSON round-trip spec passes.
+- YAML round-trip spec passes.
+- The spec proves the format-agnostic claim is true.

data/TODO.align/70-iterative-walker.md

@@ -0,0 +1,40 @@
+# 70 — Iterative tree walker
+
+## Why
+
+`Chemicalml::Convention::Constraint#walk_nodes` recurses through the
+wire tree. CML documents can be deeply nested (cascading modules,
+large reaction cascades, etc.) — recursion risks `SystemStackError`
+on real-world files.
+
+The constraint walker is also called from `Coordinator.validate`, so
+a stack overflow there aborts validation entirely.
+
+## Work
+
+Replace the recursive walk in `lib/chemicalml/convention/constraint.rb`
+with an iterative worklist:
+
+```ruby
+def walk_nodes(node, path = [], &block)
+  return unless visitable?(node)
+  worklist = [[node, path]]
+  until worklist.empty?
+    current, current_path = worklist.shift
+    yield(current, current_path)
+    children = current.wire_children.map do |child|
+      [child, current_path + [describe(child)]]
+    end
+    worklist.unshift(*children)
+  end
+end
+```
+
+This preserves the same traversal order (DFS pre-order) without
+recursion.
+
+## Acceptance
+
+- A deeply-nested CML document (100+ levels of nested Module) walks
+  without stack overflow.
+- All existing constraint specs pass unchanged.

data/TODO.align/71-violation-value.md

@@ -0,0 +1,25 @@
+# 71 — Enrich Violation with offending value
+
+## Why
+
+`Violation` carries `path`, `message`, `severity`, `constraint`.
+Debugging is harder than necessary because the actual offending value
+is not on the violation — only mentioned inside `message`. Callers
+that want to render violations in a UI or aggregate them need to
+parse the message string to extract the value.
+
+## Work
+
+1. Add an optional `value:` keyword to `Violation#initialize`. The
+   field is the literal offending value (e.g. the duplicated atom id
+   `"a1"`).
+2. Update `Constraint#violation` to forward `value:` to `Violation.new`.
+3. Constraint classes pass the offending value where natural
+   (e.g. duplicate id constraints pass the duplicate id).
+4. Specs assert the value is carried.
+
+## Acceptance
+
+- `Violation.new(path: "x", message: "y", value: "a1").value == "a1"`.
+- No existing spec breaks (value defaults to nil).
+- At least 3 constraints populate `value` with the offending value.

data/TODO.align/72-close-child-gaps.md

@@ -0,0 +1,66 @@
+# 72 — Close remaining Schema24 child gaps
+
+## Why
+
+After TODO 64 closed the bulk of Schema24 child gaps via
+`CommonChildren`, ~140 element-specific children remain unmodelled.
+These are concrete child declarations the XSD permits and real CML
+documents use.
+
+## Work
+
+Add element-specific children to each Base module below. For each,
+add a round-trip spec covering at least one new child.
+
+| Element | Children to add |
+|---|---|
+| reactiveCentre | atomSet, atomTypeList, bondSet, bondTypeList |
+| sample | molecule, substance, substanceList |
+| spectator | molecule, object |
+| transitionState | molecule, propertyList |
+| substance | amount, property |
+| substanceList | amount, propertyList |
+| lattice | matrix, scalar, symmetry |
+| table | arrayList, tableRowList |
+| trow | tcell |
+| unit | metadata, unitType (annotation via CommonChildren) |
+| unitType | dimension (annotation via CommonChildren) |
+| dictionary | unitList (annotation via CommonChildren) |
+| dictionaryEntry | alternative, enumeration, relatedEntry |
+| gradient | array, matrix, property, scalar |
+| eigen | array, matrix |
+| xaxis, yaxis | array |
+| zMatrix | angle, length, torsion |
+| symmetry | matrix, transform3 |
+| map | link |
+| join | angle, length, torsion, molecule, arg |
+| fragment | fragmentList, join |
+| fragmentList | join |
+| formula | formula (self-ref) |
+| parameter | expression, gradient, property |
+| potential | arg |
+| atomicBasisFunction | gradient |
+| isotope | abundance |
+| atomType | atom, molecule, scalar, array, matrix, property |
+| bondType | bond, molecule, scalar, array, matrix, property |
+| arg | atom, atomType, expression, scalar, array, matrix |
+| expression | operator, parameter |
+| potentialForm | arg, expression, parameter |
+| annotation | appinfo |
+| enumeration | annotation |
+| metadataList | metadataList (self-ref) |
+| moleculeList | list, moleculeList (self-ref) |
+| parameterList | parameterList (self-ref) |
+| productList | productList (self-ref) |
+| reactantList | reactantList (self-ref) |
+| reactionList | reactionScheme |
+| reactionScheme | identifier, reactionScheme (self-ref) |
+| reactionStep | reactionScheme |
+| peakGroup | atom, bond, molecule, peakGroup (self-ref) |
+| peakStructure | peakStructure (self-ref) |
+| spectrumList | list, spectrumList (self-ref) |
+
+## Acceptance
+
+- Static XSD child gap analysis (accounting for CommonChildren) reports < 20 remaining gaps.
+- All new child declarations have at least one round-trip spec.

data/TODO.align/73-schema24-parse-limitation.md

@@ -0,0 +1,64 @@
+# 73 — Document Schema24 nested-parse limitation
+
+## Why
+
+`Chemicalml::Cml::Schema24::Document.from_xml` fails on any document
+with non-trivial nested content:
+
+```ruby
+Chemicalml::Cml::Schema24::Document.from_xml(
+  %(<cml xmlns="http://www.xml-cml.org/schema"><molecule id="m1"/></cml>),
+  register: :chemicalml_schema24
+)
+# => Lutaml::Model::InvalidFormatError: Document has no root element.
+```
+
+Empty `<cml/>` parses; any child element triggers the failure.
+
+## Root cause
+
+Tracing the failure, the XML parser is invoked twice for nested
+content. The second call receives the *attribute value* (e.g. `"m1"`)
+instead of an XML fragment — indicating lutaml-model's TypeResolver
+is mis-resolving the child type. The error surfaces as
+`Unknown type 'molecule' in context 'default'`.
+
+Schema3 does not exhibit this. Both Schema3 and Schema24 register
+`:molecule` in their own contexts; the `chemicalml_schema24` context
+resolves `:molecule` to `Chemicalml::Cml::Schema24::Molecule`
+correctly when inspected directly. The failure is in the
+*attribute cast* path inside `Lutaml::Model::Attribute#cast`, which
+uses a different lookup mechanism that appears to default to the
+`:default` context.
+
+This looks like a lutaml-model issue with how `Attribute#cast` resolves
+child types when multiple schema-version contexts are registered
+globally. Investigating further requires changes inside lutaml-model.
+
+## Workaround
+
+Schema24 wire classes themselves work correctly when constructed
+directly:
+
+```ruby
+Chemicalml::Cml::Schema24::Molecule.new(id: "m1", atom_array: ...) # works
+Chemicalml::Cml::Schema24::Molecule#to_xml                          # works
+```
+
+So Schema24 round-trips through *construction → serialize*, just not
+through *parse → re-serialize*. Existing Schema24 specs use direct
+construction; they continue to pass.
+
+## Work
+
+1. Document this limitation in `CLAUDE.md` and in a comment on
+   `Schema24::Configuration`.
+2. Add a `pending: true` spec that asserts the behaviour fails today
+   and will catch the regression automatically when lutaml-model is
+   fixed.
+3. File an issue upstream in `lutaml/lutaml-model`.
+
+## Acceptance
+
+- CLAUDE.md notes the limitation.
+- Pending spec exists and is marked `pending`.

data/TODO.align/74-final-verification-round18.md

@@ -0,0 +1,15 @@
+# 74 — Final verification round 18
+
+## Work
+
+1. Full rspec suite — must be green.
+2. rubocop on touched files — must be clean.
+3. Forbidden-pattern scan: 0 hits for require_relative, def to_h/from_h/to_xml/from_xml on model classes, double( in specs, send(/instance_variable_*, respond_to? in lib/.
+4. Update CLAUDE.md with: Detection covers 8 conventions; JSON/YAML round-trip proven; iterative walker; enriched Violation; documented Schema24 limitation.
+5. Write `TODO.align/README.round18.md` summarising this round.
+
+## Acceptance
+
+- All four scans clean.
+- CLAUDE.md current.
+- README.round18.md exists.

data/TODO.align/75-key-value-mappings.md

@@ -0,0 +1,43 @@
+# 75 — key_value mappings for JSON / YAML wire names
+
+## Why
+
+`lutaml-model` supports a `key_value do ... end` block alongside
+`xml do ... end` to declare JSON/YAML wire names. Previously Base
+modules declared only XML mappings, so JSON output used Ruby
+snake_case names (`element_type`, `atom_array`) instead of CML wire
+names (`elementType`, `atomArray`).
+
+## Solution
+
+Each `Base::*` module now has an explicit `key_value do ... end`
+block written by hand, mirroring its `xml do ... end` block. The
+two blocks are kept in sync manually — no runtime introspection,
+no DSL, no generation.
+
+This is more verbose than the auto-generation approach
+(`Base::WireMappings.auto_key_value_mapping!`) that was tried and
+reverted. The user explicitly preferred manual blocks for clarity
+and explicitness over DRY.
+
+## Work done
+
+1. Generated initial `key_value do ... end` blocks from each
+   `Schema3::*` and `Schema24::*` wire class's XML mappings via a
+   one-shot script that introspected the loaded classes.
+2. Inserted each block into the corresponding `Base::*` file right
+   after the `xml do ... end` block.
+3. Removed `Base::WireMappings` module and all
+   `auto_key_value_mapping!` calls from wire classes.
+4. Verified JSON output carries CML wire names (`elementType`,
+   `atomArray`, `formalCharge`).
+5. Verified YAML also carries wire names.
+6. All 422 specs pass.
+
+## Acceptance
+
+- `Atom.new(element_type: "C").to_json` includes `"elementType":"C"`.
+- `Molecule.from_json(json)` round-trips wire names correctly.
+- All existing specs pass.
+- No runtime introspection or auto-generation — every key_value
+  block is hand-written in its Base module.

data/TODO.align/76-schema24-workaround.md

@@ -0,0 +1,57 @@
+# 76 — Schema24 parse bug: ROOT CAUSE FOUND AND FIXED
+
+## Status: FIXED
+
+## Root cause
+
+The Schema24 nested-XML parse bug had nothing to do with
+lutaml-model internals. The root cause was a **type-name collision**
+in the Schema24 context registry.
+
+Schema 2.4 declares legacy elements `<string>`, `<integer>`,
+`<float>` that share their XML names with lutaml-model primitive
+type names (`:string`, `:integer`, `:float`). The Schema24
+Configuration registered these CML element classes as types in the
+Schema24 context — shadowing the primitives.
+
+Every `attribute :foo, :string` cast in a Schema24 wire class then
+resolved `:string` to `Chemicalml::Cml::Schema24::String` (the CML
+element class, a `Lutaml::Model::Serializable`) instead of
+`Lutaml::Model::Type::String` (the primitive, which just casts to
+Ruby String). The Serializable.cast path on a String value tried to
+deserialize it as a CML `<string>` element, which failed.
+
+Schema3 was unaffected because Schema 3's XSD doesn't declare
+`<string>`, `<integer>`, `<float>` elements.
+
+## Fix
+
+`lib/chemicalml/cml/elements.rb` adds a new constant:
+
+```ruby
+SCHEMA24_TYPE_COLLISIONS = %i[Float Integer String].freeze
+```
+
+`lib/chemicalml/cml/schema24/configuration.rb#register_models!` now
+passes this list as `except:` when registering SCHEMA24_ONLY:
+
+```ruby
+register_elements!(
+  only: true,
+  except: Chemicalml::Cml::Elements::SCHEMA24_TYPE_COLLISIONS
+)
+```
+
+The CML `<string>`, `<integer>`, `<float>` wire classes remain
+defined and parseable as document roots (via VersionedParser), but
+they are no longer registered as types — so `:string` attribute
+casts resolve correctly to the primitive.
+
+## Verification
+
+- `Chemicalml::Cml::Schema24::Document.from_xml` now parses nested
+  content correctly.
+- `spec/chemicalml/cml/schema24_nested_parse_spec.rb` has 3 passing
+  tests including one with parallel-array atomArray.
+- Full suite: 422 examples, 0 failures (previously 2 pending — both
+  now pass).

data/TODO.align/77-convention-coverage-matrix.md

@@ -0,0 +1,31 @@
+# 77 — Convention coverage matrix spec
+
+## Why
+
+The gem registers 8 conventions, each with multiple constraints.
+Currently each convention has its own spec file, but there is no
+single source of truth asserting that every convention:
+
+- is in the Registry
+- is detectable via at least one root role
+- has at least one violation case for at least one of its constraints
+- has at least one passing-case example
+
+A matrix spec catches gaps when adding a new convention (the new
+convention's matrix entry fails until it has specs).
+
+## Work
+
+Add `spec/chemicalml/convention/coverage_matrix_spec.rb` that:
+
+1. Iterates `Convention::Registry.builtin_qnames`.
+2. For each, asserts the convention is detectable from its declared
+   root role.
+3. For each constraint class registered against the convention,
+   asserts a spec file exists that exercises it (grep for the class
+   name in `spec/`).
+
+## Acceptance
+
+- Matrix spec passes for all 8 conventions.
+- Adding a 9th convention without specs makes the matrix spec fail.

data/TODO.align/78-fixture-audit.md

@@ -0,0 +1,23 @@
+# 78 — Fixture coverage audit
+
+## Why
+
+`spec/fixtures/` holds CML examples. Current round-trip specs cover a
+subset. After recent additions (parallel-array attrs, CommonChildren,
+8 conventions), some features may have no fixture exercising them.
+
+## Work
+
+Audit `spec/fixtures/`:
+
+1. Identify fixtures that exercise parallel-array atomArray/bondArray.
+2. Identify fixtures covering each convention.
+3. Identify fixtures using new child elements (reaction.mechanism,
+   reactiveCentre.atomSet, etc.).
+4. For features with no fixture, add one under `spec/fixtures/`.
+
+## Acceptance
+
+- Every convention has at least one fixture.
+- Parallel-array form has at least one fixture.
+- Schema24-only legacy elements have at least one fixture.

data/TODO.align/79-final-verification-round19.md

@@ -0,0 +1,15 @@
+# 79 — Final verification round 19
+
+## Work
+
+1. Full rspec — must be green (or pending for documented limitations).
+2. rubocop on touched files.
+3. Forbidden-pattern scan.
+4. Update CLAUDE.md noting key_value support and JSON wire names.
+5. Write `TODO.align/README.round19.md`.
+
+## Acceptance
+
+- All four scans clean.
+- CLAUDE.md current.
+- README.round19.md exists.

data/TODO.align/80-xsd-enum-constants.md

@@ -0,0 +1,35 @@
+# 80 — XSD enum constants
+
+## Why
+
+The XSD declares ~30 simpleTypes that restrict to enumeration sets
+(orderType, stereoType, chiralityType, latticeType, matrixType,
+stateType, peakMultiplicityType, etc.). We model every attribute as
+`:string` and accept any value.
+
+Without a single source of truth for the allowed values, downstream
+callers that want to validate CML have to scrape the XSD themselves
+or hard-code the enums (which drift from the schema).
+
+## Solution
+
+`Chemicalml::Cml::Enums` — frozen-set constants for each XSD enum
+simpleType. The constants are the canonical Ruby source of truth
+for "what values does this attribute accept".
+
+## Work
+
+1. Create `lib/chemicalml/cml/enums.rb` with one constant per XSD
+   enum simpleType. Names match the XSD type name with `Type`
+   suffix stripped (e.g. `ORDER_VALUES` for `orderType`).
+2. Each constant is a frozen Set of allowed string values.
+3. Add specs asserting the constants match the XSD exactly.
+
+## Acceptance
+
+- `Chemicalml::Cml::Enums::ORDER_VALUES` includes `"S"`, `"D"`, `"T"`,
+  `"A"`, etc.
+- `Chemicalml::Cml::Enums::STEREO_VALUES` includes `"C"`, `"T"`, `"W"`,
+  `"H"`.
+- Constants are frozen.
+- Generated from the XSD (no hand-maintenance).

data/TODO.align/81-enum-validation-constraints.md

@@ -0,0 +1,29 @@
+# 81 — Enum validation constraints
+
+## Why
+
+With enum constants defined (TODO 80), add warning-severity
+constraints that flag attribute values outside the XSD-declared
+enum set. Warning (not error) because CML allows extension values.
+
+## Work
+
+Add constraints under the molecular convention (where most enum
+attributes live):
+
+1. `BondOrderShouldBeInEnum` (applies_to Role::Bond) — warning if
+   `bond.order` not in `Cml::Enums::ORDER_VALUES`.
+2. `BondStereoShouldBeInEnum` (applies_to Role::BondStereo) —
+   warning if `bondStereo.value` not in `Cml::Enums::STEREO_VALUES`.
+3. `MoleculeChiralityShouldBeInEnum` (applies_to Role::Molecule) —
+   warning if `molecule.chirality` not in `Cml::Enums::CHIRALITY_VALUES`.
+4. `LatticeTypeShouldBeInEnum` (applies_to Role::Lattice) —
+   warning if not in `LATTICE_VALUES`.
+
+Each constraint is registered against the molecular convention.
+
+## Acceptance
+
+- A bond with `order="X"` triggers a warning.
+- A bond with `order="S"` passes silently.
+- All existing specs pass.

data/TODO.align/82-reference-resolver.md

@@ -0,0 +1,33 @@
+# 82 — Reference resolver
+
+## Why
+
+CML documents reference atoms/bonds/molecules by id via attributes
+like `atomRefs2`, `atomRefs4`, `bondRefs`, `moleculeRefs`, `ref`.
+Currently callers must walk the document themselves to resolve
+these to actual instances.
+
+## Solution
+
+`Chemicalml::Cml::ReferenceResolver` — walks a document, builds an
+id → node index, then exposes lookup methods.
+
+## Work
+
+1. Create `lib/chemicalml/cml/reference_resolver.rb`.
+2. API:
+   ```ruby
+   resolver = Chemicalml::Cml::ReferenceResolver.new(document)
+   resolver.find_atom(molecule, "a1")     # → Atom or nil
+   resolver.resolve_atom_refs2(bond)      # → [Atom, Atom] or nils
+   resolver.unresolved_refs(document)     # → [{ source: Bond, attr: :atom_refs2, missing: ["a99"] }]
+   ```
+3. Add a constraint `ReferencesShouldResolve` (warning severity)
+   that lists unresolved refs in a document.
+4. Specs covering resolve + unresolved detection.
+
+## Acceptance
+
+- Resolver resolves a valid atomRefs2 to actual atoms.
+- `unresolved_refs` returns missing atom ids.
+- All existing specs pass.

data/TODO.align/83-toml-roundtrip.md

@@ -0,0 +1,20 @@
+# 83 — TOML round-trip spec
+
+## Why
+
+lutaml-model supports TOML as a key-value format. CLAUDE.md claims
+format-agnosticism — XML/JSON/YAML are tested. Add TOML to complete
+the set.
+
+## Work
+
+Add `spec/chemicalml/cml/toml_roundtrip_spec.rb` that round-trips
+a Molecule through `to_toml` / `from_toml`. TOML's flat key/value
+structure means nested objects get flattened — verify the same
+data survives.
+
+## Acceptance
+
+- `Molecule#to_toml` produces a TOML string.
+- `Molecule.from_toml(toml)` returns a Molecule with the same id
+  and atom data.

data/TODO.align/84-final-verification-round21.md

@@ -0,0 +1,16 @@
+# 84 — Final verification round 21
+
+## Work
+
+1. Full rspec — must be green.
+2. rubocop on touched files.
+3. Forbidden-pattern scan.
+4. Update CLAUDE.md noting enum validation, reference resolver,
+   TOML round-trip.
+5. Write `TODO.align/README.round21.md`.
+
+## Acceptance
+
+- All scans clean.
+- CLAUDE.md current.
+- README.round21.md exists.

data/TODO.align/85-bond-distinct-atoms.md

@@ -0,0 +1,25 @@
+# 85 — Bond atomRefs2 distinct constraint
+
+## Why
+
+The molecular spec at `reference-docs/conventions/molecular.md` says:
+
+> `atomRefs2` — REQUIRED, two distinct atom ids in same molecule
+
+No current constraint enforces distinctness. A `<bond atomRefs2="a1 a1"/>`
+(zero-length self-bond) is silently accepted.
+
+## Work
+
+Add `Molecular::Constraints::BondAtomRefs2ShouldBeDistinct` (warning
+severity — there are edge cases in non-classical chemistry). The
+constraint parses `node.atom_refs2`, splits on whitespace, and warns
+if the two ids are identical.
+
+Register against molecular convention.
+
+## Acceptance
+
+- `<bond atomRefs2="a1 a1"/>` triggers a warning.
+- `<bond atomRefs2="a1 a2"/>` passes silently.
+- All existing specs pass.

data/TODO.align/86-references-should-resolve.md

@@ -0,0 +1,20 @@
+# 86 — References-should-resolve constraint
+
+## Why
+
+With `Cml::ReferenceResolver` (TODO 82), we can now detect bonds
+whose `atomRefs2` reference atoms that don't exist in the parent
+molecule. Currently no constraint flags this — typos like
+`atomRefs2="a1 a99"` (where `a99` doesn't exist) pass silently.
+
+## Work
+
+Add `Molecular::Constraints::ReferencesShouldResolve` as a
+`DocumentConstraint`. It instantiates a `ReferenceResolver` and
+reports each unresolved reference as a warning violation.
+
+## Acceptance
+
+- A bond referencing a missing atom triggers a warning.
+- A bond referencing existing atoms passes silently.
+- All existing specs pass.

data/TODO.align/87-cli-utility.md

@@ -0,0 +1,26 @@
+# 87 — CLI utility for validation
+
+## Why
+
+A user-facing CLI makes the gem immediately useful for command-line
+validation of CML files. Without a CLI, users have to write Ruby
+to use the gem.
+
+## Work
+
+Create `exe/chemicalml` (executable) with subcommands:
+
+- `chemicalml validate <file>` — auto-detect convention, print
+  violations to stderr, exit non-zero if errors.
+- `chemicalml conventions` — list registered conventions.
+- `chemicalml dictionaries` — list builtin dictionaries.
+
+Wire it through `Chemicalml::Cli` module under
+`lib/chemicalml/cli.rb` so the logic is reusable.
+
+## Acceptance
+
+- `bundle exec chemicalml validate spec/fixtures/schema3/molecular/water.cml`
+  parses, detects convention:molecular, prints nothing, exits 0.
+- `chemicalml conventions` lists all 8 conventions.
+- `chemicalml dictionaries` lists all built-in dictionaries.