ucode 0.2.1 → 0.2.3

data/lib/ucode/glyphs/embedded_fonts/catalog.rb

@@ -249,6 +249,7 @@ module Ucode
             font_obj_id: font_obj_id,
             tu_ref: tu_ref,
             cid_map_kind: cid_map_kind,
+            base_font: base_font,
           )
           return nil if cp_to_gid.empty?
 
@@ -275,14 +276,23 @@ module Ucode
         # when no /ToUnicode is present, consult the correlator_configs
         # registry — if the user supplied a config for this font, render
         # the relevant page(s) to SVG and run positional correlation.
-        # Returns an empty hash when neither path produces a map (the
-        # caller treats that as "skip this font").
-        def build_codepoint_to_gid(font_obj_id:, tu_ref:, cid_map_kind:)
+        # Pillar-2b fallback: when no caller-supplied config either,
+        # auto-detect via `mutool trace` — parse the structured text
+        # trace to build `{codepoint => gid}` from hex labels + specimen
+        # positions. Returns an empty hash when none of the paths
+        # produce a map (the caller treats that as "skip this font").
+        def build_codepoint_to_gid(font_obj_id:, tu_ref:, cid_map_kind:,
+                                   base_font: nil)
           return {} if cid_map_kind != :identity
 
           return codepoint_map_from_tounicode(tu_ref) if tu_ref
 
-          codepoint_map_from_correlator(font_obj_id)
+          map = codepoint_map_from_correlator(font_obj_id)
+          return map unless map.empty?
+
+          return {} unless base_font
+
+          codepoint_map_from_trace(base_font, font_obj_id)
         end
 
         def codepoint_map_from_tounicode(tu_ref)
@@ -298,6 +308,73 @@ module Ucode
           ContentStreamCorrelator.new(config).correlate(svg)
         end
 
+        # Pillar-2b: auto-detect codepoint → GID via `mutool trace`.
+        # For CID-keyed fonts without /ToUnicode and without a
+        # caller-supplied correlator config, trace every page of the
+        # PDF and positionally match hex labels to specimen glyphs.
+        # `mutool info` only reports the first page per font, so tracing
+        # all pages is simpler and catches every chart page.
+        #
+        # Each page is correlated independently to prevent cross-page
+        # position interference (page coordinate systems overlap, so
+        # a label on page 3 could wrongly match a specimen on page 2).
+        # First match wins when a codepoint appears on multiple pages.
+        def codepoint_map_from_trace(base_font, _font_obj_id)
+          return {} unless font_appears_in_pdf?(base_font)
+
+          runner = TraceRunner.new(@source.pdf_path)
+          correlator = TraceCorrelator.new(specimen_font_name: base_font)
+
+          (1..page_count).each_with_object({}) do |page, mapping|
+            glyphs = runner.trace([page])
+            page_mapping = correlator.correlate(glyphs)
+            page_mapping.each do |cp, gid|
+              mapping[cp] ||= gid
+            end
+          end
+        end
+
+        def font_appears_in_pdf?(base_font)
+          font_entries_cache.key?(base_font)
+        end
+
+        # Lazy cache of {base_font => true} — which fonts `mutool info`
+        # reports in this PDF. We only need the key set, not page numbers,
+        # because {codepoint_map_from_trace} traces all pages regardless.
+        def font_entries_cache
+          @font_entries_cache ||= begin
+            result = {}
+            mutool_info_text.each_line do |line|
+              next unless line.include?("Type0")
+
+              font_match = line.match(/Type0\s+'([^']+)'/)
+              next unless font_match
+
+              result[font_match[1]] = true
+            end
+            result
+          end
+        end
+
+        # Total pages in the PDF, parsed from `mutool info`'s
+        # `Pages: N` line. Falls back to the first font page if parsing
+        # fails (so we still try at least one page).
+        def page_count
+          @page_count ||= begin
+            m = mutool_info_text.match(/^Pages:\s+(\d+)/)
+            m ? m[1].to_i : 1
+          end
+        end
+
+        def mutool_info_text
+          @mutool_info_text ||= run_mutool_info
+        end
+
+        def run_mutool_info
+          out, err, status = Open3.capture3("mutool", "info", @source.pdf_to_s)
+          status.success? ? out + err : ""
+        end
+
         def resolve_fontfile(fd_dict)
           if fd_dict.key?("FontFile2")
             [first_ref(fd_dict["FontFile2"]), :ttf]

