ucode 0.2.0 → 0.2.2

data/lib/ucode/code_chart/extractor.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "ucode/error"
+require "ucode/glyphs/embedded_fonts/catalog"
+require "ucode/glyphs/embedded_fonts/renderer"
+require "ucode/glyphs/embedded_fonts/source"
+require "ucode/glyphs/resolver"
+require "ucode/glyphs/sources/pillar1_embedded_tounicode"
+require "ucode/glyphs/sources/tier1_real_font"
+
+module Ucode
+  module CodeChart
+    # Walks every assigned codepoint in a block and returns one
+    # {Result} per codepoint that any tier produced a glyph for.
+    #
+    # This is **not** a new extraction pipeline — it composes the
+    # existing {Ucode::Glyphs::Resolver} with per-block inputs
+    # (the block's Code Charts PDF + optionally Tier 1 and Pillar 3
+    # sources). The Resolver owns tier selection; the Extractor owns
+    # inputs.
+    #
+    # The REQ (R2) describes extraction via "locate the grid cell
+    # whose margin label matches the codepoint" — that was the v0.1
+    # retired approach (cell-border compositing). The current path
+    # is the embedded-font walk (Pillar 1, via {EmbeddedFonts::Catalog})
+    # with Pillar 2 (positional correlation) and Pillar 3 (Last Resort
+    # placeholders) as fallbacks.
+    #
+    # ## Tier selection
+    #
+    # Pillar 1 is always configured (the embedded font walk over the
+    # block's PDF). Tier 1 (real-font cmap) and Pillar 3 (Last
+    # Resort) are optional — the caller injects pre-built sources.
+    # This avoids forcing the Extractor to construct Last Resort
+    # eagerly, which would fail in environments where the UFO is
+    # not checked out.
+    class Extractor
+      # Result of extracting one codepoint.
+      Result = Struct.new(:codepoint, :svg, :tier, :provenance, keyword_init: true)
+
+      # @param block [Ucode::Models::Block] block whose assigned
+      #   codepoints will be extracted
+      # @param pdf_path [Pathname, String] path to the per-block
+      #   Code Charts PDF (downloaded by the caller; the Extractor
+      #   doesn't fetch)
+      # @param cache_dir [Pathname, String, nil] directory for
+      #   cached extracted font streams. nil = default
+      #   (data/pdf-fonts/ relative to the gem root).
+      # @param tier1_sources [Array<Ucode::Glyphs::Source>, nil]
+      #   optional Tier 1 sources (real-font cmap). nil = no Tier 1
+      # @param pillar3_source [Ucode::Glyphs::Source, nil] optional
+      #   Pillar 3 (Last Resort) source. nil = no Pillar 3 fallback.
+      #   Callers that want Last Resort placeholders inject the
+      #   pre-built source here.
+      def initialize(block:, pdf_path:, cache_dir: nil,
+                     tier1_sources: nil, pillar3_source: nil)
+        @block = block
+        @pdf_path = Pathname.new(pdf_path)
+        @cache_dir = cache_dir && Pathname.new(cache_dir)
+        @tier1_sources = tier1_sources || []
+        @pillar3_source = pillar3_source
+      end
+
+      # @return [Array<Result>] one Result per codepoint that any
+      #   tier produced a glyph for. Codepoints no tier can serve
+      #   are silently skipped (no Result yielded).
+      def extract
+        resolver = build_resolver
+        results = []
+        each_codepoint do |cp|
+          resolver_result = resolver.resolve(cp)
+          next unless resolver_result&.svg
+
+          results << Result.new(
+            codepoint: cp,
+            svg: resolver_result.svg,
+            tier: resolver_result.tier,
+            provenance: resolver_result.provenance,
+          )
+        end
+        results
+      end
+
+      private
+
+      # Yields every codepoint in the block's range in ascending
+      # order. We yield the whole range because the Resolver's
+      # tiers handle unassigned codepoints — Pillar 3 (when
+      # configured) maps every codepoint via its Format 13 cmap,
+      # so unassigned slots get a placeholder. With no Pillar 3
+      # injected, only assigned codepoints (those the embedded
+      # font actually covers) yield Results; the rest are silently
+      # skipped, satisfying the REQ's "skip unassigned codepoints".
+      def each_codepoint(&)
+        return enum_for(:each_codepoint) unless block_given?
+
+        (@block.range_first..@block.range_last).each(&)
+      end
+
+      def build_resolver
+        sources = @tier1_sources.dup
+        sources.concat(embedded_pillar_sources)
+        sources << @pillar3_source if @pillar3_source
+        order = sources.map(&:tier).uniq
+        Glyphs::Resolver.new(sources: sources, order: order)
+      end
+
+      def embedded_pillar_sources
+        embedded_source = Glyphs::EmbeddedFonts::Source.new(
+          pdf: @pdf_path, cache_dir: @cache_dir,
+        )
+        catalog = Glyphs::EmbeddedFonts::Catalog.new(embedded_source)
+        renderer = Glyphs::EmbeddedFonts::Renderer.new(catalog)
+        [Glyphs::Sources::Pillar1EmbeddedTounicode.new(renderer: renderer)]
+      end
+    end
+  end
+end

