pubid 2.0.0 → 2.0.2

data/lib/pubid/nist/router.rb

@@ -104,7 +104,10 @@ module Pubid
 
         # Check for CS variants (works for both compound "NBS CS" and simple "CS")
         if series == "CS"
-          first_num = parsed_hash[:first_number]
+          # The composite branch of the split first_number wrapper (the
+          # grammar's v#n# branch) arrives under :first_number_composite.
+          first_num = parsed_hash[:first_number] ||
+                      parsed_hash[:first_number_composite]
 
           # Check for CSM (monthly) - v#n# pattern inside first_number hash
           if first_num.is_a?(Hash) && first_num[:volume_number] && first_num[:issue_number]

data/lib/pubid/nist/supplement_identifier.rb

@@ -30,12 +30,12 @@ module Pubid
       # and `to_s` wraps its single result. `super` is not reachable from a
       # private method, so it is handed in as a block.
       def to_s(format = :short)
-        annotated = format.is_a?(Hash) ? format[:annotated] : nil
+        flags = plain_render_flags(format)
         format = format[:format] || :short if format.is_a?(Hash)
 
         rendered = render_plain(format) { super(format) }
 
-        annotate_plain_render(rendered, annotated: annotated)
+        annotate_plain_render(rendered, **flags)
       end
 
       private

data/lib/pubid/oasis/identifier.rb

@@ -146,7 +146,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:oasis, identifier)
+        parsed = Pubid::Parg::Model.bound(:oasis, identifier)
         Builder.build(parsed)
       end
 

data/lib/pubid/oasis/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Oasis
-    # Parslet grammar for printed OASIS identifiers, e.g.
+    # Grammar for printed OASIS identifiers, e.g.
     #   "OASIS OSLC-CoreShapes-3.0-PS01-Pt8"
     #   "OASIS amqp-core"
     #
@@ -16,19 +14,7 @@ module Pubid
     # Builder with order-independent fragment classification. Keeping
     # decomposition out of the PEG avoids brittle backtracking and guarantees a
     # lossless round-trip.
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:prefix) { str("OASIS") >> str(" ") }
-
-      # The whole slug, captured verbatim (any character, incl. spaces / "]").
-      rule(:slug) { any.repeat(1).as(:original) }
-
-      rule(:identifier) { prefix >> slug }
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/ogc/identifier.rb

@@ -85,7 +85,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        Builder.build(Pubid::Parg::Backend.parse(:ogc, identifier))
+        Builder.build(Pubid::Parg::Model.bound(:ogc, identifier))
       end
     end
   end

data/lib/pubid/ogc/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Ogc
-    # Parslet grammar for OGC identifiers.
+    # Grammar for OGC identifiers.
     #
     # Recognizes `<yy>-<nnn>` optionally followed by a revision suffix that
     # begins with a letter (r/c/a/R…) and may carry a trailing letter
@@ -12,29 +10,7 @@ module Pubid
     # leniency, though the canonical printed form omits it.
     #
     # Examples: "25-023", "24-032r1", "01-009a", "04-095c1", "OGC 24-032r1".
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space) { match["\\s"].repeat(1) }
-      rule(:digits) { match["0-9"].repeat(1) }
-
-      # Optional leading publisher token, e.g. "OGC " — consumed, not captured.
-      rule(:publisher) { (str("OGC") >> space).maybe }
-
-      # Revision suffix: a run of letters/digits that starts after the numeric
-      # part (which greedily consumes all digits, so the suffix begins with a
-      # separator letter). Kept as a single token for the builder to normalize.
-      rule(:revision) { match["A-Za-z0-9"].repeat(1).as(:revision) }
-
-      rule(:identifier) do
-        publisher >>
-          digits.as(:year) >> str("-") >> digits.as(:number) >>
-          revision.maybe >> space.maybe
-      end
-
-      root(:identifier)
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/oiml/identifiers/certification_system.rb

@@ -28,6 +28,13 @@ module Pubid
         def type_string
           "CS"
         end
