ucode 0.1.1 → 0.2.0

data/lib/ucode/commands/universal_set.rb

@@ -39,7 +39,7 @@ module Ucode
       # (in `lib/ucode/cli.rb`) is responsible only for argument
       # parsing and dispatch.
       class BuildCommand
-        # @param version_intent [nil, :default, :latest, String]
+        # @param version [String] resolved UCD version
         # @param output_root [String, Pathname] directory that will
         #   hold `manifest.json`, `glyphs/`, `reports/`.
         # @param source_config_path [String, Pathname, nil] override
@@ -58,10 +58,9 @@ module Ucode
         #   resolver and don't have a real source config on disk.
         # @return [Hash] { version:, manifest_path:, totals:,
         #   by_tier:, coverage:, validation: }
-        def call(version_intent, output_root:, source_config_path: nil,
+        def call(version, output_root:, source_config_path: nil,
                  resolver: nil, block_filter: nil,
                  parallel_workers: default_workers, skip_pre_check: false)
-          version = VersionResolver.resolve(version_intent)
           root = Pathname.new(output_root)
 
           config_path = source_config_path_or_default(source_config_path)
@@ -144,7 +143,7 @@ module Ucode
       # checks (config loads, fonts present, coverage assertion runs)
       # without starting the 4-hour build.
       class PreCheckCommand
-        # @param version_intent [nil, :default, :latest, String]
+        # @param version [String] resolved UCD version
         # @param source_config_path [String, Pathname, nil]
         # @param cmaps [#covers?] injectable; defaults to
         #   RealFonts::CmapCache.
@@ -153,9 +152,8 @@ module Ucode
         # @return [Ucode::Glyphs::UniversalSet::PreBuildReport]
         # @raise [Ucode::UniversalSetPreBuildError] when missing_fonts
         #   is non-empty or the config fails to load.
-        def call(version_intent, source_config_path: nil, cmaps: nil,
+        def call(version, source_config_path: nil, cmaps: nil,
                  font_locator: nil)
-          version = VersionResolver.resolve(version_intent)
           database = Database.open(version)
           config_path = source_config_path || Glyphs::SourceConfig::DEFAULT_PATH
 
@@ -171,12 +169,11 @@ module Ucode
       # shape (or regenerating reports after a model change) without
       # re-running the build.
       class ReportCommand
-        # @param version_intent [nil, :default, :latest, String]
+        # @param version [String] resolved UCD version
         # @param output_root [String, Pathname] directory holding
         #   `manifest.json`.
         # @return [Hash] the {CoverageReport#emit} payload.
-        def call(version_intent, output_root:)
-          version = VersionResolver.resolve(version_intent)
+        def call(version, output_root:)
           root = Pathname.new(output_root)
           manifest_path = root.join("manifest.json")
           raise Ucode::Error, "manifest not found at #{manifest_path}" unless manifest_path.exist?
@@ -196,12 +193,11 @@ module Ucode
       # totals_reconcile, provenance_complete).
       class ValidateCommand
         # @param output_root [String, Pathname]
-        # @param version_intent [nil, :default, :latest, String]
-        #   used only to stamp the report's unicode_version when the
-        #   manifest's recorded value is missing.
+        # @param version [String, nil] resolved UCD version, used only
+        #   to stamp the report's unicode_version when the manifest's
+        #   recorded value is missing.
         # @return [Hash] the {Validator#validate} payload.
-        def call(output_root, version_intent: nil)
-          version = version_intent && VersionResolver.resolve(version_intent)
+        def call(output_root, version: nil)
           Glyphs::UniversalSet::Validator
             .new(output_root, unicode_version: version).validate
         end

data/lib/ucode/coordinator/indices.rb

@@ -2,6 +2,22 @@
 
 module Ucode
   class Coordinator
+    # Pairs of (output-file-slug, indices-field) for every per-property
+    # relationship table the Repo writes. Each field holds a Hash whose
+    # values are Records (or Arrays of Records). The Repo iterates
+    # `Indices#each_relationship` instead of reaching into the Struct by
+    # field name (see Candidate 1 of the 2026-06-29 architecture review).
+    RELATIONSHIPS = [
+      ["special_casing",        :special_casing],
+      ["case_folding",          :case_folding],
+      ["bidi_mirroring",        :bidi_mirroring],
+      ["bidi_brackets",         :bidi_brackets],
+      ["cjk_radicals",          :cjk_radicals],
+      ["standardized_variants", :standardized_variants],
+      ["name_aliases",          :name_aliases],
+    ].freeze
+    private_constant :RELATIONSHIPS
+
     # Bag of pre-built indices consumed by the per-codepoint enrichment
     # pass. Every field is a frozen-shaped collection that is read-only
     # after `build_indices` returns: range files land in sorted Arrays
@@ -12,6 +28,10 @@ module Ucode
     # call reads as a self-documenting catalogue of every parsed file —
     # adding a new index is one keyword arg here, one builder call in
     # `Coordinator#build_indices`, and one assignment in `#enrich`.
+    #
+    # The relationship enumerator (`#each_relationship`) is the seam the
+    # Repo uses to write per-property relationship tables without knowing
+    # which Struct field carries which data.
     Indices = Struct.new(
       :blocks,
       :scripts,
@@ -40,6 +60,22 @@ module Ucode
       :emoji_properties,
       :extra_binary_properties,
       keyword_init: true,
-    )
+    ) do
+      # Yield (slug, records) for each relationship table. The seam
+      # between "what the Coordinator indexed" and "what the Repo writes"
+      # lives here — Repo never names a Struct field directly.
+      #
+      # @yieldparam slug [String] output file slug under
+      #   `output/relationships/`
+      # @yieldparam records [Hash<Integer|String, Record|Array<Record>>]
+      # @return [Enumerator] when no block is given
+      def each_relationship(&block)
+        return enum_for(:each_relationship) unless block_given?
+
+        RELATIONSHIPS.each do |slug, field|
+          yield(slug, public_send(field))
+        end
+      end
+    end
   end
-end
+end

data/lib/ucode/glyphs/pipeline.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "set"
+
+require "ucode/cache"
+require "ucode/glyphs/pdf_fetcher"
+require "ucode/glyphs/writer"
+require "ucode/parsers"
+
+module Ucode
+  module Glyphs
+    # Assembles the per-block specs that {Glyphs::Writer#write_all} drains.
+    #
+    # Owns three pieces of orchestration that {Commands::GlyphsCommand}
+    # used to carry inline:
+    #
+    #   - block loading from {Cache.ucd_dir}/Blocks.txt (with an optional
+    #     block filter)
+    #   - PDF fetcher construction (with monolith fallback)
+    #   - the per-block page-map heuristic (per-block PDFs are page 1 =
+    #     title, page 2 = first chart page starting at the block's first
+    #     codepoint; true for most BMP blocks; multi-page blocks need a
+    #     richer resolver — mismatches yield placeholder SVGs only, never
+    #     wrong glyphs)
+    #
+    # The Command stays a thin wrapper that prints the experimental
+    # warning and wires the writer. See Candidate 3 of the 2026-06-29
+    # architecture review.
+    class Pipeline
+      # Path to the monolith fallback file when no per-block PDF is on
+      # disk yet. Overridable for tests.
+      DEFAULT_MONOLITH_PATH = "CodeCharts.pdf"
+      # Cache path for the page-map corpus. Overridable for tests.
+      DEFAULT_PAGE_MAP_CACHE = "data/codecharts_page_map.json"
+
+      Spec = Struct.new(:block, :pdf_path, :page_map, keyword_init: true)
+
+      # @param version [String] resolved UCD version (callers must
+      #   resolve via {VersionResolver.resolve} first)
+      # @param block_filter [Array<String>, nil] block ids to limit to;
+      #   nil = every block
+      # @param monolith_path [String, Pathname, nil] fallback monolith
+      # @param page_map_cache [String, Pathname] cache for the page map
+      def initialize(version:, block_filter: nil,
+                     monolith_path: DEFAULT_MONOLITH_PATH,
+                     page_map_cache: DEFAULT_PAGE_MAP_CACHE)
+        @version = version
+        @block_filter = block_filter
+        @monolith_path = monolith_path
+        @page_map_cache = page_map_cache
+      end
+
+      # Load every block from the cached Blocks.txt (filtered by
+      # `@block_filter` when set) and pair each one with a fetched PDF
+      # path and a page map. Blocks whose PDF cannot be fetched are
+      # silently dropped — the placeholder pass downstream covers them.
+      #
+      # @param force [Boolean] re-fetch PDFs even when cached
+      # @return [Array<Spec>]
+      def build_specs(force: false)
+        blocks = load_blocks
+        fetcher = build_fetcher(blocks)
+        blocks.map { |block| spec_for(block, fetcher, force) }.compact
+      end
+
+      private
+
+      def load_blocks
+        path = Cache.ucd_dir(@version).join("Blocks.txt")
+        return [] unless path.exist?
+
+        all = Parsers::Blocks.each_record(path).to_a
+        return all unless @block_filter && !@block_filter.empty?
+
+        filter_set = @block_filter.to_set
+        all.select { |block| filter_set.include?(block.id) }
+      end
+
+      def build_fetcher(blocks)
+        monolith = @monolith_path ? Pathname.new(@monolith_path) : nil
+        monolith = monolith.exist? ? monolith : nil
+        PdfFetcher.new(
+          @version,
+          monolith_path: monolith,
+          blocks: blocks,
+          page_map_cache: @page_map_cache,
+        )
+      end
+
+      def spec_for(block, fetcher, force)
+        pdf_path = fetcher.fetch(block_first_cp: block.range_first, force: force)
+        return nil unless pdf_path
+
+        Spec.new(block: block, pdf_path: pdf_path, page_map: page_map_for(block))
+      end
+
+      # Per-block PDFs are page 1 = title, page 2 = first chart page
+      # starting at the block's first codepoint. True for most BMP
+      # blocks; multi-page blocks (CJK) need a richer resolver.
+      def page_map_for(block)
+        { 2 => block.range_first }
+      end
+    end
+  end
+end

data/lib/ucode/glyphs.rb

@@ -20,6 +20,7 @@ module Ucode
     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

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
 require "pathname"
-require "json"
-require "time"
 
-require "ucode/models"
-require "ucode/repo/atomic_writes"
-require "ucode/repo/paths"
+require "ucode/repo/writers/planes_writer"
+require "ucode/repo/writers/blocks_writer"
+require "ucode/repo/writers/scripts_writer"
+require "ucode/repo/writers/indexes_writer"
+require "ucode/repo/writers/relationships_writer"
+require "ucode/repo/writers/enums_writer"
+require "ucode/repo/writers/named_sequences_writer"
+require "ucode/repo/writers/manifest_writer"
 
 module Ucode
   module Repo
@@ -14,67 +17,30 @@ module Ucode
     #
     #   output/planes/<n>.json
     #   output/blocks/<ID>.json
-    #   output/blocks/index.json              (block index)
+    #   output/blocks/index.json
     #   output/scripts/<code>.json
-    #   output/index/names.json               (cp_id → name)
-    #   output/index/labels.json              (cp_id → {name, gc, sc, cc, bc, mir})
-    #   output/index/codepoint_to_block.json  (cp_id → block_id)
-    #   output/relationships/*.json           (per-property tables)
-    #   output/enums.json                     (property aliases + value aliases)
+    #   output/index/names.json
+    #   output/index/labels.json
+    #   output/index/codepoint_to_block.json
+    #   output/relationships/*.json
+    #   output/enums.json
     #   output/named_sequences/<slug>.json
     #   output/manifest.json
     #
-    # **Single pass**: callers feed one CodePoint at a time via `#add`;
-    # `#flush` writes all derived files using the Coordinator's indices
-    # for the static tables (relationships, enums, named sequences).
+    # **Single pass**: callers feed one CodePoint at a time via `#add`,
+    # which folds into the streaming accumulators. `#flush` then
+    # composes eight per-concern writer classes (one per output kind)
+    # and runs them in order. Adding a new aggregate = adding one
+    # writer class + one line here. See Candidate 5 of the 2026-06-29
+    # architecture review.
     #
     # **MECE**:
     #   - paths: `Repo::Paths`
     #   - atomic writes: `Repo::AtomicWrites`
-    #   - stream aggregation: this class
+    #   - stream aggregation: this class (the `#add` half)
+    #   - per-concern writers: `Repo::Writers::*`
     #   - serialization: lutaml-model `to_yaml_hash` / `to_json`
     class AggregateWriter
-      include AtomicWrites
-
-      # Static metadata for the 17 Unicode planes. Planes 4–13 are
-      # unassigned in Unicode 17; their entries use placeholder names.
-      PLANE_TABLE = {
-        0  => ["Basic Multilingual Plane",            "BMP"],
-        1  => ["Supplementary Multilingual Plane",    "SMP"],
-        2  => ["Supplementary Ideographic Plane",     "SIP"],
-        3  => ["Tertiary Ideographic Plane",          "TIP"],
-        4  => ["Unassigned Plane 4",                  "—"],
-        5  => ["Unassigned Plane 5",                  "—"],
-        6  => ["Unassigned Plane 6",                  "—"],
-        7  => ["Unassigned Plane 7",                  "—"],
-        8  => ["Unassigned Plane 8",                  "—"],
-        9  => ["Unassigned Plane 9",                  "—"],
-        10 => ["Unassigned Plane 10",                 "—"],
-        11 => ["Unassigned Plane 11",                 "—"],
-        12 => ["Unassigned Plane 12",                 "—"],
-        13 => ["Unassigned Plane 13",                 "—"],
-        14 => ["Supplementary Special-purpose Plane", "SSP"],
-        15 => ["Supplementary Private Use Area-A",    "SPUA-A"],
-        16 => ["Supplementary Private Use Area-B",    "SPUA-B"],
-      }.freeze
-      private_constant :PLANE_TABLE
-
-      # Coordinator::Indices fields paired with the file slug used
-      # under `output/relationships/`. Each field is a Hash<Integer,
-      # Record> or Hash<Integer, Array<Record>>.
-      RELATIONSHIP_SOURCES = {
-        special_casing:        "special_casing",
-        case_folding:          "case_folding",
-        bidi_mirroring:        "bidi_mirroring",
-        bidi_brackets:         "bidi_brackets",
-        cjk_radicals:          "cjk_radicals",
-        standardized_variants: "standardized_variants",
-        name_aliases:          "name_aliases",
-      }.freeze
-      private_constant :RELATIONSHIP_SOURCES
-
-      attr_reader :codepoint_count
-
       # @param output_root [String, Pathname]
       def initialize(output_root)
         @output_root = Pathname.new(output_root)
@@ -87,6 +53,8 @@ module Ucode
         @codepoint_count = 0
       end
 
+      attr_reader :codepoint_count
+
       # Fold one CodePoint into the stream accumulators. No-ops if the
       # cp has no block_id (it has no home in the output tree).
       # @param cp [Ucode::Models::CodePoint]
@@ -107,10 +75,8 @@ module Ucode
         @codepoint_count += 1
       end
 
-      # Write every aggregate file. Optional params supply data that is
-      # not in `Coordinator::Indices` (the Coordinator only resolves the
-      # `sc` subset of PropertyValueAliases; the full alias tables and
-      # the named sequences are passed through from the CLI/parsers).
+      # Compose the eight per-concern writers, run them in order, and
+      # return the total number of files written.
       #
       # @param ucd_version [String]
       # @param indices [Ucode::Coordinator::Indices]
@@ -118,19 +84,40 @@ module Ucode
       # @param property_value_aliases [Array<Ucode::Models::PropertyValueAlias>]
       # @param named_sequences [Array<Ucode::Models::NamedSequence>]
       # @param glyph_count [Integer]
-      # @return [Integer] number of files written
+      # @return [Integer]
       def flush(ucd_version:, indices:, property_aliases: [],
                 property_value_aliases: [], named_sequences: [], glyph_count: 0)
-        writes = 0
-        writes += write_planes(indices.blocks)
-        writes += write_blocks(indices.blocks)
-        writes += write_scripts(indices.scripts)
-        writes += write_indexes
-        writes += write_relationships(indices)
-        writes += write_enums(property_aliases, property_value_aliases)
-        writes += write_named_sequences(named_sequences)
-        writes += write_manifest(ucd_version: ucd_version, glyph_count: glyph_count)
-        writes
+        writers(ucd_version, indices, property_aliases, property_value_aliases,
+                named_sequences, glyph_count).sum(&:write)
+      end
+
+      # @api private — exposed for testing.
+      def writers(ucd_version, indices, property_aliases,
+                  property_value_aliases, named_sequences, glyph_count)
+        [
+          Writers::PlanesWriter.new(output_root: @output_root, blocks: indices.blocks),
+          Writers::BlocksWriter.new(output_root: @output_root,
+                                    blocks: indices.blocks,
+                                    block_codepoint_ids: @block_codepoint_ids,
+                                    block_ages: @block_ages),
+          Writers::ScriptsWriter.new(output_root: @output_root,
+                                     scripts: indices.scripts,
+                                     script_codepoint_ids: @script_codepoint_ids),
+          Writers::IndexesWriter.new(output_root: @output_root,
+                                     names: @names_index,
+                                     labels: @labels_index,
+                                     cp_to_block: @cp_to_block),
+          Writers::RelationshipsWriter.new(output_root: @output_root, indices: indices),
+          Writers::EnumsWriter.new(output_root: @output_root,
+                                   property_aliases: property_aliases,
+                                   property_value_aliases: property_value_aliases),
+          Writers::NamedSequencesWriter.new(output_root: @output_root,
+                                            named_sequences: named_sequences),
+          Writers::ManifestWriter.new(output_root: @output_root,
+                                      ucd_version: ucd_version,
+                                      codepoint_count: @codepoint_count,
+                                      glyph_count: glyph_count),
+        ]
       end
 
       private
@@ -151,9 +138,7 @@ module Ucode
 
       # Per-block `age` is the earliest DerivedAge of any codepoint in
       # the block, compared as a Gem::Version. Stored as the original
-      # string (e.g. "1.1", "17.0.0"). nil when no codepoint in the
-      # block has an age (rare — only happens for entirely-reserved
-      # blocks, which the parser excludes anyway).
+      # string (e.g. "1.1", "17.0.0").
       def track_block_age(cp)
         return if cp.age.nil? || cp.age.empty?
 
@@ -168,229 +153,6 @@ module Ucode
       def min_age(a, b)
         Gem::Version.new(a) < Gem::Version.new(b) ? a : b
       end
-
-      # ---- Plane files -------------------------------------------------
-
-      def write_planes(blocks)
-        plane_block_ids = group_block_ids_by_plane(blocks)
-        count = 0
-        (0..16).each do |n|
-          path = Paths.plane_metadata_path(@output_root, n)
-          count += 1 if write_atomic(path, plane_payload(n, plane_block_ids[n] || []))
-        end
-        count
-      end
-
-      def group_block_ids_by_plane(blocks)
-        blocks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |block, h|
-          h[block.plane_number] << block.id
-        end
-      end
-
-      def plane_payload(plane_number, block_ids)
-        name, abbrev = PLANE_TABLE.fetch(plane_number)
-        range_first = plane_number * 0x10000
-        range_last  = range_first + 0xFFFF
-        to_pretty_json(
-          "number"       => plane_number,
-          "name"         => name,
-          "abbrev"       => abbrev,
-          "range_first"  => range_first,
-          "range_last"   => range_last,
-          "block_ids"    => block_ids,
-        )
-      end
-
-      # ---- Block files -------------------------------------------------
-
-      def write_blocks(blocks)
-        count = blocks.sum do |block|
-          block.age = @block_ages[block.id]
-          path = Paths.block_metadata_path(@output_root, block.id)
-          write_atomic(path, block_payload(block)) ? 1 : 0
-        end
-        count + write_blocks_index(blocks)
-      end
-
-      def write_blocks_index(blocks)
-        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,
-            "plane_number" => block.plane_number,
-            "age"          => @block_ages[block.id],
-          }
-        end
-        write_atomic(path, to_pretty_json(summary)) ? 1 : 0
-      end
-
-      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] || []),
-        )
-      end
-
-      # ---- Script files ------------------------------------------------
-
-      def write_scripts(scripts)
-        count = 0
-        scripts.group_by(&:code).each do |code, ranges|
-          next if code.nil? || code.empty?
-
-          path = Paths.script_metadata_path(@output_root, code)
-          count += 1 if write_atomic(path, script_payload(code, ranges))
-        end
-        count
-      end
-
-      def script_payload(code, ranges)
-        to_pretty_json(
-          "code"           => code,
-          "name"           => ranges.first&.name,
-          "range_first"    => ranges.map(&:range_first).min,
-          "range_last"     => ranges.map(&:range_last).max,
-          "codepoint_ids"  => (@script_codepoint_ids[code] || []),
-        )
-      end
-
-      # ---- Lookup indexes ---------------------------------------------
-
-      def write_indexes
-        count = 0
-        count += 1 if write_atomic(Paths.names_index_path(@output_root), to_pretty_json(@names_index))
-        count += 1 if write_atomic(Paths.labels_index_path(@output_root), to_pretty_json(@labels_index))
-        count += 1 if write_atomic(codepoint_to_block_path, to_pretty_json(@cp_to_block))
-        count
-      end
-
-      def codepoint_to_block_path
-        Pathname(@output_root).join("index", "codepoint_to_block.json")
-      end
-
-      # ---- Relationships ----------------------------------------------
-
-      def write_relationships(indices)
-        RELATIONSHIP_SOURCES.sum do |field, slug|
-          records = indices.public_send(field)
-          write_relationship_file(slug, records)
-        end
-      end
-
-      def write_relationship_file(slug, records)
-        return 0 if records.nil? || records.empty?
-
-        path = Pathname(@output_root).join("relationships", "#{slug}.json")
-        write_atomic(path, relationship_payload(records)) ? 1 : 0
-      end
-
-      # records is Hash<Integer, Record>, Hash<Integer, Array<Record>>,
-      # Hash<String, Record>, or Hash<String, Array<Record>>.
-      # Output: { "U+XXXX" => record.to_yaml_hash, ... } or
-      # { "U+XXXX" => [record.to_yaml_hash, ...], ... }
-      def relationship_payload(records)
-        payload = records.each_with_object({}) do |(key, value), h|
-          h[key_to_cp_id(key)] = serialize_value(value)
-        end
-        to_pretty_json(payload)
-      end
-
-      # Indices that are keyed by Integer codepoint (most of them) get
-      # formatted into "U+XXXX". Indices keyed by string ids already
-      # (cjk_radicals by ideograph_id, standardized_variants by base_id)
-      # are passed through verbatim.
-      def key_to_cp_id(key)
-        key.is_a?(Integer) ? Paths.cp_id(key) : key
-      end
-
-      def serialize_value(value)
-        return value.map { |v| serialize_one(v) } if value.is_a?(Array)
-
-        serialize_one(value)
-      end
-
-      def serialize_one(record)
-        record.to_yaml_hash
-      end
-
-      # ---- Enums -------------------------------------------------------
-
-      def write_enums(property_aliases, property_value_aliases)
-        path = Pathname(@output_root).join("enums.json")
-        payload = {
-          "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
-      end
-
-      # ---- Named sequences --------------------------------------------
-
-      def write_named_sequences(named_sequences)
-        return 0 if named_sequences.nil? || named_sequences.empty?
-
-        dir = Pathname(@output_root).join("named_sequences")
-        named_sequences.sum do |ns|
-          path = dir.join("#{slug_for(ns)}.json")
-          write_atomic(path, ns.to_json(pretty: true)) ? 1 : 0
-        end
-      end
-
-      # Slug derived from the name: downcase, non-alphanumerics → "_".
-      def slug_for(named_sequence)
-        named_sequence.name
-          .downcase
-          .gsub(/[^a-z0-9]+/, "_")
-          .gsub(/^_+|_+$/, "")
-      end
-
-      # ---- Manifest ---------------------------------------------------
-
-      # Fields that define the manifest's semantic content. When these
-      # match the existing manifest on disk, we preserve the old
-      # `generated_at` so that re-runs are byte-idempotent (no rewrite
-      # unless something actually changed).
-      MANIFEST_CONTENT_KEYS = %w[
-        ucd_version codepoint_count glyph_count schema_version
-      ].freeze
-      private_constant :MANIFEST_CONTENT_KEYS
-
-      def write_manifest(ucd_version:, glyph_count:)
-        path = Paths.manifest_path(@output_root)
-        content = {
-          "ucd_version"     => ucd_version,
-          "codepoint_count" => @codepoint_count,
-          "glyph_count"     => glyph_count,
-          "schema_version"  => "1",
-        }
-        ts = preserved_or_new_timestamp(path, content)
-        payload = content.merge("generated_at" => ts)
-        write_atomic(path, to_pretty_json(payload)) ? 1 : 0
-      end
-
-      def preserved_or_new_timestamp(path, content)
-        existing = read_manifest(path)
-        return Time.now.utc.iso8601 unless existing
-
-        unchanged = MANIFEST_CONTENT_KEYS.all? { |k| existing[k] == content[k] }
-        unchanged ? existing["generated_at"] : Time.now.utc.iso8601
-      end
-
-      def read_manifest(path)
-        return nil unless path.exist?
-
-        JSON.parse(path.read)
-      rescue JSON::ParserError
-        nil
-      end
     end
   end
-end
+end