asciichem 0.31.15 → 0.31.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3246a177690e1019834ab1e177da12f75aee9a7a75cdaa6caecaa3e7a721b227
-  data.tar.gz: e2194852b615ef5e61ddea0726e8b279543c6cbad326991a6238adf791e8d87c
+  metadata.gz: 96ad0bea754dd62a7b5b92f44cf87d1446a7afc1594634f903fd744c7c7c0326
+  data.tar.gz: 00d721ea5ba129cbd6f6b606167469178c83ec17ca53ecf1749160d337ea5639
 SHA512:
-  metadata.gz: 9fb5e64c26d57111cb9a742388228e225a99da2965d5ac7793cf8ec2366367a3c3b4ed24c14aab1c173f03d324309bd0f34919c52d29a0ee569cb34de88d1012
-  data.tar.gz: cc604167f949bac08b2f47c1dd6ec69e76d1b85ec9d2158ed7d0004a1c0f60c368ec5c1c5a6544fec68f6cc9f71ffec197d1fc2eb165c7da3ea6062e039db7f1
+  metadata.gz: a4d8d30b7b44a9b4b8ac460708a38e5eaf122a90a3d53c387bda976390eab2e41cf6750742c88755d5147119fa15f58758f4a55c9f846165b21b7ec0986a6bc3
+  data.tar.gz: c3e7da0afbcd8f8cce91335c6f722fc797af05d461952b743913e4e12066c25962a3add7db9deca81e7baccde11ac3fcd5b662f1c6bd787b722f608d84b459d7

data/.github/workflows/ci.yml

@@ -9,7 +9,7 @@ env:
   # Hermetic CI: the corpus ref is pinned, never floating. Bump this
   # one line deliberately with each corpus release (the tag carries
   # what changed).
-  CORPUS_REF: v0.8.0
+  CORPUS_REF: v0.11.0
 
 jobs:
   test:

