gov_codes 0.1.0 → 0.1.2

data/lib/gov_codes/dafecd/publication.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module GovCodes
+  module Dafecd
+    # Per-publication configuration for the classification-directory extractor.
+    #
+    # The DAFECD (enlisted) and DAFOCD (officer) directories share the same
+    # extraction pipeline (RecordSplitter -> SpecialtyParser -> ShredoutParser ->
+    # IndexBuilder) but differ in a handful of concrete details: the running
+    # header, the shape of a skill/qualification ladder line, whether standalone
+    # single-code records and CEM lines exist, how the X-form specialty key is
+    # derived, and where the release artifact is written.
+    #
+    # A Publication is an immutable value object capturing exactly those
+    # differences. It is injected into every pipeline stage. The default
+    # everywhere is +Publication.dafecd+, so the enlisted extraction is
+    # byte-for-byte unchanged by the parameterization.
+    class Publication
+      # --- Enlisted (DAFECD) patterns ------------------------------------------
+      # Running page header, e.g. "DAFECD, 31 Oct 25".
+      DAFECD_HEADER = /^\s*DAFECD,\s+\d/
+
+      # Skill-ladder line (group 1 = concrete 5-char AFSC, group 2 = skill-level
+      # word). Tolerates the DAFECD's pdf-reader quirks (see Patterns::LADDER).
+      DAFECD_LADDER = /
+        ^\s*(?:AFSC\s+)?(\d[A-Z]\d\d\d)\*?
+        (?:\s+or\s+\d[A-Z0-9]+)?
+        ,?\s*
+        (?:[A-Za-z][A-Za-z\/]*\s+){0,3}
+        (Helper|Apprentice|Journeyman|Craftsman|
+         Superintendent|Senior\s+Enlisted(?:\s+Leader)?|Entry)
+        (?:\s*\([A-Z]{2,6}\))?
+        (?:\s*AFSC)?
+        \s*$
+      /x
+
+      # CEM (Chief Enlisted Manager) code line, e.g. "CEM Code 1A100*".
+      DAFECD_CEM = /^\s*CEM Code\s+(\d[A-Z]\d00)\*?/
+
+      # Inserts a boundary before an "AFSC <enlisted-code>" glued to a word.
+      DAFECD_GLUED_AFSC = /(?<=[A-Za-z])(?=AFSC \d[A-Z]\d\d\d)/
+
+      # The DAFECD's per-record change-date annotation.
+      DAFECD_CHANGE_DATE = /\((?:Changed|Established|Effective)\s+(\d{1,2}\s+\w{3,9}\s+\d{2,4})\)/
+
+      # The DAFECD shredout table header ("Suffix ... Primary Aircraft").
+      DAFECD_SHREDOUT_HEADER = /Suffix\s+\w/
+
+      # --- Officer (DAFOCD) patterns -------------------------------------------
+      # Running page header, e.g. "DAFOCD, 31 Oct 25".
+      DAFOCD_HEADER = /^\s*DAFOCD,\s+\d/
+
+      # Qualification-ladder line (group 1 = concrete 4-char AFSC, group 2 =
+      # free-form qualification title). The officer title vocabulary is open, so
+      # the anchor relies on the CODE SHAPE (exactly 4 chars: two digits, a
+      # letter, and a level digit 1-4) plus a SHORT title that ENDS the line AND
+      # STARTS WITH AN UPPERCASE LETTER. Every real DAFOCD qualification title is
+      # a proper label (Entry, Qualified, Aircraft Commander, Staff, ...), so the
+      # uppercase-initial requirement rejects wrapped source PROSE that happens to
+      # begin "AFSC <4-char-code>, <lowercase words>" (e.g. the real lines
+      # "AFSC 14F3, but applied to developing" and "AFSC 42G3, current and
+      # continuous"), which otherwise satisfied the code+short-title shape. It
+      # also still rejects the 5-char shred-code / long-sentence prose mentions.
+      # An optional leading/trailing "AFSC" absorbs the same pdf-reader glue the
+      # enlisted ladder handles (e.g. "11G4, StaffAFSC").
+      #
+      # The directory is INCONSISTENT about three things, all tolerated here:
+      #   * COMMA (group A): most cards print "AFSC 11B4, Staff", but several live
+      #     medical cards omit the comma and separate with a space ("AFSC 44B4
+      #     Staff", "AFSC 45A4* Staff"). Hence the separator is comma-or-space,
+      #     NOT a bare optional comma: requiring at least one of comma/whitespace
+      #     is what still rejects glued-shred prose such as "AFSC 42B3Z requires
+      #     successful completion of" and "AFSC 43E3Aand complete the education",
+      #     where an uppercase shred letter is glued to the code with no
+      #     separator before the lowercase prose. A bare ",?" would let those in.
+      #   * SHRED LETTER (group B): a few cards print the qualification code with
+      #     a glued shredout letter, e.g. "AFSC 17D4W*, Staff". The optional
+      #     "[A-Z]" absorbs it so it is NOT baked into the captured concrete code
+      #     (group 1 stays "17D4"); the letter is documented as a shredout via the
+      #     card's shredout table instead (see ShredoutParser).
+      #   * LEADING GLYPH: pdf-reader prepends a Private Use Area / bullet glyph
+      #     to some ladder lines (e.g. U+F0EA on the 17D card). The leading class
+      #     mirrors Patterns::DECORATIVE so the anchor tolerates it.
+      DAFOCD_LADDER = %r{
+        ^[\s\u{E000}-\u{F8FF}★☆•●▪■⁃∙]*(?:AFSC\s+)?(\d\d[A-Z][1-4])[A-Z]?\*?
+        (?:,\s*|\s+)
+        ([A-Z][A-Za-z/\ ]{0,44}?)
+        (?:\s*AFSC)?
+        \s*$
+      }x
+
+      # A standalone single-code officer record, e.g. "AFSC 10C0". These carry a
+      # title/date/sections but no ladder; each is a full record keyed by the
+      # literal code.
+      DAFOCD_BARE_CODE = /^\s*AFSC\s+(\d\d[A-Z][0-9X])\s*$/
+
+      # Inserts a boundary before an "AFSC <officer-code>" glued to a word.
+      DAFOCD_GLUED_AFSC = /(?<=[A-Za-z])(?=AFSC \d\d[A-Z][1-4])/
+
+      # The DAFOCD's per-record change-date annotation. Tolerant of the officer
+      # directory's glued day/month ("30Apr 23") and of a trailing second date
+      # ("30Apr 14, Effective 25 Oct 13"): the first annotation is captured.
+      DAFOCD_CHANGE_DATE = /\((?:Changed|Established|Effective)\s+(\d{1,2}\s*\w{3,9}\s+\d{2,4})/
+
+      # The DAFOCD shredout table header ("Suffix ... Portion of AFS to Which
+      # Related").
+      DAFOCD_SHREDOUT_HEADER = /Suffix\s+\w/
+
+      class << self
+        # @return [Publication] the enlisted directory configuration
+        def dafecd
+          @dafecd ||= new(
+            id: :dafecd,
+            directory_name: "Department of the Air Force Enlisted Classification Directory",
+            header: DAFECD_HEADER,
+            ladder: DAFECD_LADDER,
+            bare_code: nil,
+            cem: DAFECD_CEM,
+            glued_afsc: DAFECD_GLUED_AFSC,
+            change_date: DAFECD_CHANGE_DATE,
+            shredout_header: DAFECD_SHREDOUT_HEADER,
+            levels_key: :skill_levels,
+            code_has_specific: true,
+            captures_shredout_acronyms: false,
+            acronym_exclusions: %i[1D7X2 1A8X0],
+            release_dir: "dafecd",
+            index_filename: "enlisted.yml",
+            title_overrides_filename: "title_overrides.yml",
+            shredout_overrides_filename: "shredout_overrides/dafecd.yml"
+          )
+        end
+
+        # @return [Publication] the officer directory configuration
+        def dafocd
+          @dafocd ||= new(
+            id: :dafocd,
+            directory_name: "Department of the Air Force Officer Classification Directory",
+            header: DAFOCD_HEADER,
+            ladder: DAFOCD_LADDER,
+            bare_code: DAFOCD_BARE_CODE,
+            cem: nil,
+            glued_afsc: DAFOCD_GLUED_AFSC,
+            change_date: DAFOCD_CHANGE_DATE,
+            shredout_header: DAFOCD_SHREDOUT_HEADER,
+            levels_key: :qual_levels,
+            code_has_specific: false,
+            captures_shredout_acronyms: true,
+            acronym_exclusions: [],
+            release_dir: "dafocd",
+            index_filename: "officer.yml",
+            title_overrides_filename: "title_overrides/dafocd.yml",
+            shredout_overrides_filename: "shredout_overrides/dafocd.yml"
+          )
+        end
+
+        # Select the publication that matches +text+'s running header, defaulting
+        # to enlisted.
+        def detect(text)
+          [dafocd, dafecd].find { |pub| pub.header.match?(text) } || dafecd
+        end
+
+        # Look a publication up by its id symbol (:dafecd / :dafocd).
+        def for(id)
+          by_id = {dafecd: dafecd, dafocd: dafocd}
+          by_id.fetch(id.to_sym) do
+            raise ArgumentError,
+              "unknown publication #{id.inspect}; valid options are #{by_id.keys.map(&:inspect).join(", ")}"
+          end
+        end
+      end
+
+      attr_reader :id, :directory_name, :header, :ladder, :bare_code, :cem,
+        :glued_afsc, :change_date, :shredout_header, :levels_key,
+        :acronym_exclusions, :release_dir, :index_filename,
+        :title_overrides_filename, :shredout_overrides_filename
+
+      def initialize(id:, directory_name:, header:, ladder:, bare_code:, cem:,
+        glued_afsc:, change_date:, shredout_header:, levels_key:,
+        code_has_specific:, captures_shredout_acronyms:, acronym_exclusions:,
+        release_dir:, index_filename:, title_overrides_filename:,
+        shredout_overrides_filename:)
+        @id = id
+        @directory_name = directory_name
+        @header = header
+        @ladder = ladder
+        @bare_code = bare_code
+        @cem = cem
+        @glued_afsc = glued_afsc
+        @change_date = change_date
+        @shredout_header = shredout_header
+        @levels_key = levels_key
+        @code_has_specific = code_has_specific
+        @captures_shredout_acronyms = captures_shredout_acronyms
+        @acronym_exclusions = acronym_exclusions
+        @release_dir = release_dir
+        @index_filename = index_filename
+        @title_overrides_filename = title_overrides_filename
+        @shredout_overrides_filename = shredout_overrides_filename
+        freeze
+      end
+
+      # Whether this publication extracts shredout-level acronyms (officer).
+      def captures_shredout_acronyms?
+        @captures_shredout_acronyms
+      end
+
+      # The X-form specialty key for a ladder group's concrete codes.
+      #   enlisted: 1A172,1A152,... -> :1A1X2  (X at the level digit, specific kept)
+      #   officer:  11B4,11B3,...   -> :11BX    (X at the level digit, no specific)
+      # Returns nil when no codes are given.
+      def specialty_key(codes)
+        return nil if codes.empty?
+        basis = specialty_basis(codes)
+        prefix = basis.first[0, 3]
+        @code_has_specific ? :"#{prefix}X#{most_common_specific(basis)}" : :"#{prefix}X"
+      end
+
+      # The career-field key (first two chars of the basis code).
+      def career_field(codes)
+        return nil if codes.empty?
+        :"#{specialty_basis(codes).first[0, 2]}"
+      end
+
+      # The absolute path to this publication's title-overrides file.
+      def title_overrides_path
+        File.expand_path(@title_overrides_filename, __dir__)
+      end
+
+      # The absolute path to this publication's shredout-overrides file.
+      def shredout_overrides_path
+        File.expand_path(@shredout_overrides_filename, __dir__)
+      end
+
+      private
+
+      # The ladder codes that define the specialty. Enlisted: a subdivision
+      # superintendent (skill digit 9) carries a specific digit of 0, so the
+      # specialty is defined by its non-superintendent levels. Officer: all ladder
+      # codes share the same three-char family, so every code is basis.
+      def specialty_basis(codes)
+        return codes unless @code_has_specific
+        non_super = codes.reject { |code| code[3] == "9" }
+        non_super.empty? ? codes : non_super
+      end
+
+      # The most frequent specific (5th) digit among the basis codes (enlisted).
+      def most_common_specific(basis)
+        basis.map { |code| code[4] }.group_by(&:itself).max_by { |_, v| v.size }.first
+      end
+    end
+  end
+end

data/lib/gov_codes/dafecd/record_splitter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "patterns"
+require_relative "publication"
+require_relative "text"
+
+module GovCodes
+  # Dev-only tooling that parses an official Department of the Air Force
+  # classification directory (DAFECD enlisted / DAFOCD officer) PDF text into
+  # structured data.
+  #
+  # These classes are NEVER required by the gem runtime. They are used offline
+  # (via bin/extract_afsc_from_pdf.rb) to regenerate the versioned index when a
+  # new directory is released.
+  module Dafecd
+    # Splits the full directory text into one string per specialty record.
+    #
+    # A specialty record begins at either:
+    #   * a "CEM Code <code>" line (enlisted only), or
+    #   * a bare standalone "AFSC <code>" line (officer single-code records), or
+    #   * the first ladder line ("AFSC <code>, <title>") of a ladder group that
+    #     is NOT immediately preceded (ignoring blank lines) by another ladder
+    #     line, CEM line, or bare-code line.
+    #
+    # Running page headers ("DAFECD, <date>" / "DAFOCD, <date>") are stripped
+    # before splitting. Behavior is publication-specific (injected Publication);
+    # the default is the enlisted directory.
+    class RecordSplitter
+      # A lone title-case word on its own line (e.g. "Leader" left behind when
+      # Text.split_glued_afsc splits "LeaderAFSC 1A178"). Such wrapped
+      # continuations must not break a ladder group.
+      CONTINUATION_WORD = /\A[A-Z][a-z]+\z/
+
+      def initialize(text, publication: Publication.dafecd)
+        @publication = publication
+        @text = Text.split_glued_afsc(text, publication.glued_afsc)
+      end
+
+      # @return [Array<String>] one string per specialty record
+      def records
+        lines = @text.lines.reject { |line| line =~ @publication.header }
+
+        records = []
+        current = nil
+        prev_meaningful_was_anchor = false
+
+        lines.each do |line|
+          is_ladder = line =~ @publication.ladder
+          is_cem = @publication.cem && line =~ @publication.cem
+          is_bare = @publication.bare_code && line =~ @publication.bare_code
+          stripped = line.strip
+          # Blank lines and lone continuation words are neutral: they neither
+          # start a record nor break a run of ladder/CEM/bare lines.
+          neutral = stripped.empty? || stripped.match?(CONTINUATION_WORD)
+
+          starts_record =
+            is_cem ||
+            is_bare ||
+            (is_ladder && !prev_meaningful_was_anchor)
+
+          if starts_record
+            current = +""
+            records << current
+          end
+
+          current << line if current
+
+          unless neutral
+            prev_meaningful_was_anchor = !!(is_ladder || is_cem || is_bare)
+          end
+        end
+
+        records
+      end
+    end
+  end
+end

data/lib/gov_codes/dafecd/ri_sdi/change_date.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+
+module GovCodes
+  module Dafecd
+    module RiSdi
+      # Extracts the per-record change/effective date from an RI or SDI record's
+      # header region.
+      #
+      # The RI/SDI sections of the DAFECD/DAFOCD use noticeably messier date
+      # annotations than the AFSC ladder records the existing
+      # Publication#change_date patterns handle. Rather than loosen those shared
+      # patterns (which would risk perturbing the already-shipped enlisted/officer
+      # artifacts), this module owns a deliberately tolerant capture regex used
+      # only on the new content:
+      #
+      #   * a leading extra word before the date
+      #       "(Change Effective 31 Oct 18)", "(Established Effective 31 Oct 22)"
+      #   * a long leading clause ending in a lowercase "effective"
+      #       "(Change to description only effective 11 May 15)"
+      #   * a glued day/month  "(Established 30Apr 25)"
+      #   * a dual date; the FIRST is captured (matching the officer convention)
+      #       "(Changed 31 Oct 16, Effective 8 Feb 16)"  -> 2016-10-31
+      #   * a missing/misplaced open paren (pdf glue)
+      #       "Established 31 Oct 25   )"
+      #
+      # The captured substring is normalized to ISO 8601 by the shared
+      # Text.parse_date (which already tolerates the glued day/month). Returns nil
+      # when the given text carries no such annotation.
+      module ChangeDate
+        # A directory date: "31 Oct 25", "5 June 2013", the glued "30Apr 25", or
+        # the fully glued "30Apr20" (officer 81D0). The gap before BOTH the month
+        # and the year is optional to absorb pdf-reader's glue.
+        DATE = /\d{1,2}\s*[A-Za-z]{3,9}\s*\d{2,4}/
+
+        # A change-date annotation: a capitalized change keyword, then a lazy run
+        # of same-annotation filler (no newline, no close paren), then the first
+        # date. The lazy filler is what captures the FIRST date of a dual-date
+        # line and absorbs the "Effective"/"effective"/"to description only"
+        # bridging words.
+        ANNOTATION = /(?:Changed|Established|Effective|Change)\b[^)\n]*?(#{DATE})/
+
+        module_function
+
+        # @param text [String] the record's header region (or any text slice)
+        # @return [String, nil] the ISO 8601 change date, or nil when absent
+        def extract(text)
+          raw = text.to_s[ANNOTATION, 1]
+          raw && normalize(raw)
+        end
+
+        # Normalize an already-isolated raw date ("31 Oct 24", "30Apr20") to ISO
+        # 8601. Re-spaces any letter/digit glue so the shared date normalizer,
+        # which needs a gap before the year, can read it. Returns nil when the raw
+        # is not a date.
+        def normalize(raw)
+          Text.parse_date(raw.to_s.gsub(/([A-Za-z])(?=\d)/, '\1 ').gsub(/(\d)(?=[A-Za-z])/, '\1 '))
+        end
+      end
+    end
+  end
+end

data/lib/gov_codes/dafecd/ri_sdi/config.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "../patterns"
+
+module GovCodes
+  module Dafecd
+    module RiSdi
+      # Per-publication configuration for the RI/SDI extractor.
+      #
+      # The DAFECD (enlisted) and DAFOCD (officer) directories publish their
+      # Reporting Identifiers (RI) and Special Duty Identifiers (SDI) in the same
+      # two record formats (the SDI "card" and the flat numbered RI list). They
+      # differ only in the code SHAPE (enlisted codes are 5 chars, "8A200";
+      # officer codes are 4 chars, "80C0"), the running page header, and where the
+      # combined artifact is written. A Config captures exactly those differences
+      # and is injected into every stage.
+      class Config
+        # Enlisted RI/SDI code: a digit, a letter, three digits (8A200, 9Z200,
+        # 5I000, 5Z700). Space Force RI reuses the same shape.
+        ENLISTED_CODE = /\d[A-Z]\d{3}/
+
+        # Officer RI/SDI code: two digits, a letter, a level digit (80C0, 90G0).
+        # The trailing character is a DIGIT — never "X" — which is what rejects
+        # the academic CIP codes ("05XX", "14.10XX") that share the officer RI
+        # list's page real estate.
+        OFFICER_CODE = /\d\d[A-Z]\d/
+
+        DAFECD_HEADER = /^\s*DAFECD,\s+\d/
+        DAFOCD_HEADER = /^\s*DAFOCD,\s+\d/
+
+        # Both directories head the shredout table with "Suffix ... Portion of
+        # <AFS|RI> to Which Related"; the leading "Suffix <word>" is common to
+        # every variant, so the existing header regex matches them all.
+        SHREDOUT_HEADER = /Suffix\s+\w/
+
+        class << self
+          def dafecd
+            @dafecd ||= new(
+              id: :dafecd,
+              directory_name: "Department of the Air Force Enlisted Classification Directory",
+              code: ENLISTED_CODE,
+              header: DAFECD_HEADER,
+              release_dir: "dafecd",
+              # Trailing parentheticals that abbreviate an embedded organization
+              # or a sub-phrase — NOT the identifier's own name — and so must not
+              # ship as the record's acronym. See the acronym classification in
+              # the extractor report. (SWMS/AFSPECWAR/MEPCOM/etc. are mid-title or
+              # length-excluded and never captured, so they need no listing here.)
+              acronym_exclusions: %i[9B100 9H100 9M400],
+              # AF SDI -> AF RI -> (skip SFSC) -> SF SDI -> SF RI
+              sections: [
+                {kind: :sdi, force: :af, header: /^\s*SPECIALDUTY IDENTIFIERS \(SDI\)/},
+                {kind: :ri, force: :af, header: /^\s*AIR FORCE REPORTING IDENTIFIERS \(RI\)/},
+                {kind: :skip, force: :sf, header: /^\s*SPACE FORCE SPECIALTY CODES \(SFSC\)/},
+                {kind: :sdi, force: :sf, header: /^\s*SPACE FORCE SPECIAL ?DUTY IDENTIFIERS \(SDI\)/},
+                {kind: :ri, force: :sf, header: /^\s*SPACE FORCE REPORTING IDENTIFIERS \(RI\)/}
+              ]
+            )
+          end
+
+          def dafocd
+            @dafocd ||= new(
+              id: :dafocd,
+              directory_name: "Department of the Air Force Officer Classification Directory",
+              code: OFFICER_CODE,
+              header: DAFOCD_HEADER,
+              release_dir: "dafocd",
+              acronym_exclusions: [],
+              # Officer SDI -> Officer RI (no AF/SF split in the officer directory)
+              sections: [
+                {kind: :sdi, force: :officer, header: /^\s*SPECIAL ?DUTY IDENTIFIERS \(SDI\)/},
+                {kind: :ri, force: :officer, header: /^\s*REPORTING IDENTIFIERS \(RI\)/}
+              ]
+            )
+          end
+
+          def for(id)
+            by_id = {dafecd: dafecd, dafocd: dafocd}
+            by_id.fetch(id.to_sym) do
+              raise ArgumentError,
+                "unknown publication #{id.inspect}; valid options are #{by_id.keys.map(&:inspect).join(", ")}"
+            end
+          end
+        end
+
+        attr_reader :id, :directory_name, :code, :header, :shredout_header,
+          :release_dir, :sections, :index_filename, :acronym_exclusions,
+          :title_overrides_filename, :sdi_anchor, :sdi_inline_anchor, :ri_anchor, :cem
+
+        def initialize(id:, directory_name:, code:, header:, release_dir:, sections:, acronym_exclusions:)
+          @id = id
+          @directory_name = directory_name
+          @code = code
+          @header = header
+          @shredout_header = SHREDOUT_HEADER
+          @release_dir = release_dir
+          @sections = sections
+          @acronym_exclusions = acronym_exclusions
+          @index_filename = "ri.yml"
+          # Human-verified de-glued titles, one file per publication, gated at
+          # build time against the verbatim source (spacing/case only).
+          @title_overrides_filename = "title_overrides/#{id}.yml"
+          # A standalone SDI card anchor ("SDI 8A200") and an inline-title anchor
+          # ("SDI 8L100,AirAdvisor - Basic"); group 1 is the code, group 2 (inline
+          # only) the raw title text. The inline anchor's "SDI " keyword is
+          # OPTIONAL: the officer Air Advisor cards (89A0-89I0) print as a bare
+          # "CODE,Title" line with no prefix. False positives are still rejected
+          # downstream by Title.real? (the inline "title" must start with a
+          # capital/digit/paren, never a wrapped-prose lowercase continuation),
+          # and the "^" anchor keeps the code at line start so mid-line codes
+          # (e.g. "...10-4301V1, Air Advisor Training") never match.
+          @sdi_anchor = /^\s*SDI\s+(#{code})\*?\s*$/
+          @sdi_inline_anchor = /^\s*(?:SDI\s+)?(#{code})\*?,\s*(\S.*)$/
+          # A flat-list RI anchor: a top-level list number, an optional decorative
+          # star, then the code. Group 1 is the list number, group 2 the code,
+          # group 3 the remainder of the line (title, possibly with a trailing
+          # date). Tolerates a run of spaces or none after "<n>.", and a comma or
+          # a bare space before the title.
+          @ri_anchor =
+            /^[ \t]*(\d{1,2})\.[ \t]*(?:#{Patterns::DECORATIVE}[ \t]*)*(#{code})\s*,?\s*(.*)$/
+          # The one ladder record embedded in the enlisted AF SDI section
+          # ("CEM Code 8G000", Premier Honor Guard) is handled by the AFSC
+          # pipeline; the splitter uses this to isolate it from the cards.
+          @cem = Patterns::CEM
+          freeze
+        end
+
+        # The absolute path to this publication's RI/SDI title-overrides file.
+        # Mirrors Publication#title_overrides_path so the shared TitleDegluer
+        # (its .for/#override_for/.matches_source? API) loads from a Config too.
+        def title_overrides_path
+          File.expand_path(@title_overrides_filename, __dir__)
+        end
+      end
+    end
+  end
+end