data/lib/ucode/glyphs/embedded_fonts/trace_correlator.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Glyphs
+    module EmbeddedFonts
+      # Correlates specimen glyphs (CID font without `/ToUnicode`) to
+      # their Unicode codepoints via positional matching against hex
+      # codepoint labels on the same chart page.
+      #
+      # The Unicode Code Charts use two layouts:
+      #
+      # 1. **List layout** (chart pages): the hex codepoint label (e.g.
+      #    "10D75") is printed to the LEFT of the specimen glyph at the
+      #    same Y baseline.
+      #
+      # 2. **Grid layout** (summary pages): the hex codepoint label is
+      #    printed directly ABOVE the specimen glyph (~12 pt higher on
+      #    Y, same X).
+      #
+      # Both layouts are handled by matching each specimen to the
+      # nearest valid label cluster by Euclidean distance, with a
+      # maximum match radius that excludes far-away header/footer text.
+      #
+      # The codepoint labels in every Unicode Code Charts PDF are set
+      # in a single dedicated label font (typically ArialNarrow).
+      # Character names, headers, and footers use other fonts. To avoid
+      # false matches from hex chars in those texts, the correlator
+      # auto-detects the label font as the non-specimen font that
+      # contributes the most hex-char glyphs.
+      #
+      # Matching is greedy one-to-one: each GID and each codepoint is
+      # assigned at most once, so a specimen that sits between two
+      # labels only claims the closer one.
+      #
+      # Pure logic — no I/O. The caller passes pre-parsed TraceGlyph
+      # arrays (typically from {TraceRunner} + {TraceParser}).
+      class TraceCorrelator
+        DEFAULT_Y_BUCKET = 1.0
+        private_constant :DEFAULT_Y_BUCKET
+
+        # Adjacent label chars within one codepoint label are ~4-6 pt
+        # apart on X. Different columns are ~30+ pt apart. 10 pt
+        # cleanly separates within-label from between-column gaps.
+        X_GAP_THRESHOLD = 10.0
+        private_constant :X_GAP_THRESHOLD
+
+        # Maximum valid Unicode codepoint. Filters out false labels
+        # that form hex strings from character-name fragments.
+        UNICODE_MAX = 0x10FFFF
+        private_constant :UNICODE_MAX
+
+        # Maximum Euclidean distance from a specimen to its matching
+        # label cluster. List-layout labels are ~21 pt to the left;
+        # grid-layout labels are ~12 pt above. Header/footer text is
+        # always > 30 pt away from any specimen.
+        MAX_MATCH_DISTANCE = 30.0
+        private_constant :MAX_MATCH_DISTANCE
+
+        # @param specimen_font_name [String] the BaseFont name of the
+        #   CID font whose glyphs need correlation
+        def initialize(specimen_font_name:)
+          @specimen_font_name = specimen_font_name
+          @y_bucket = DEFAULT_Y_BUCKET
+        end
+
+        # @param trace_glyphs [Array<TraceGlyph>]
+        # @return [Hash{Integer=>Integer}] codepoint => gid
+        def correlate(trace_glyphs)
+          specimens = trace_glyphs.select { |g| g.font_name == @specimen_font_name }
+          return {} if specimens.empty?
+
+          label_font = detect_label_font(trace_glyphs)
+          return {} unless label_font
+
+          labels = trace_glyphs.select { |g| label_glyph?(g, label_font) }
+          return {} if labels.empty?
+
+          clusters = build_label_clusters(labels)
+          return {} if clusters.empty?
+
+          build_mapping(specimens, clusters)
+        end
+
+        private
+
+        # The label font is the non-specimen font whose hex-char glyphs
+        # appear most often in close proximity to specimen glyphs.
+        # Code Charts dedicate one small font to the codepoint labels;
+        # body text, headers, and character names use other fonts that
+        # may also contain hex chars but are not co-located with
+        # specimens (e.g. the index page has thousands of hex chars in
+        # MyriadPro-Light but zero specimens).
+        LABEL_PROXIMITY_RADIUS = 50.0
+        private_constant :LABEL_PROXIMITY_RADIUS
+
+        def detect_label_font(trace_glyphs)
+          specimens = trace_glyphs.select { |g| g.font_name == @specimen_font_name }
+          return nil if specimens.empty?
+
+          non_specimen_hex = non_specimen_hex_glyphs(trace_glyphs)
+          return nil if non_specimen_hex.empty?
+
+          counts = proximity_counts(specimens, non_specimen_hex)
+          return nil if counts.empty?
+
+          counts.max_by { |_, n| n }.first
+        end
+
+        def non_specimen_hex_glyphs(trace_glyphs)
+          trace_glyphs.select do |g|
+            g.font_name != @specimen_font_name &&
+              g.unicode&.match?(/\A[0-9A-Fa-f]\z/)
+          end
+        end
+
+        def proximity_counts(specimens, candidates)
+          counts = Hash.new(0)
+          radius_sq = LABEL_PROXIMITY_RADIUS * LABEL_PROXIMITY_RADIUS
+          specimens.each do |spec|
+            candidates.each do |g|
+              counts[g.font_name] += 1 if within_radius?(spec, g, radius_sq)
+            end
+          end
+          counts
+        end
+
+        def within_radius?(spec, glyph, radius_sq)
+          dx = spec.x - glyph.x
+          dy = spec.y - glyph.y
+          dx * dx + dy * dy < radius_sq
+        end
+
+        def label_glyph?(glyph, label_font)
+          glyph.font_name == label_font &&
+            glyph.unicode&.match?(/\A[0-9A-Fa-f]\z/)
+        end
+
+        # Cluster labels by Y (row), then by X gap (column within row).
+        # Returns a flat array of {x:, y:, codepoint:} clusters.
+        def build_label_clusters(labels)
+          by_y = labels.group_by { |g| quantize(g.y, @y_bucket) }
+          by_y.flat_map { |(_, glyphs)| clusters_from_row(glyphs) }
+        end
+
+        def clusters_from_row(glyphs)
+          cluster_by_x_gap(glyphs.sort_by(&:x)).filter_map { |cluster| build_cluster(cluster) }
+        end
+
+        def build_cluster(cluster)
+          hex = cluster.map(&:unicode).join
+          return nil unless hex.match?(/\A[0-9A-Fa-f]{4,6}\z/)
+
+          cp = hex.to_i(16)
+          return nil unless cp <= UNICODE_MAX
+
+          {
+            x: cluster.sum(&:x) / cluster.size,
+            y: cluster.first.y,
+            codepoint: cp,
+          }
+        end
+
+        def cluster_by_x_gap(sorted_glyphs)
+          clusters = []
+          current = []
+
+          sorted_glyphs.each do |g|
+            if current.empty? || (g.x - current.last.x).abs < X_GAP_THRESHOLD
+              current << g
+            else
+              clusters << current if current.size > 1
+              current = [g]
+            end
+          end
+          clusters << current if current.size > 1
+          clusters
+        end
+
+        # Greedy one-to-one matching: each GID and each codepoint is
+        # assigned at most once. Candidate pairs are sorted by distance
+        # so the closest specimen-label pair always wins.
+        def build_mapping(specimens, clusters)
+          candidates = Array.new(clusters.size) { |ci| specimen_distances(specimens, clusters, ci) }
+
+          assigned_gids = Set.new
+          assigned_cps = Set.new
+          mapping = {}
+
+          pairs_by_distance(candidates).each do |spec_idx, cluster_idx, dist|
+            next if dist > MAX_MATCH_DISTANCE
+
+            spec = specimens[spec_idx]
+            cluster = clusters[cluster_idx]
+            next if assigned_gids.include?(spec.gid)
+            next if assigned_cps.include?(cluster[:codepoint])
+
+            assigned_gids << spec.gid
+            assigned_cps << cluster[:codepoint]
+            mapping[cluster[:codepoint]] = spec.gid
+          end
+
+          mapping
+        end
+
+        def specimen_distances(specimens, clusters, cluster_idx)
+          cluster = clusters[cluster_idx]
+          specimens.each_with_index.map do |spec, spec_idx|
+            [spec_idx, cluster_idx, distance(spec, cluster)]
+          end
+        end
+
+        def pairs_by_distance(candidates)
+          candidates.flatten(1).sort_by { |_, _, dist| dist }
+        end
+
+        def distance(spec, cluster)
+          dx = spec.x - cluster[:x]
+          dy = spec.y - cluster[:y]
+          Math.sqrt(dx * dx + dy * dy)
+        end
+
+        def quantize(value, bucket_size)
+          return nil if value.nil?
+
+          (value / bucket_size).round * bucket_size
+        end
+      end
+    end
+  end
+end