data/lib/ucode/code_chart/provenance.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "digest"
+require "time"
+
+require "ucode/version"
+
+module Ucode
+  module CodeChart
+    # Per-codepoint provenance value object — every field the REQ
+    # (R5) requires in the sidecar JSON next to each extracted SVG.
+    #
+    # Single source of truth for the provenance schema: the
+    # {Sidecar} writer reads this Struct, the Writer constructs it.
+    # Adding a field is one place to change.
+    #
+    # `extractor_version` reads from `Ucode::VERSION` at construction
+    # so the field stays in sync with the gem's version bump — single
+    # source of truth.
+    #
+    # `extracted_at` is the extraction event timestamp (UTC ISO8601),
+    # not the file-write timestamp.
+    Provenance = Struct.new(
+      :codepoint,
+      :block,
+      :source_pdf_url,
+      :source_pdf_sha256,
+      :ucd_version,
+      :extracted_at,
+      :extractor_version,
+      keyword_init: true,
+    )
+
+    # Computes the source PDF's URL from a block name and first
+    # codepoint. Mirrors the per-block URL convention in
+    # {Ucode::Fetch::CodeCharts}: the hex representation of the
+    # codepoint, zero-padded to a minimum of 4 digits (e.g.
+    # `U0000.pdf` for BMP, `U10920.pdf` for Plane 1,
+    # `U100000.pdf` for Plane 16 SPUA-B).
+    #
+    # @param block_first_cp [Integer]
+    # @return [String]
+    def self.code_chart_url(block_first_cp)
+      slug = block_first_cp.to_s(16).upcase.rjust(4, "0")
+      "#{Ucode.configuration.charts_base_url}/U#{slug}.pdf"
+    end
+
+    # Builds a Provenance from the inputs the {Writer} has on hand
+    # (block, codepoint, ucd_version, pdf_path). Computes the PDF
+    # hash + URL once. The `extracted_at` timestamp is fixed at
+    # call time so re-running the same block produces identical
+    # provenance JSON for unchanged codepoints.
+    #
+    # @param block [Ucode::Models::Block]
+    # @param codepoint [Integer]
+    # @param ucd_version [String]
+    # @param pdf_path [Pathname, String]
+    # @param now [Time, nil] override for tests
+    # @return [Provenance]
+    def self.build(block:, codepoint:, ucd_version:, pdf_path:, now: nil)
+      path = Pathname.new(pdf_path)
+      Provenance.new(
+        codepoint: format("U+%04X", codepoint),
+        block: block.id,
+        source_pdf_url: code_chart_url(block.range_first),
+        source_pdf_sha256: sha256_of(path),
+        ucd_version: ucd_version,
+        extracted_at: (now || Time.now.utc).iso8601,
+        extractor_version: Ucode::VERSION,
+      )
+    end
+
+    # @param path [Pathname]
+    # @return [String] hex digest, "" when the path doesn't exist
+    #   (callers can decide how to handle a missing hash)
+    def self.sha256_of(path)
+      return "" unless path.exist?
+
+      Digest::SHA256.file(path).hexdigest
+    end
+  end
+end