+
+        # `OIML-CS` names the OIML Certification System as one unit, so
+        # `with_publisher: false` drops it whole (`PD-05 Edition 6`) and never
+        # leaves a bare `CS`.
+        def publisher_prefixes
+          ["#{publisher}-#{type_string}", "#{publisher} #{type_string}"]
+        end
       end
     end
   end

data/lib/pubid/oiml/identifiers/dual_published.rb

@@ -127,7 +127,7 @@ module Pubid
         # which starts with an OIML prefix), parses each side through its
         # own flavor and returns the wrapper. Returns nil for anything else,
         # so the caller (Pubid::Oiml.parse) falls through to the ordinary
-        # grammar, which raises the standard Parslet::ParseFailed for a
+        # grammar, which raises the standard Pubid::Errors::ParseError for a
         # string containing "|" (the grammar defines no rule for it).
         def self.build(identifier)
           sides = split_sides(identifier)
@@ -164,7 +164,7 @@ module Pubid
 
         def self.parse_side(str, oiml:)
           oiml ? Oiml.parse(str) : ::Pubid.parse(str)
-        rescue Parslet::ParseFailed, Pubid::Errors::InvalidInputError
+        rescue Pubid::Errors::ParseError, Pubid::Errors::InvalidInputError
           nil
         end
         private_class_method :parse_side

data/lib/pubid/oiml/parser.rb