data/lib/ucode/glyphs/embedded_fonts/trace_glyph.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ucode
+  module Glyphs
+    module EmbeddedFonts
+      # Value object for one glyph emitted by `mutool trace`.
+      #
+      # Each `<g>` element in the trace XML maps to one TraceGlyph:
+      #
+      #   <g unicode="�" glyph="174" x="237.06" y="673.92" adv=".62"/>
+      #
+      # The `font_name` is inherited from the enclosing `<span>`:
+      #
+      #   <span font="GPJAHB+WolofGaraySansSerif" ...>
+      #       <g .../>
+      #   </span>
+      TraceGlyph = Struct.new(
+        :font_name,
+        :gid,
+        :x,
+        :y,
+        :unicode,
+        keyword_init: true,
+      )
+    end
+  end
+end

data/lib/ucode/glyphs/embedded_fonts/trace_parser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ucode
+  module Glyphs
+    module EmbeddedFonts
+      # Parses the XML output of `mutool trace <pdf> <page>` into an
+      # array of {TraceGlyph} instances.
+      #
+      # The trace XML uses a flat `<span font="...">` → `<g glyph="..."
+      # x="..." y="..." unicode="..."/>` structure. Nokogiri walks
+      # the tree; the parser maps each `<g>` to a TraceGlyph,
+      # inheriting the font_name from the enclosing span.
+      #
+      # Pure function — no I/O, no PDF access. Callers inject the XML
+      # string (typically from {TraceRunner}).
+      module TraceParser
+        class << self
+          # @param xml [String] raw mutool trace XML
+          # @return [Array<TraceGlyph>] one per `<g>` element; empty
+          #   if the XML is empty or has no `<g>` elements
+          def parse(xml)
+            return [] if xml.nil? || xml.strip.empty?
+
+            doc = Nokogiri::XML(xml)
+            doc.css("span").flat_map { |span| glyphs_in_span(span) }
+          end
+
+          private
+
+          def glyphs_in_span(span)
+            font_name = span[:font]
+            span.css("g").map { |g| build_glyph(font_name, g) }
+          end
+
+          def build_glyph(font_name, g)
+            TraceGlyph.new(
+              font_name: font_name,
+              gid: g[:glyph]&.to_i,
+              x: g[:x]&.to_f,
+              y: g[:y]&.to_f,
+              unicode: g[:unicode],
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ucode/glyphs/embedded_fonts/trace_runner.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+
+require "ucode/error"
+
+module Ucode
+  module Glyphs
+    module EmbeddedFonts
+      # Thin I/O wrapper around `mutool trace <pdf> <page>`.
+      #
+      # Runs mutool on the given pages, captures the XML output,
+      # delegates parsing to {TraceParser}, and returns a flat
+      # `Array<TraceGlyph>` across all pages.
+      #
+      # The only class in the trace pipeline that touches the
+      # filesystem / spawns subprocesses. Everything upstream
+      # (parser, correlator) is pure.
+      class TraceRunner
+        # @param pdf_path [Pathname, String]
+        def initialize(pdf_path)
+          @pdf_path = Pathname.new(pdf_path)
+        end
+
+        # @param page_numbers [Array<Integer>] 1-based PDF page numbers
+        # @return [Array<TraceGlyph>]
+        def trace(page_numbers)
+          page_numbers.flat_map { |page| trace_page(page) }
+        end
+
+        private
+
+        def trace_page(page)
+          xml = run_mutool(page)
+          TraceParser.parse(xml)
+        end
+
+        def run_mutool(page)
+          out, err, status = Open3.capture3(
+            "mutool", "trace", @pdf_path.to_s, page.to_s,
+          )
+          unless status.success?
+            raise Ucode::EmbeddedFontsMissingError,
+                  "mutool trace failed: #{(out + err).strip}"
+          end
+
+          out + err
+        end
+      end
+    end
+  end
+end

data/lib/ucode/glyphs/embedded_fonts.rb

@@ -42,6 +42,10 @@ module Ucode
       autoload :Catalog, "ucode/glyphs/embedded_fonts/catalog"
       autoload :ContentStreamCorrelator,
                "ucode/glyphs/embedded_fonts/content_stream_correlator"
+      autoload :TraceGlyph, "ucode/glyphs/embedded_fonts/trace_glyph"
+      autoload :TraceParser, "ucode/glyphs/embedded_fonts/trace_parser"
+      autoload :TraceCorrelator, "ucode/glyphs/embedded_fonts/trace_correlator"
+      autoload :TraceRunner, "ucode/glyphs/embedded_fonts/trace_runner"
       autoload :Svg, "ucode/glyphs/embedded_fonts/svg"
       autoload :Renderer, "ucode/glyphs/embedded_fonts/renderer"
       autoload :Writer, "ucode/glyphs/embedded_fonts/writer"

data/lib/ucode/glyphs/pdf_fetcher.rb

@@ -1,42 +1,26 @@
 # frozen_string_literal: true
 
 require "pathname"
-require "open3"
 
 require "ucode/cache"
 require "ucode/fetch/code_charts"
-require "ucode/glyphs/monolith_page_map"
 
 module Ucode
   module Glyphs
     # Resolves a Unicode block to its source PDF on disk.
     #
-    # Primary source: the per-block PDF cached at
+    # Source: the per-block PDF cached at
     # `<cache>/<version>/pdfs/U<XXXX>.pdf` (downloaded from
     # `unicode.org/charts/PDF/` by `Ucode::Fetch::CodeCharts`).
-    #
-    # Fallback: slice the page range from the monolith `CodeCharts.pdf`.
-    # The page range is resolved by `MonolithPageMap` from the PDF's
-    # bookmark outline, cached under `data/codecharts_page_map.json`.
     class PdfFetcher
       # @param version [String] UCD version, used as the cache namespace.
-      # @param monolith_path [String, Pathname, nil] path to the full
-      #   `CodeCharts.pdf`. Pass nil to disable monolith fallback.
-      # @param blocks [Array<Ucode::Models::Block>] required for monolith
-      #   fallback — used to match bookmark titles to block first-cps.
-      # @param page_map_cache [String, Pathname, nil] where to read/write
-      #   the monolith page-map JSON cache.
-      def initialize(version, monolith_path: nil, blocks: [], page_map_cache: nil)
+      def initialize(version)
         @version = version
-        @monolith_path = monolith_path && Pathname.new(monolith_path)
-        @blocks = blocks
-        @page_map_cache = page_map_cache
       end
 
       # Resolve the per-block PDF for `block_first_cp`, fetching from the
       # network if missing. Returns the local PDF path, or nil if the
-      # block's PDF is unavailable (network failure + no monolith, or
-      # monolith lacks the requested block).
+      # block's PDF is unavailable (network failure).
       #
       # @param block_first_cp [Integer] first codepoint of the block;
       #   also the PDF's URL slug per unicode.org's naming convention.
@@ -47,9 +31,7 @@ module Ucode
         return path if path.exist? && !force
 
         download(block_first_cp)
-        return path if path.exist?
-
-        slice_from_monolith(block_first_cp)
+        path if path.exist?
       end
 
       private
@@ -65,38 +47,13 @@ module Ucode
       def download(block_first_cp)
         Fetch::CodeCharts.call(@version, block_first_cps: [block_first_cp])
       rescue StandardError => e
-        # Network failures fall through to monolith fallback. We do not
-        # swallow programming errors (NoMethodError etc.) — only fetch
-        # failures (network, checksum, HTTP).
+        # Network failures return nil so callers can fall back to other
+        # tiers. We do not swallow programming errors (NoMethodError
+        # etc.) — only fetch failures (network, checksum, HTTP).
         return if e.is_a?(Ucode::FetchError)
 
         raise
       end
-
-      def slice_from_monolith(block_first_cp)
-        return unless @monolith_path&.exist?
-
-        entry = page_map[block_first_cp]
-        return unless entry && entry.start_page && entry.end_page
-
-        slice_pages(entry.start_page, entry.end_page, per_block_path(block_first_cp))
-      end
-
-      def page_map
-        @page_map ||= MonolithPageMap.load(
-          monolith_path: @monolith_path,
-          blocks: @blocks,
-          cache_path: @page_map_cache,
-        )
-      end
-
-      def slice_pages(start_page, end_page, out_path)
-        out_path.dirname.mkpath
-        cmd = ["pdftk", @monolith_path.to_s, "cat",
-               "#{start_page}-#{end_page}", "output", out_path.to_s]
-        _out, status = Open3.capture2e(*cmd)
-        status.success? ? out_path : nil
-      end
     end
   end
 end

data/lib/ucode/glyphs.rb

@@ -3,24 +3,14 @@
 module Ucode
   # Glyphs — converts Code Charts PDF pages into per-codepoint SVGs.
   #
-  # Pipeline: fetch per-block PDF → render to SVG → detect grid → extract
-  # cell → normalize viewBox → write glyph.svg.
+  # The current pipeline is the 4-tier sourcing strategy:
+  # Tier 1 (real fonts) → Pillar 1 (embedded CIDFont + ToUnicode) →
+  # Pillar 2 (positional correlation) → Pillar 3 (Last Resort UFO).
+  # See {EmbeddedFonts} for Pillar 1 + 2 and {LastResort} for Pillar 3.
   #
   # Vector extraction only. NEVER run OCR.
   module Glyphs
     autoload :PdfFetcher, "ucode/glyphs/pdf_fetcher"
-    autoload :PageRenderer, "ucode/glyphs/page_renderer"
-    autoload :MutoolRenderer, "ucode/glyphs/mutool_renderer"
-    autoload :Pdf2svgRenderer, "ucode/glyphs/pdf2svg_renderer"
-    autoload :DvisvgmRenderer, "ucode/glyphs/dvisvgm_renderer"
-    autoload :PdftocairoRenderer, "ucode/glyphs/pdftocairo_renderer"
-    autoload :Grid, "ucode/glyphs/grid"
-    autoload :PathBbox, "ucode/glyphs/path_bbox"
-    autoload :GridDetector, "ucode/glyphs/grid_detector"
-    autoload :CellExtractor, "ucode/glyphs/cell_extractor"
-    autoload :MonolithPageMap, "ucode/glyphs/monolith_page_map"
-    autoload :Writer, "ucode/glyphs/writer"
-    autoload :Pipeline, "ucode/glyphs/pipeline"
     autoload :LastResort, "ucode/glyphs/last_resort"
     autoload :EmbeddedFonts, "ucode/glyphs/embedded_fonts"
     autoload :RealFonts, "ucode/glyphs/real_fonts"

data/lib/ucode/repo/aggregate_writer.rb

@@ -155,4 +155,4 @@ module Ucode
       end
     end
   end
-end
+end

data/lib/ucode/repo/writers/blocks_writer.rb

@@ -45,12 +45,12 @@ module Ucode
           path = Paths.blocks_index_path(@output_root)
           summary = @blocks.map do |block|
             {
-              "id"           => block.id,
-              "name"         => block.name,
-              "first_cp"     => block.range_first,
-              "last_cp"      => block.range_last,
+              "id" => block.id,
+              "name" => block.name,
+              "first_cp" => block.range_first,
+              "last_cp" => block.range_last,
               "plane_number" => block.plane_number,
-              "age"          => @block_ages[block.id],
+              "age" => @block_ages[block.id],
             }
           end
           write_atomic(path, to_pretty_json(summary)) ? 1 : 0
@@ -58,16 +58,16 @@ module Ucode
 
         def block_payload(block)
           to_pretty_json(
-            "id"             => block.id,
-            "name"           => block.name,
-            "range_first"    => block.range_first,
-            "range_last"     => block.range_last,
-            "plane_number"   => block.plane_number,
-            "age"            => @block_ages[block.id],
-            "codepoint_ids"  => (@block_codepoint_ids[block.id] || []),
+            "id" => block.id,
+            "name" => block.name,
+            "range_first" => block.range_first,
+            "range_last" => block.range_last,
+            "plane_number" => block.plane_number,
+            "age" => @block_ages[block.id],
+            "codepoint_ids" => @block_codepoint_ids[block.id] || [],
           )
         end
       end
     end
   end
-end
+end

data/lib/ucode/repo/writers/enums_writer.rb

@@ -27,7 +27,7 @@ module Ucode
         def write
           path = Pathname(@output_root).join("enums.json")
           payload = {
-            "properties"      => @property_aliases.map(&:to_yaml_hash),
+            "properties" => @property_aliases.map(&:to_yaml_hash),
             "property_values" => @property_value_aliases.map(&:to_yaml_hash),
           }
           write_atomic(path, to_pretty_json(payload)) ? 1 : 0
@@ -35,4 +35,4 @@ module Ucode
       end
     end
   end
-end
+end