data/lib/ucode/code_chart/sidecar.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+
+require "ucode/repo/atomic_writes"
+
+module Ucode
+  module CodeChart
+    # Writes a {Provenance} to disk as the sidecar JSON next to its
+    # corresponding SVG.
+    #
+    # Path: `<output_root>/<codepoint>.json` — colocated with the
+    # SVG so a downstream consumer can find both files by a single
+    # directory listing.
+    #
+    # Idempotent via {Ucode::Repo::AtomicWrites#write_atomic}: a
+    # re-write of byte-identical content is a no-op (no temp-file
+    # rename). Provenance JSON is canonical (sorted keys via Ruby's
+    # stdlib JSON), so the byte-equality test is sound.
+    class Sidecar
+      include Ucode::Repo::AtomicWrites
+
+      # @param output_root [Pathname, String] directory the SVG +
+      #   sidecar live in. Parent directories are created on demand.
+      def initialize(output_root:)
+        @output_root = Pathname.new(output_root)
+      end
+
+      # @param provenance [Ucode::CodeChart::Provenance]
+      # @return [Pathname] the written sidecar path
+      def write(provenance)
+        path = path_for(provenance)
+        payload = "#{JSON.pretty_generate(provenance.to_h)}\n"
+        write_atomic(path, payload)
+        path
+      end
+
+      # @param codepoint_id [String] e.g. "U+10920"
+      # @return [Pathname] the would-be path for a sidecar
+      def path_for_id(codepoint_id)
+        @output_root.join("#{codepoint_id}.json")
+      end
+
+      private
+
+      def path_for(provenance)
+        path_for_id(provenance.codepoint)
+      end
+    end
+  end
+end

data/lib/ucode/code_chart/writer.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "digest"
+require "pathname"
+
+require "ucode/code_chart/extractor"
+require "ucode/code_chart/provenance"
+require "ucode/code_chart/sidecar"
+require "ucode/error"
+require "ucode/version_resolver"
+
+module Ucode
+  module CodeChart
+    # Orchestrates extraction + provenance sidecar writing for one
+    # block. The Writer is the **only thing that touches disk** in the
+    # CodeChart namespace; everything else is composition.
+    #
+    # Output layout (per block):
+    #
+    #     <output_root>/<block_id>/<U+XXXX>.svg
+    #     <output_root>/<block_id>/<U+XXXX>.json   # provenance sidecar
+    #
+    # One folder per block keeps each block's output self-contained
+    # and discoverable — a downstream consumer (fontisan) can iterate
+    # a block's folder without scanning the whole tree.
+    #
+    # Idempotent: re-running `write` on the same inputs produces
+    # byte-identical files (SVGs via content check; sidecars via
+    # {Ucode::Repo::AtomicWrites#write_atomic}'s canonical-JSON
+    # byte-equality). The {Summary} tally distinguishes "first run"
+    # writes from no-op re-writes.
+    class Writer
+      # Per-block run summary. Returned from {#write}.
+      Summary = Struct.new(
+        :block,
+        :codepoints_extracted,
+        :svgs_written,
+        :sidecars_written,
+        :pdf_sha256,
+        keyword_init: true,
+      )
+
+      # @param output_root [Pathname, String] parent directory. The
+      #   `<block_id>/` subdirectory is created inside it.
+      # @param pdf_path [Pathname, String] Code Charts PDF (already
+      #   downloaded by the caller; Writer doesn't fetch).
+      # @param ucd_version [String, nil] UCD version to stamp on
+      #   provenance. nil = resolved via {VersionResolver.resolve(nil)}.
+      # @param cache_dir [Pathname, String, nil] font-stream cache
+      #   directory for the EmbeddedFonts::Source.
+      # @param now [Time, nil] timestamp override (for tests).
+      # @param pillar3_source, tier1_sources: forwarded to the Extractor.
+      def initialize(output_root:, pdf_path:, ucd_version: nil,
+                     cache_dir: nil, now: nil,
+                     pillar3_source: nil, tier1_sources: nil)
+        @output_root = Pathname.new(output_root)
+        @pdf_path = Pathname.new(pdf_path)
+        @ucd_version = ucd_version || VersionResolver.resolve(nil)
+        @cache_dir = cache_dir && Pathname.new(cache_dir)
+        @now = now
+        @pillar3_source = pillar3_source
+        @tier1_sources = tier1_sources
+      end
+
+      # Extracts every codepoint in `block` and writes `<block_id>/<cp>.svg`
+      # + `<block_id>/<cp>.json` under `@output_root`. Returns a
+      # {Summary} tally.
+      #
+      # @param block [Ucode::Models::Block]
+      # @return [Summary]
+      def write(block)
+        block_dir = @output_root.join(block.id)
+        block_dir.mkpath
+
+        pdf_sha = CodeChart.sha256_of(@pdf_path)
+
+        sidecar = Sidecar.new(output_root: block_dir)
+        extractor = Extractor.new(
+          block: block,
+          pdf_path: @pdf_path,
+          cache_dir: @cache_dir,
+          pillar3_source: @pillar3_source,
+          tier1_sources: @tier1_sources,
+        )
+
+        results = extractor.extract
+        svgs = 0
+        sidecars = 0
+        results.each do |result|
+          write_svg(block_dir, result)
+          svgs += 1
+          provenance = CodeChart.build(
+            block: block, codepoint: result.codepoint,
+            ucd_version: @ucd_version, pdf_path: @pdf_path,
+            now: @now,
+          )
+          sidecar.write(provenance)
+          sidecars += 1
+        end
+
+        Summary.new(
+          block: block.id,
+          codepoints_extracted: results.size,
+          svgs_written: svgs,
+          sidecars_written: sidecars,
+          pdf_sha256: pdf_sha,
+        )
+      end
+
+      private
+
+      # Writes one SVG, skipping the write when the existing content
+      # is byte-identical (so mtime is preserved on idempotent
+      # re-runs — the Sidecar uses `Repo::AtomicWrites` for the same
+      # reason but at a different layer).
+      def write_svg(block_dir, result)
+        path = block_dir.join("#{format_cp(result.codepoint)}.svg")
+        return if path.exist? && path.read == result.svg
+
+        path.write(result.svg)
+      end
+
+      def format_cp(codepoint)
+        "U+#{codepoint.to_s(16).upcase.rjust(4, '0')}"
+      end
+    end
+  end
+end