data/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to AsciiChem are documented here.
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [0.31.17] - 2026-11-13
+
+### Added
+- The resolver clock seam: `resolve_all` and every adapter accept a
+  `now:` ISO-8601 UTC timestamp (nil = the wall clock) that pins
+  `retrievedAt` — recorded-fixture runs and the citation goldens that
+  consume them compare byte-stably. Mirrors the asciichem-py seam of
+  the same name.
+
+### Changed
+- The conformance runner gates the corpus 0.11.0 parity families
+  (linter-expectations with engine posture + node matching, resolver
+  replay, citation byte-goldens, the 22 CLI contracts); the CI
+  corpus pin moves v0.8.0 → v0.11.0. Claims matrix: linter 27 run +
+  3 posture skips, resolver 6/6, citation 4/4 byte-equal, CLI 22/22
+  (asciichem-ruby#159).
+
+## [0.31.16] - 2026-11-12
+
+### Changed
+- **The legacy parse engines are deleted.** The PARG artifact engine
+  is the one engine: `AsciiChem.parse` goes straight through the
+  checksummed asciichem PARG artifact (asciichem-parg) — the same
+  artifact the Rust crate embeds. Removed: the parslet Parser, the
+  parslet Transform wrapper, ParsletEngine, ParsanolEngine, the
+  Engine selector + the ASCIICHEM_ENGINE seam, the `--engine` CLI
+  flag, and the parslet gem dependency. The shared rule definitions
+  the PARG transform consumes stay. 376 lines removed; suite 2327/0.
+- The gemspec carries parsanol (~> 1.3) — the PARG runtime.
+
 ## [0.31.15] - 2026-11-12
 
 ### Fixed

data/asciichem.gemspec

@@ -40,7 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "lutaml-model", "~> 0.8"
   spec.add_dependency "mml", "~> 2.3"
   spec.add_dependency "moxml", "~> 0.6.1"
-  spec.add_dependency "parslet", "~> 2.0"
+  spec.add_dependency "parsanol", "~> 1.3", ">= 1.3.107"
   spec.add_dependency "relaton-bib", "~> 2.1"
   spec.add_dependency "plurimath", "~> 0.11"
   spec.add_dependency "thor", "~> 1.3"

data/benchmarks/RESULTS.md

@@ -42,6 +42,32 @@ than 2x.
 | electron config | _tbd_ | _tbd_ | _tbd_ |
 | bonds (H-O-H=O#H) | _tbd_ | _tbd_ | _tbd_ |
 
+## Cross-runtime parse comparison (2026-11-12)
+
+The shared workload (the ten inputs the TS bench and the rs bench
+pin — see `benchmarks/README.md`), per parse input, on the
+maintainer's machine:
+
+| Runtime | Engine | per parse |
+|---|---|---|
+| TypeScript (peggy) | peggy-generated JS | **~32 µs** |
+| Python (rd) | rd grammar port | ~672 µs |
+| Ruby (parslet) | parslet | ~2,960 µs |
+| Rust (parsanol) | parsanol portable parser | ~200 µs |
+
+Recorded via `npm run bench` (asciichem-ts), `python3
+benchmarks/engines.py` (asciichem-py), `bundle exec ruby
+benchmarks/engines.rb` (the gem), and `cargo bench -- --quick`
+(asciichem-rs, criterion, shared workload — see the crate's
+`benches/parse.rs`).
+
+Two Rust facts from the same pass: the deep-stack parse thread is
+spawned once and reused, and inputs ≤ 16 KiB parse inline (PEG
+depth is bounded by input length) — both landed in
+asciichem-rs#24. The remaining Rust-vs-peggy gap is parsanol's
+evaluation loop (setup 12 µs, eval ~37 µs for tiny inputs); the
+optimization lever lives in the parsanol repo.
+
 ## When to investigate
 
 - Any input that drops below 100 ips on parse.

data/lib/asciichem/cli.rb

@@ -20,18 +20,12 @@ module AsciiChem
                          desc: 'Input grammar: asciichem|smiles|molfile'
     method_option :format, aliases: '-t', type: :string, default: 'mathml',
                            desc: 'Output format'
-    method_option :engine, type: :string, default: 'parslet',
-                           desc: 'Parsing engine: parslet (default) | parsanol (opt-in, needs the parsanol gem)'
     def convert
       raise AsciiChem::ParseError, 'provide -i INPUT or -f FILE' unless options['input'] || options['file']
 
-      select_engine(options[:engine])
       source = read_source
       formula = ingest(source, options[:from])
       puts render(formula, options[:format])
-    rescue AsciiChem::Engine::Error => e
-      warn "Engine error: #{e.message}"
-      exit 6
     rescue AsciiChem::ParseError => e
       warn "Parse error: #{e.message}"
       exit 1
@@ -206,15 +200,6 @@ module AsciiChem
 
     private
 
-    # --engine feeds the Engine selector (0.29.0+); :parsanol is an
-    # opt-in soft dependency, :parslet stays the default.
-    def select_engine(name)
-      return if name.to_s == 'parslet' && AsciiChem::Engine.current == AsciiChem::Engine::ParsletEngine
-
-      require 'asciichem/engine'
-      AsciiChem::Engine.use(name.to_s)
-    end
-
     def read_source
       return File.read(options[:file]) if options[:file]
       return $stdin.read if options[:input] == '-'

data/lib/asciichem/engine.rb

@@ -1,61 +1,19 @@
 # frozen_string_literal: true
 
 module AsciiChem
-  # Parsing engine selector (TODO.impl 63/64; parsanol-ruby#25).
-  #
-  # The reference engine is :parslet (pure Ruby, zero extra
-  # dependencies) and remains the default. The :parsanol engine runs
-  # the SAME rules (GrammarRules/TransformRules) over Parsanol's
-  # Rust-backed parslet-compat layer — the shared corpus passes
-  # byte-for-byte (221/221) at ~3x parslet speed.
-  #
-  # Parsanol is an opt-in soft dependency; the gemspec is unchanged:
-  #
-  #   # Gemfile
-  #   gem "parsanol", "~> 1.3.16"
-  #
-  #   require "asciichem/engine/parsanol_engine"
-  #   AsciiChem::Engine.use(:parsanol)
-  #   AsciiChem.parse("H_2O")   # parsed by the Rust core
-  #
-  # The active engine may also be selected via ASCIICHEM_ENGINE
-  # (a testing seam, mirroring ASCIICHEM_CORPUS):
-  #
-  #   ASCIICHEM_ENGINE=parsanol bundle exec rspec
-  #
+  # The parse engine: the PARG artifact engine, period (TODO.v2/17
+  # slice 9; the maintainer's PARG-only directive). The legacy
+  # parslet and DSL-parsanol engines are deleted — the checksummed
+  # AsciiChem PARG artifact (vendored at engine/parg/asciichem.json,
+  # sourced from asciichem-parg) is the one grammar, and
+  # PargEngine adapts its tree to the DSL shapes TransformRules
+  # consumes.
   module Engine
     class Error < AsciiChem::Error; end
 
-    # The named engine exists but its gem is not installed.
+    # The engine is the PARG runtime; its gem must be installed.
     class NotAvailableError < Error; end
 
-    autoload :ParsletEngine, 'asciichem/engine/parslet_engine'
-    autoload :ParsanolEngine, 'asciichem/engine/parsanol_engine'
     autoload :PargEngine, 'asciichem/engine/parg_engine'
-
-    class << self
-      # Selects the engine by name. Returns the engine class.
-      def use(name)
-        @current = engine_for(name)
-      end
-
-      # The active engine. Defaults to :parslet, overridable once via
-      # ASCIICHEM_ENGINE at first use.
-      def current
-        @current ||= engine_for(ENV.fetch('ASCIICHEM_ENGINE', 'parslet'))
-      end
-
-      private
-
-      def engine_for(name)
-        case name.to_s
-        when 'parslet' then ParsletEngine
-        when 'parsanol' then ParsanolEngine
-        when 'parg' then PargEngine
-        else
-          raise Error, "unknown engine #{name.inspect} (available: parslet, parsanol, parg)"
-        end
-      end
-    end
   end
 end

data/lib/asciichem/grammar_rules.rb

@@ -3,7 +3,7 @@
 module AsciiChem
   # The grammar's rules, backend-neutral: included by Grammar
   # (parslet, the reference engine) and by
-  # Engine::ParsanolEngine::Grammar (Rust core) when that opt-in
+  # the PARG engine (the one engine, per TODO.v2/17 slice 9)
   # engine is active. The DSL (str, match, any, .repeat, .maybe,
   # .absent?, >>, .as) is identical across backends.
   module GrammarRules
@@ -164,7 +164,7 @@ module AsciiChem
         rule(:reaction_cascade) do
           # The repeat is wrapped in a single :segment capture so every
           # engine arrays it (parsanol merges — and overwrites — bare
-          # repeated sibling captures; see Engine::ParsanolEngine).
+          # repeated sibling captures; see the PARG engine).
           (reaction.as(:first) >>
             (arrow.as(:arrow) >> spaces? >> terms.as(:products)).repeat(1).as(:segments)).as(:cascade)
         end

data/lib/asciichem/parser.rb

@@ -8,12 +8,12 @@ module AsciiChem
       @text = text.to_s
     end
 
-    # Grammar and Transform instances are stateless and expensive to
-    # construct; each engine memoizes them at the class level so
-    # repeated parses avoid the overhead (benchmark: ~15% throughput
-    # improvement).
+    # The parse goes through the PARG engine (the leptris-family
+    # discipline applies to parsing too: ONE engine, the PARG
+    # artifact). Its grammar/transform instances are memoized at the
+    # class level.
     def parse
-      engine = AsciiChem::Engine.current
+      engine = AsciiChem::Engine::PargEngine
       tree = engine.grammar_instance.parse(text)
       engine.transform_instance.apply(tree)
     rescue engine.parse_failed => e

data/lib/asciichem/resolver/adapter.rb

@@ -41,7 +41,11 @@ module AsciiChem
 
       # Cache-aware resolution. `fetch` must answer #get(url) -> body
       # String (NetFetch by default; specs inject recorded responses).
-      def resolve(value:, convention:, fetch: nil, cache: nil, refresh: false)
+      # `now` pins the retrieval clock (an ISO-8601 UTC string) for
+      # recorded-fixture runs — the shared corpus pins `retrievedAt`
+      # so replayed records compare byte-stably; nil means the wall
+      # clock.
+      def resolve(value:, convention:, fetch: nil, cache: nil, refresh: false, now: nil)
         cache ||= Cache.default
         fetch ||= NetFetch.new
         key = cache.key_for(self.class.source_name, convention, value)
@@ -51,22 +55,22 @@ module AsciiChem
           return cached if cached
         end
 
-        substance = fetch_record(value: value, convention: convention, fetch: fetch)
-          .tap { |s| s&.identifiers&.each { |i| i.provenance ||= default_provenance } }
+        substance = fetch_record(value: value, convention: convention, fetch: fetch, now: now)
+          .tap { |s| s&.identifiers&.each { |i| i.provenance ||= default_provenance(now) } }
         cache.write(key, substance) if substance
         substance
       end
 
       # Not-found is nil, not an error — sources legitimately answer
       # "unknown substance" during multi-source resolution.
-      def fetch_record(**)
+      def fetch_record(value:, convention:, fetch:, now: nil)
         raise NotImplementedError
       end
 
-      def default_provenance
+      def default_provenance(now: nil)
         Provenance.new(
           source: self.class.source_name,
-          retrieved_at: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+          retrieved_at: now || Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
           attribution: attribution
         )
       end

data/lib/asciichem/resolver/common_chemistry.rb

@@ -43,7 +43,7 @@ module AsciiChem
         @api_key = api_key
       end
 
-      def fetch_record(value:, convention:, fetch:)
+      def fetch_record(value:, convention:, fetch:, now: nil)
         headers = {
           "Accept" => "application/json",
           "x-origin" => ORIGIN
@@ -55,7 +55,7 @@ module AsciiChem
         data = JSON.parse(body)
         return nil if data.empty?
 
-        substance_from(data)
+        substance_from(data, now)
       rescue JSON::ParserError => e
         raise Error, "common_chemistry returned malformed JSON: #{e.message}"
       end
@@ -71,8 +71,8 @@ module AsciiChem
           (File.read(KEY_FILE).strip if File.readable?(KEY_FILE))
       end
 
-      def substance_from(data)
-        provenance = default_provenance
+      def substance_from(data, now)
+        provenance = default_provenance(now: now)
         identifiers = [Identifier.new(value: data["rn"], convention: "cas",
                                       provenance: provenance)]
         add_identifier(identifiers, data, "inchikey", "inchikey", provenance)

data/lib/asciichem/resolver/opsin.rb

@@ -27,11 +27,11 @@ module AsciiChem
       BASE = 'https://opsin.ch.cam.ac.uk/opsin'
       private_constant :BASE
 
-      def fetch_record(value:, convention: nil, fetch:)
+      def fetch_record(value:, convention: nil, fetch:, now: nil)
         body = fetch.get("#{BASE}/#{CGI.escape(value.to_s)}.smiles")
         return nil unless body
 
-        substance_from(body.strip)
+        substance_from(body.strip, now)
       rescue StandardError => e
         raise Error, "opsin request failed: #{e.message}"
       end
@@ -42,10 +42,10 @@ module AsciiChem
 
       private
 
-      def substance_from(smiles)
+      def substance_from(smiles, now)
         return nil if smiles.empty?
 
-        provenance = default_provenance
+        provenance = default_provenance(now: now)
         Substance.new(
           preferred_name: nil,
           identifiers: [Identifier.new(value: smiles, convention: 'canonical-smiles',

data/lib/asciichem/resolver/pubchem.rb

@@ -26,14 +26,14 @@ module AsciiChem
                       MolecularWeight IUPACName InChI InChIKey].freeze
       private_constant :BASE, :PROPERTIES
 
-      def fetch_record(value:, convention:, fetch:)
+      def fetch_record(value:, convention:, fetch:, now: nil)
         body = fetch.get(url_for(value, convention))
         return nil unless body
 
         props = JSON.parse(body).dig("PropertyTable", "Properties", 0)
         return nil unless props
 
-        substance_from(props)
+        substance_from(props, now)
       rescue JSON::ParserError => e
         raise Error, "pubchem returned malformed JSON: #{e.message}"
       end
@@ -53,8 +53,8 @@ module AsciiChem
         "#{BASE}/#{namespace}/#{CGI.escape(value.to_s)}/property/#{PROPERTIES.join(',')}/JSON"
       end
 
-      def substance_from(props)
-        provenance = default_provenance
+      def substance_from(props, now)
+        provenance = default_provenance(now: now)
         identifiers = []
         identifiers << Identifier.new(value: props["CID"].to_s, convention: "pubchem-cid", provenance: provenance) if props["CID"]
         add_identifier(identifiers, props, "InChIKey", "inchikey", provenance)

data/lib/asciichem/resolver.rb

@@ -48,15 +48,16 @@ module AsciiChem
       # entries dropped). Sources answer in registration order. A
       # source-level failure (HTTP error, rejected request) skips that
       # source — one dead or key-gated endpoint must not poison the
-      # others; callers see what answered.
-      def resolve_all(value:, convention:, sources: nil, fetch: nil, cache: nil, refresh: false)
+      # others; callers see what answered. `now` pins the retrieval
+      # clock for recorded-fixture runs (the adapters' seam).
+      def resolve_all(value:, convention:, sources: nil, fetch: nil, cache: nil, refresh: false, now: nil)
         selected = sources ? Array(sources).map { |s| self[s] } : adapters.values
         selected.filter_map do |adapter_class|
           adapter = adapter_class.new
           next unless adapter.supports?(convention)
 
           begin
-            adapter.resolve(value: value, convention: convention, fetch: fetch, cache: cache, refresh: refresh)
+            adapter.resolve(value: value, convention: convention, fetch: fetch, cache: cache, refresh: refresh, now: now)
           rescue AsciiChem::Error
             nil
           end

data/lib/asciichem/transform_rules.rb

@@ -2,7 +2,7 @@
 
 module AsciiChem
   # The transform's rules, backend-neutral: included by Transform
-  # (parslet) and by Engine::ParsanolEngine::Transform when that
+  # and by the PARG engine's Transform (the one engine,
   # opt-in engine is active. String class_eval so the nested builder
   # classes land as constants of the including class, unchanged.
   module TransformRules

data/lib/asciichem/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AsciiChem
-  VERSION = "0.31.15"
+  VERSION = "0.31.17"
 end

data/lib/asciichem.rb

@@ -39,7 +39,6 @@ module AsciiChem
   autoload :Rxn, "asciichem/rxn"
   autoload :Smiles, "asciichem/smiles"
   autoload :Structure, "asciichem/structure"
-  autoload :Transform, "asciichem/transform"
   autoload :TransformRules, "asciichem/transform_rules"
   autoload :VERSION, "asciichem/version"
   autoload :Wire, "asciichem/wire"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciichem
 version: !ruby/object:Gem::Version
-  version: 0.31.15
+  version: 0.31.17
 platform: ruby
 authors:
 - Ribose Inc.
@@ -80,19 +80,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.6.1
 - !ruby/object:Gem::Dependency
-  name: parslet
+  name: parsanol
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.107
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.107
 - !ruby/object:Gem::Dependency
   name: relaton-bib
   requirement: !ruby/object:Gem::Requirement
@@ -196,8 +202,6 @@ files:
 - lib/asciichem/engine.rb
 - lib/asciichem/engine/parg/asciichem.json
 - lib/asciichem/engine/parg_engine.rb
-- lib/asciichem/engine/parsanol_engine.rb
-- lib/asciichem/engine/parslet_engine.rb
 - lib/asciichem/errors.rb
 - lib/asciichem/formatter.rb
 - lib/asciichem/formatter/base.rb
@@ -207,7 +211,6 @@ files:
 - lib/asciichem/formatter/structural_svg.rb
 - lib/asciichem/formatter/svg.rb
 - lib/asciichem/formatter/text.rb
-- lib/asciichem/grammar.rb
 - lib/asciichem/grammar_rules.rb
 - lib/asciichem/greek.rb
 - lib/asciichem/identifiers.rb
@@ -289,7 +292,6 @@ files:
 - lib/asciichem/structure.rb
 - lib/asciichem/structure/graph.rb
 - lib/asciichem/structure/linearizer.rb
-- lib/asciichem/transform.rb
 - lib/asciichem/transform_rules.rb
 - lib/asciichem/version.rb
 - lib/asciichem/wire.rb

data/lib/asciichem/engine/parsanol_engine.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-# Opt-in soft dependency: fail with guidance, never silently.
-begin
-  require 'parsanol/parslet'
-  # parsanol-ruby 1.3.16's native.rb references
-  # Parsanol::Native::Dynamic from the serializer without loading it
-  # (parsanol-ruby#25).
-  require 'parsanol/native/dynamic'
-rescue LoadError => e
-  raise AsciiChem::Engine::NotAvailableError,
-        'the parsanol engine requires the parsanol gem — add gem "parsanol", "~> 1.3.16" ' \
-        "to your Gemfile (#{e.message})"
-end
-
-module AsciiChem
-  module Engine
-    # The Parsanol engine: the SAME rules (GrammarRules /
-    # TransformRules) over Parsanol's Rust-backed parslet-compat
-    # layer. Corpus-identical to :parslet (221/221 byte-for-byte,
-    # benchmarks/parsanol_recheck.rb) at ~3x parse speed.
-    class ParsanolEngine
-      # Backend twins of the reference classes; the shared rules
-      # modules are the single source of grammar truth.
-      class Grammar < ::Parsanol::Parslet::Parser
-        include AsciiChem::GrammarRules
-      end
-
-      # Transform twin; #apply normalizes the engine's merged sibling
-      # captures before the shared rules run (see split_merged_formula).
-      class Transform < ::Parsanol::Parslet::Transform
-        include AsciiChem::TransformRules
-
-        # Engine divergence seam: parslet yields repeated sibling
-        # node captures as an array of single-key hashes; parsanol
-        # merges them into one hash, which no rule can match. Split
-        # the merged form back before the shared rules run, so the
-        # rules stay engine-agnostic (single source of truth).
-        def apply(tree, context = nil)
-          super(ParsanolEngine.split_merged_formula(tree), context)
-        end
-      end
-
-      class << self
-        # NODE_STARTERS mirrors the grammar's `node` alternatives
-        # (grammar_rules.rb): the capture key each alternative
-        # produces FIRST. A new node group begins at each starter;
-        # continuation keys (arrow/products, coefficient/annotations,
-        # crystal_name/params/body, ...) attach to the current group.
-        NODE_STARTERS = %i[
-          cascade reactants electron_config crystal_node spectrum_node
-          calc_node zmatrix_node mechanism_node mol units math_source text_run
-        ].freeze
-
-        # Grammar truth: a molecule node is {coefficient? stereo? units}
-        # — coefficient/stereo may LEGITIMATELY precede :units in one
-        # node. They are prefixes, not new-node markers.
-        PREFIX_KEYS = %i[coefficient stereo].freeze
-
-        def split_merged_formula(node)
-          case node
-          when Hash
-            node.to_h { |key, value| [key, split_formula_value(key, value)] }
-          when Array
-            node.map { |member| split_merged_formula(member) }
-          else
-            node
-          end
-        end
-
-        def grammar
-          Grammar
-        end
-
-        def transform
-          Transform
-        end
-
-        def parse_failed
-          ::Parsanol::ParseFailed
-        end
-
-        def grammar_instance
-          @grammar_instance ||= grammar.new
-        end
-
-        def transform_instance
-          @transform_instance ||= transform.new
-        end
-
-        private
-
-        def split_formula_value(key, value)
-          if key == :formula && value.is_a?(Hash) && value.length > 1
-            groups = []
-            value.each do |k, v|
-              groups << {} if new_group?(groups, k)
-              groups.last[k] = split_merged_formula(v)
-            end
-            groups.length == 1 ? groups.first : groups
-          else
-            split_merged_formula(value)
-          end
-        end
-
-        def new_group?(groups, key)
-          return true if groups.empty?
-
-          return false unless NODE_STARTERS.include?(key)
-
-          # :units continues a group that so far holds only molecule
-          # prefixes ({coefficient:...} / {stereo:...}).
-          !(key == :units && groups.last.keys.all? { |pk| PREFIX_KEYS.include?(pk) })
-        end
-      end
-    end
-  end
-end

data/lib/asciichem/engine/parslet_engine.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module AsciiChem
-  module Engine
-    # The reference engine: pure-Ruby parslet. Zero extra
-    # dependencies; Grammar and Transform as always.
-    class ParsletEngine
-      class << self
-        def grammar
-          Grammar
-        end
-
-        def transform
-          Transform
-        end
-
-        def parse_failed
-          Parslet::ParseFailed
-        end
-
-        # Engines memoize their grammar/transform instances — they are
-        # stateless and expensive to construct (benchmark: ~15%
-        # throughput on repeated parses).
-        def grammar_instance
-          @grammar_instance ||= grammar.new
-        end
-
-        def transform_instance
-          @transform_instance ||= transform.new
-        end
-      end
-    end
-  end
-end

data/lib/asciichem/grammar.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'parslet'
-
-module AsciiChem
-  # Parslet grammar for AsciiChem v1.
-  #
-  # Design notes:
-  #
-  # - Leaf rules return strings; `.as(:name)` is applied at the
-  #   combination site so the parse tree is a flat hash of named strings
-  #   wherever practical.
-  # - The prefix-isotope binding (`^14C`) is enforced structurally: the
-  #   `prefixed_atom` production consumes `^digits element` as a unit.
-  #   A bare `^digits` without an element is rejected.
-  # - Marker rules (`subscript_marker`, `superscript_marker`) capture
-  #   ONLY the value, not the leading `_` or `^`. The literal prefix is
-  #   consumed by the rule but not included in the named capture.
-  class Grammar < Parslet::Parser
-    include GrammarRules
-  end
-end

data/lib/asciichem/transform.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'parslet'
-
-module AsciiChem
-  # Converts a parse tree (from AsciiChem::Grammar) into a tree of
-  # AsciiChem::Model instances.
-  #
-  # The transform contains minimal logic — it maps hash shapes to
-  # constructor calls. Anything semantically tricky (e.g. distinguishing
-  # isotope prefix from suffix charge) is encoded in the grammar, not
-  # here.
-  class Transform < Parslet::Transform
-    include TransformRules
-  end
-end