@@ -1,310 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Oiml
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-      include ::Pubid::Parser::CommonParseMethods
-
-      root :identifier
-
-      # Additional basic rules not in CommonParseRules
-      rule(:colon) { str(":") }
-      rule(:lparen) { str("(") }
-      rule(:rparen) { str(")") }
-      rule(:slash) { str("/") }
-
-      # Main identifier pattern - check supplements first
-      rule(:identifier) do
-        amendment_identifier | amendment_short | annex_letter_identifier |
-          annex_identifier | plus_supplement_identifier |
-          trailing_supplement_identifier | cs_identifier |
-          bulletin_identifier | base
-      end
-
-      # Publisher - always "OIML"
-      rule(:publisher) { str("OIML").as(:publisher) >> space }
-
-      # Document type - single letter. Strict family set: OIML publishes
-      # R D B G E V S documents (the estate grammar's family letters);
-      # any other letter is a rejection, not a flavor.
-      rule(:doc_type) { match("[BDEGRSV]").as(:type) >> space }
-
-      # Bulletin locator — structured form. Year optionally followed by
-      # 2-digit issue and 2-digit sequence:
-      #   "OIML Bulletin", "OIML Bulletin 1960",
-      #   "OIML Bulletin 1960-03", "OIML Bulletin 1960-03-01"
-      # All four shapes appear as primary docids in relaton-data-oiml.
-      rule(:bulletin_date) do
-        space >> year_digits.as(:year) >>
-          (dash >> two_digits.as(:issue)).maybe >>
-          (dash >> two_digits.as(:sequence)).maybe
-      end
-
-      # Two-digit zero-padded number (used for issue / sequence).
-      rule(:two_digits) { match('\d').repeat(2, 2) }
-
-      # Roman numeral token composed of I,V,X,L,C,D,M (uppercase, matching
-      # OIML's print convention). Captured so the builder can cross-check
-      # the declared volume against the year implied by the article_id.
-      rule(:roman_numeral) { match("[IVXLCDM]").repeat(1).as(:volume_roman) }
-
-      # Bulletin locator — citation form. The format OIML prints on the
-      # article page is: "LXVII(2) 20260211" where LXVII is the volume in
-      # roman numerals, (2) is the issue in arabic without zero padding,
-      # and 20260211 is the 8-digit oiml.org article id (YYYYNNSS).
-      rule(:bulletin_citation) do
-        space >> roman_numeral >>
-          lparen >> digits.as(:issue_arabic) >> rparen >>
-          space >> match('\d').repeat(8, 8).as(:article_id)
-      end
-
-      # Bulletin identifier — no code; the locator (when present) is the
-      # (year, issue, sequence) tuple drawn from either the structured
-      # YYYY-II-SS form or the citation VOLUME(ISSUE) ARTID form. Both
-      # decode to the same record. Tried before base because
-      # "Bulletin" is a word that the single-letter doc_type rule cannot
-      # match.
-      rule(:bulletin_identifier) do
-        publisher >> str("Bulletin").as(:type) >>
-          (bulletin_citation | bulletin_date).maybe >>
-          language_portion.maybe.as(:language)
-      end
-
-      # Number with optional part and subpart
-      rule(:number_only) { digits.as(:number) }
-
-      # Part number, optionally a slashed multi-part continuation captured
-      # verbatim, e.g. "1/-2" in "OIML R 46-1/-2:2012".
-      rule(:part_number) do
-        dash >> (digits >> (slash >> dash >> digits).repeat).as(:part)
-      end
-
-      rule(:subpart_number) { dash >> digits.as(:subpart) }
-
-      # Free-form named/lettered code suffix glued after the numeric part:
-      #   -GUM 1, -special, -sup, -erratum, -A, -ISO3930, -Amend, -Amended_2012
-      # plus the space-separated "Brochure" label. "GUM <n>" is tried first so
-      # its trailing number isn't lost to the bare-word alternative. The
-      # trailing `(_?digits)*` captures joint codes ("ISO3930") and the
-      # "Amended_2012" amendment label (the hand-off treats these as part
-      # suffixes, preserved verbatim for round-trip).
-      rule(:named_suffix) do
-        (dash >> (
-          (str("GUM") >> space >> digits) |
-          (match("[A-Za-z]").repeat(1) >> (str("_").maybe >> digits).repeat)
-        ).as(:code_suffix)) |
-          (space >> str("Brochure").as(:code_suffix) >> str("").as(:space_suffix))
-      end
-
-      rule(:full_number) do
-        (number_only >> part_number >> subpart_number >> named_suffix.maybe) |
-          (number_only >> part_number >> named_suffix.maybe) |
-          (number_only >> named_suffix.maybe)
-      end
-
-      # Edition number - ordinal numbers
-      rule(:edition_number) do
-        (
-          str("6th") | str("5th") | str("4th") | str("3rd") |
-          str("2nd") | str("1st") |
-          (digits >> (str("th") | str("nd") | str("rd") | str("st")))
-        ).as(:edition)
-      end
-
-      # Edition text - uppercase or lowercase
-      rule(:edition_text) { str("Edition") | str("edition") }
-
-      # Edition portion - handles "6th Edition 2015" or "Edition 2013" or ", edition 1992"
-      rule(:edition_portion) do
-        (
-          (str(", ") | space) >>
-          edition_number.maybe >> space.maybe >> edition_text >> space.maybe >> year_digits.as(:year)
-        ).as(:edition_format) # Wrap entire match to capture that Edition was used
-      end
-
-      # Date - year after colon, the VIM's paren-year form ("OIML V 2-200
-      # (2000)" — space + (YYYY) instead of :YYYY, the shape #342 flags as
-      # the one real-world spelling that did not parse), OR edition portion
-      # (with optional space before year)
-      rule(:date) do
-        edition_portion |
-          (space.maybe >> colon >> space.maybe >> year_digits.as(:year)) |
-          (space.maybe >> lparen >> year_digits.as(:year) >> rparen)
-      end
-
-      # Draft stage - WD or CD with optional iteration
-      rule(:stage_iteration) do
-        (
-          (digits >> str(".") >> digits) | # 3.1
-          digits # 1, 2, 3
-        ).as(:iteration)
-      end
-
-      rule(:stage_abbr) do
-        (str("WD") | str("CD")).as(:stage)
-      end
-
-      rule(:draft_stage) do
-        space >> stage_iteration.maybe >> stage_abbr
-      end
-
-      # Language codes
-      #
-      # relaton-data-oiml encodes the publication language with its own code
-      # set (lib/oiml_fetcher.rb DOCID_LANG_CODE): single uppercase letters
-      # E F D R S C A U X, plus two-letter PO/PT/PE/SR. The two-letter OIML
-      # codes must be tried before the single-letter rule so e.g. "PE" isn't
-      # left with a dangling "E".
-      rule(:lang_single) do
-        match("[EFRXDSCAU]")
-      end
-
-      rule(:lang_multi_oiml) do
-        str("PO") | str("PT") | str("PE") | str("SR")
-      end
-
-      rule(:lang_multi) do
-        match("[a-z]").repeat(2, 2) # Two letters: en, fr, etc.
-      end
-
-      # Full-word language markers as OIML prints them ("(Fra)", "(Eng)"),
-      # three or more letters, any case. Kept verbatim on the identifier;
-      # the URN lowercases.
-      rule(:lang_word) do
-        match("[A-Za-z]").repeat(3)
-      end
-
-      rule(:language_code) do
-        (
-          (lang_single >> slash >> lang_single) | # E/F
-          lang_multi_oiml |                        # PO, PT, PE, SR
-          lang_word |                              # Fra, eng, rus — before
-                                                   # the letter rules: a
-                                                   # committed "F" of "(Fra)"
-                                                   # or "fr" of "(fra)" would
-                                                   # never fall through
-          lang_single |                            # E, F, D, R, S, C, A, U, X
-          lang_multi                               # en, fr
-        ).as(:language)
-      end
-
-      rule(:language_with_space) do
-        space >> lparen >> language_code >> rparen >> str("").as(:space_before_lang)
-      end
-
-      rule(:language_without_space) do
-        lparen >> language_code >> rparen
-      end
-
-      rule(:language_portion) do
-        language_with_space | language_without_space
-      end
-
-      # Amendment identifier - "Amendment (YYYY) to BASE"
-      rule(:amendment_identifier) do
-        str("Amendment") >> space >> lparen >> year_digits.as(:year) >> rparen >>
-          space >> str("to") >> space >>
-          base_without_language.as(:base) >>
-          language_portion.maybe.as(:language)
-      end
-
-      # Short amendment forms - "OIML TYPE NUMBER Amendment Edition YYYY" or "Amendment: YYYY"
-      rule(:amendment_short) do
-        publisher >>
-          doc_type >>
-          full_number.as(:base_code) >>
-          space >> str("Amendment").as(:amd_marker) >>
-          (
-            (space >> edition_text >> space.maybe >> year_digits.as(:year)).as(:edition_format) |
-            (colon >> space.maybe >> year_digits.as(:year))
-          ) >>
-          language_portion.maybe.as(:language)
-      end
-
-      # Trailing supplement word - "BASE Amendment" / "BASE Errata" where the
-      # publication year stays on the base (e.g. "OIML R 138:2009 Amendment").
-      # amendment_short is tried first; it only matches when a year follows the
-      # word, so the no-year trailing form falls through to here.
-      rule(:trailing_supplement_identifier) do
-        base_without_language.as(:base) >>
-          space >> (str("Amendment") | str("Errata")).as(:trailing_marker) >>
-          (space >> digits.as(:number)).maybe >>
-          language_portion.maybe.as(:language)
-      end
-
-      # OIML-CS certification-system documents. Two head spellings
-      # ("OIML-CS" / "OIML CS") and two family-number separators
-      # ("PD-05" / "PD 05"), an "Edition N" instead of a year, and an
-      # optional parenthesized trailing amendment - "(Amendment 1)".
-      rule(:cs_identifier) do
-        str("OIML").as(:publisher) >>
-          (dash >> str("CS") | space >> str("CS")).as(:cs_series) >> space >>
-          (str("PD") | str("OD") | str("CID")).as(:cs_family) >>
-          (dash | space).as(:cs_separator) >>
-          digits.as(:number) >>
-          space >> str("Edition") >> space >> digits.as(:edition) >>
-          (space >> lparen >> str("Amendment") >> space >>
-            digits.as(:cs_amendment) >> rparen).maybe
-      end
-
-      # Plus-joined supplement - "BASE:YEAR+Supplement:YEAR" form where both
-      # the base and the supplement carry their own year. Used for amendments
-      # and errata to dated bases (e.g. "OIML B 10:2011+Amendment:2012").
-      # Annexes already encode the year-on-base intent via their own model.
-      rule(:plus_supplement_identifier) do
-        base_without_language.as(:base) >>
-          str("+") >>
-          (str("Amendment") | str("Errata")).as(:plus_marker) >>
-          (colon >> year_digits.as(:year)).maybe >>
-          language_portion.maybe.as(:language)
-      end
-
-      # Annex identifier - "BASE Annexes Edition YYYY" / "BASE Annexes:YYYY" /
-      # "BASE:YYYY Annexes" (year on the base, no annex year).
-      rule(:annex_identifier) do
-        base_without_language.as(:base) >>
-          space >> str("Annexes").as(:annex_marker) >>
-          (
-            (space >> edition_text >> space >> year_digits.as(:year)).as(:edition_format) |
-            (colon >> year_digits.as(:year))
-          ).maybe >>
-          language_portion.maybe.as(:language)
-      end
-
-      # Annex letter or letter range, e.g. "A" or "B-C".
-      rule(:annex_letter_value) do
-        (match("[A-Z]") >> (dash >> match("[A-Z]")).maybe).as(:annex_letter)
-      end
-
-      # Annex with letter - "BASE Annex A Edition YYYY" / "BASE:YYYY Annex B-C"
-      rule(:annex_letter_identifier) do
-        base_without_language.as(:base) >>
-          space >> str("Annex") >> space >> annex_letter_value >>
-          ((space >> edition_text >> space >> year_digits.as(:year)) | (colon >> year_digits.as(:year))).maybe >>
-          language_portion.maybe.as(:language)
-      end
-
-      # Base identifier without language (for use in supplements)
-      rule(:base_without_language) do
-        publisher >>
-          doc_type >>
-          full_number >>
-          date.maybe >>
-          draft_stage.maybe
-      end
-
-      # Base identifier for recursion and standalone parsing
-      rule(:base) do
-        publisher >>
-          doc_type >>
-          full_number >>
-          date.maybe >>
-          draft_stage.maybe >>
-          language_portion.maybe
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/oiml.rb