data/lib/ucode/code_chart.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Ucode
+  # CodeChart — per-codepoint SVG glyph extraction from Unicode Code
+  # Charts PDFs.
+  #
+  # The "Code Chart donor" use case (essenfont consumer): for blocks
+  # where no OFL real-font covers the glyphs (Sidetic in Unicode 17,
+  # Egyptian Hieroglyphs Extended-B), the only canonical source is
+  # the Unicode Consortium's Code Chart PDF. This namespace turns one
+  # such PDF into a tree of standalone SVG files plus provenance
+  # sidecar JSON.
+  #
+  # ## Architecture (MECE)
+  #
+  # Every concern has exactly one home:
+  #
+  #   * **Block metadata** (range + assigned codepoints) — Parsers::Blocks
+  #   * **PDF download + cache** — Fetch::CodeCharts + Glyphs::PdfFetcher
+  #   * **PDF object-graph walk + font extraction** — Glyphs::EmbeddedFonts::*
+  #   * **Tier selection (Pillar 1 / 2 / 3)** — Glyphs::Resolver
+  #   * **SVG conversion + y-flip + viewBox** — Glyphs::EmbeddedFonts::Svg
+  #   * **Provenance schema** — CodeChart::Provenance (this namespace)
+  #   * **Sidecar JSON write** — CodeChart::Sidecar (this namespace)
+  #   * **Per-block orchestration + idempotent disk write** — CodeChart::Writer
+  #   * **CLI dispatch** — Cli::CodeChartCmd
+  #
+  # CodeChart::* is the feature-facing namespace. It does not
+  # implement extraction, font parsing, or PDF I/O — it composes
+  # the existing infrastructure. Replacing the implementation
+  # (e.g. a future pure-Ruby PDF parser per ADR-0001) does not
+  # change the public API.
+  module CodeChart
+    autoload :Extractor, "ucode/code_chart/extractor"
+    autoload :Provenance, "ucode/code_chart/provenance"
+    autoload :Sidecar, "ucode/code_chart/sidecar"
+    autoload :Writer, "ucode/code_chart/writer"
+  end
+end

data/lib/ucode/commands/fetch.rb

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

data/lib/ucode/commands/glyphs.rb

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

data/lib/ucode/commands/lookup.rb

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

data/lib/ucode/commands/parse.rb

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

data/lib/ucode/coordinator/indices.rb

@@ -69,7 +69,7 @@ module Ucode
       #   `output/relationships/`
       # @yieldparam records [Hash<Integer|String, Record|Array<Record>>]
       # @return [Enumerator] when no block is given
-      def each_relationship(&block)
+      def each_relationship(&)
         return enum_for(:each_relationship) unless block_given?
 
         RELATIONSHIPS.each do |slug, field|
@@ -78,4 +78,4 @@ module Ucode
       end
     end
   end
-end
+end

data/lib/ucode/error.rb

@@ -97,6 +97,10 @@ module Ucode
   # Version string not in Config.known_versions.
   class UnknownVersionError < LookupError; end
 
+  # Block identifier not present in the cached Blocks.txt. Carries the
+  # offending id and the path searched in `context:`.
+  class UnknownBlockError < LookupError; end
+
   # Glyph pipeline failures.
   class GlyphError < Error; end
 
@@ -114,6 +118,13 @@ module Ucode
   # `mutool` is not installed on the PATH.
   class EmbeddedFontsMissingError < GlyphError; end
 
+  # The Code Charts PDF for a requested block cannot be obtained: the
+  # network returned 4xx/5xx, the response wasn't application/pdf, or
+  # the body didn't start with the `%PDF` magic. Distinct from
+  # {EmbeddedFontsMissingError} (which fires when the file is already
+  # on disk and we just can't open it): this fires at fetch time.
+  class CodeChartNotFoundError < GlyphError; end
+
   # Pre-build validation failed for a universal-set build. The
   # context carries the failing checks so the CLI can render a
   # useful diagnostic without re-running them. Distinct from

data/lib/ucode/fetch/code_charts.rb

@@ -6,7 +6,7 @@ module Ucode
     #
     # URL pattern: `https://www.unicode.org/charts/PDF/U<XXXX>.pdf`
     # where `XXXX` is the block's first codepoint zero-padded to 4 digits
-    # (5–6 digits for planes > 0).
+    # (5 digits for planes > 0).
     module CodeCharts
       class << self
         # @param version [String] used as the on-disk path namespace; PDFs
@@ -29,7 +29,7 @@ module Ucode
             next if dest.exist? && !force
 
             url = "#{Ucode.configuration.charts_base_url}/#{filename}"
-            Http.get(url, dest: dest)
+            Http.get(url, dest: dest, validate: :pdf)
             downloaded += 1
           end
           downloaded
@@ -48,8 +48,7 @@ module Ucode
         private
 
         def hex_pad(codepoint)
-          width = codepoint > 0xFFFF ? 6 : 4
-          codepoint.to_s(16).upcase.rjust(width, "0")
+          codepoint.to_s(16).upcase.rjust(4, "0")
         end
       end
     end

data/lib/ucode/fetch/http.rb

@@ -23,9 +23,17 @@ module Ucode
         #   directory is created if absent.
         # @param retries [Integer, nil] override Config.http_retries.
         # @param timeout [Integer, nil] override Config.http_timeout.
+        # @param validate [Symbol, nil] when `:pdf`, after a successful
+        #   download verify (a) Content-Type starts with `application/pdf`
+        #   and (b) the first 4 bytes of the body are `%PDF`. Raises
+        #   {Ucode::CodeChartNotFoundError} with the offending header
+        #   value in `context:` on failure. nil = no validation (the
+        #   default for non-PDF callers like UcdZip and UnihanZip).
         # @return [Pathname] destination path on success.
         # @raise [Ucode::NetworkError] if all retries fail.
-        def get(url, dest:, retries: nil, timeout: nil)
+        # @raise [Ucode::CodeChartNotFoundError] when `validate: :pdf`
+        #   and the response fails content validation.
+        def get(url, dest:, retries: nil, timeout: nil, validate: nil)
           uri = url.is_a?(URI) ? url : URI(url)
           destination = Pathname.new(dest)
           destination.dirname.mkpath
@@ -36,7 +44,11 @@ module Ucode
 
           last_error = nil
           (attempts + 1).times do |attempt|
-            return stream_to(uri, destination, read_timeout)
+            response = stream_to(uri, destination, read_timeout)
+            validate_response!(validate, response, destination) if validate
+            return destination
+          rescue ValidationFailure => e
+            raise e.cause
           rescue StandardError => e
             last_error = e
             sleep_for = backoff_sequence[attempt] || backoff_sequence.last