@@ -34,10 +34,9 @@ module Pubid
         return dual if dual
       end
 
-      parser = Parser.new
       builder = Builder.new
 
-      parsed = Pubid::Parg::Backend.parse(:oiml, identifier)
+      parsed = Pubid::Parg::Model.bound(:oiml, identifier)
       builder.build(parsed)
     end
 

data/lib/pubid/omg/identifier.rb

@@ -43,6 +43,11 @@ module Pubid
         render(format: :human, **opts)
       end
 
+      # OMG keeps its publisher in the PUBLISHER constant, not the attribute.
+      def publisher_prefixes
+        [PUBLISHER]
+      end
+
       def self.parse(identifier)
         unless identifier.is_a?(String)
           raise Pubid::Errors::InvalidInputError,
@@ -53,7 +58,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:omg, identifier)
+        parsed = Pubid::Parg::Model.bound(:omg, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/omg/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Omg
-    # Parslet grammar for OMG specification identifiers.
+    # Grammar for OMG specification identifiers.
     #
     # Accepts:
     #   OMG {ACRONYM}[ {VERSION}][ {PART}]
@@ -15,79 +13,7 @@ module Pubid
     # "2.5.1", "5 beta 3", "2.5 beta".
     # PART is the volume or format segment, e.g. "Superstructure", "PDF". A
     # space or a slash separates it.
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space) { str(" ") }
-
-      # Acronym: the URL segment OMG gives the specification, kept verbatim,
-      # because a consumer builds the URL from it. It starts with a letter,
-      # which may be lower case ("smartant"). Letters, digits and "+" follow
-      # ("SysML", "AMI4CCM", "VSIPL++"). A hyphen or a slash joins further
-      # segments ("DDS-PSM-Cxx", "EDMC-FIBO/BE"). Each segment is non-empty,
-      # so a hyphen or a slash never ends the acronym.
-      #
-      # The slash in "EDMC-FIBO/BE" belongs to the acronym: OMG serves the
-      # document at /spec/EDMC-FIBO/BE/. A slash after the version separates
-      # the document part instead (see the identifier rule).
-      rule(:acronym_char) { match("[A-Za-z0-9+]") }
-
-      rule(:acronym) do
-        (match("[A-Za-z]") >> acronym_char.repeat >>
-          (match("[-/]") >> acronym_char.repeat(1)).repeat).as(:acronym)
-      end
-
-      # Version: digits with optional dots, optionally followed by " beta" and
-      # an optional beta number. OMG writes the label both ways: the document
-      # at /spec/UML/2.5/Beta1 gives its own version as "2.5 beta", and DDS 1.4
-      # supersedes /spec/DDS/1.4/Beta2.
-      #
-      # The beta number must stay optional here. The document part below would
-      # otherwise swallow a bare "beta" and report the version as "2.5" — a
-      # silent wrong answer, not a parse failure.
-      #
-      # Both halves of the beta label end at a word boundary. Parslet never
-      # backtracks into a `.maybe` that already succeeded, so an unanchored
-      # literal makes the version eat the front of a document part and then
-      # reject the whole identifier: "OMG DDS 1.4 beta2" and
-      # "OMG DDS 1.4 betawave" would raise instead of reading the part.
-      rule(:word_boundary) { match("[A-Za-z0-9]").absent? }
-
-      rule(:beta) do
-        str(" beta") >> word_boundary >>
-          (space >> match("[0-9]").repeat(1) >> word_boundary).maybe
-      end
-
-      rule(:version) do
-        (match("[0-9]").repeat(1) >>
-          (str(".") >> match("[0-9]").repeat(1)).repeat >>
-          beta.maybe).as(:version)
-      end
-
-      # After the version, OMG separates the document part with either a
-      # space or a slash. The renderer prints a space, so the two spellings of
-      # one document stay equal.
-      rule(:part_separator) { space | str("/") }
-
-      # Document part: the volume or format segment OMG puts after the
-      # version. UML 2.1.1 is two documents, Superstructure and
-      # Infrastructure, and the URL carries the same segment
-      # (/spec/UML/2.1.1/Superstructure). A format name (/spec/DDS/1.4/PDF)
-      # occupies the same position.
-      rule(:part) { match("[A-Za-z0-9]").repeat(1).as(:part) }
-
-      # Only a space separates a part that follows the acronym directly. The
-      # acronym rule takes a slash there, so a slash separator is legal only
-      # after a version.
-      rule(:identifier) do
-        str("OMG") >> space >> acronym >>
-          ((space >> version >> (part_separator >> part).maybe) |
-            (space >> part)).maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/parg/artifact.rb