@@ -55,19 +67,34 @@ module Ucode
 
         private
 
+        # Internal carrier for a validation failure inside a retry
+        # attempt. Re-raised from the loop so the response body (which
+        # is partial on retries) isn't double-validated against
+        # truncated bytes.
+        class ValidationFailure < StandardError
+          attr_reader :cause
+
+          def initialize(cause)
+            @cause = cause
+            super(cause.message)
+          end
+        end
+
         def stream_to(uri, destination, read_timeout)
+          response = nil
           Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
                                               read_timeout: read_timeout) do |http|
             request = Net::HTTP::Get.new(uri)
-            http.request(request) do |response|
-              unless response.is_a?(Net::HTTPSuccess)
-                raise "HTTP #{response.code} #{response.message}"
+            http.request(request) do |r|
+              unless r.is_a?(Net::HTTPSuccess)
+                raise "HTTP #{r.code} #{r.message}"
               end
 
-              write_body(response, destination)
+              write_body(r, destination)
+              response = r
             end
           end
-          destination
+          response or raise "no response received"
         end
 
         def write_body(response, destination)
@@ -77,6 +104,47 @@ module Ucode
           end
           File.rename(partial.to_s, destination.to_s)
         end
+
+        # Verifies Content-Type and magic bytes for a downloaded file.
+        # Raises ValidationFailure carrying a CodeChartNotFoundError so
+        # the retry loop in `get` doesn't re-attempt a download that's
+        # structurally invalid (only the transport is retriable).
+        def validate_response!(mode, response, destination)
+          case mode
+          when :pdf then validate_pdf!(response, destination)
+          else raise ArgumentError, "unknown validate mode: #{mode.inspect}"
+          end
+        end
+
+        PDF_CONTENT_TYPE_PREFIX = "application/pdf"
+        PDF_MAGIC = "%PDF"
+        private_constant :PDF_CONTENT_TYPE_PREFIX, :PDF_MAGIC
+
+        def validate_pdf!(response, destination)
+          content_type = response["Content-Type"].to_s
+          unless content_type.start_with?(PDF_CONTENT_TYPE_PREFIX)
+            raise ValidationFailure.new(
+              Ucode::CodeChartNotFoundError.new(
+                "expected Content-Type application/pdf, got #{content_type.inspect}",
+                context: { url: response.uri.to_s, content_type: content_type },
+              ),
+            )
+          end
+
+          # Re-open the destination file and peek at the first 4 bytes.
+          # The response body has already been written to disk by
+          # `stream_to`; we don't re-read from the response (which is
+          # consumed by then).
+          magic = File.open(destination, "rb") { |f| f.read(4) }
+          unless magic == PDF_MAGIC
+            raise ValidationFailure.new(
+              Ucode::CodeChartNotFoundError.new(
+                "expected %PDF magic bytes, got #{magic.inspect}",
+                context: { url: response.uri.to_s, magic: magic },
+              ),
+            )
+          end
+        end
       end
     end
   end

data/lib/ucode/glyphs/page_renderer.rb

@@ -70,9 +70,22 @@ module Ucode
           raise NotImplementedError
         end
 
-        # @return [Boolean] true if the binary is on PATH
+        # @return [Boolean] true if the binary is on PATH. Returns
+        #   false on hosts without `which`/`where` or where the
+        #   binary isn't installed — the next renderer in
+        #   KNOWN_RENDERERS is tried.
         def available?
-          system("which", binary_name.to_s, out: "/dev/null", err: "/dev/null")
+          if Gem.win_platform?
+            # `where` returns the first match path; exit status 0
+            # means the binary is found. Suppress stdout/stderr to
+            # avoid polluting test output.
+            system("where #{binary_name} >NUL 2>NUL")
+          else
+            system("which", binary_name.to_s,
+                   out: "/dev/null", err: "/dev/null")
+          end
+        rescue Errno::ENOENT, Errno::EINVAL
+          false
         end
 
         # Smoke-test the binary by actually rendering one page of the

data/lib/ucode/glyphs/pipeline.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "pathname"
-require "set"
 
 require "ucode/cache"
 require "ucode/glyphs/pdf_fetcher"
@@ -103,4 +102,4 @@ module Ucode
       end
     end
   end
-end
+end