@@ -21,13 +21,19 @@ module Pubid
         def for(flavor)
           @artifacts[flavor] ||=
             begin
-              path = File.join(DATA_DIR, "#{flavor}.json")
-              new(Parsanol::PARG::Artifact.load(path, tables_dir: TABLES_DIR))
+              new(Parsanol::PARG::Artifact.load(path_for(flavor),
+                                                tables_dir: TABLES_DIR))
             rescue Parsanol::PARG::Error => e
               raise Pubid::Errors::ParseError,
-                    "PG artifact #{path} rejected: #{e.message}"
+                    "PG artifact #{path_for(flavor)} rejected: #{e.message}"
             end
         end
+
+        # The vendored artifact's path. PG::Lutaml.register loads the file
+        # itself, so model registration needs the path, not the wrapper.
+        def path_for(flavor)
+          File.join(DATA_DIR, "#{flavor}.json")
+        end
       end
 
       def initialize(artifact)
@@ -38,6 +44,19 @@ module Pubid
         @artifact.parse(entry, input)
       end
 
+      # The artifact tree with the entry's declared bindings applied —
+      # the builder-ready attribute hash the grammar's bindings block
+      # declares, types cast at the engine.
+      def parse_and_bind(entry, input)
+        @artifact.parse_and_bind(entry, input)
+      end
+
+      # The bindings the grammar declared for +entry+, empty when it
+      # declares none.
+      def bindings(entry)
+        @artifact.envelope.dig("entries", entry, "bindings") || []
+      end
+
       def checksum
         @artifact.envelope["checksum"]
       end