fontisan 0.4.46 → 0.4.48

data/README.adoc

@@ -53,6 +53,38 @@ command mappings and usage examples.
   round-trip. See link:docs/TYPE1_FONTS.adoc[Type 1 Fonts Guide].
 
 
+== Engine
+
+Fontisan can serve its read, audit, scan, convert, extract, instance and subset
+operations from three tiers: `native` (a precompiled Rust extension), `ffi` (the
+bundled Rust shared library, loaded through the `ffi` gem) and `ruby` (the pure
+Ruby implementation, always present).
+
+The default is `auto`: the first available tier wins, in the order
+`native`, `ffi`, `ruby`. An operation a tier cannot serve goes to the next one.
+Installed from the source gem on a machine with no Rust toolchain and no
+bundled library, `auto` serves everything from `ruby`, with no warning and
+no error.
+
+[cols="1,3"]
+|===
+|Variable |Effect
+
+|`FONTISAN_ENGINE=auto\|native\|ffi\|ruby`
+|Pick the tier. Unset or empty means `auto`. `ruby` never uses the Rust tiers.
+A forced tier that is not available falls back to `ruby`.
+
+|`FONTISAN_ENGINE_STRICT=1`
+|No fallback: a forced tier that is not available raises
+`Fontisan::Engine::TierUnavailable` at setup. `1`, `true`, `yes` and `on` enable it;
+unset, empty, `0`, `false`, `no` and `off` leave it off; any other value raises
+`Fontisan::Engine::ConfigError`.
+|===
+
+`Fontisan::Engine.served_by(:read)` reports which tier served the last call of
+an operation. See link:docs/guide/engines.md[Engines] for tiers, platforms and
+troubleshooting.
+
 == Installation
 
 Add this line to your application's Gemfile:
@@ -2734,6 +2766,26 @@ bundle exec rake fixtures:clean     # Remove downloaded fonts
 ----
 
 
+=== Reference corpus and benchmarks
+
+`corpus/` holds the golden outputs of the pure-Ruby engine (fontist/fontisan#157).
+The fonts themselves are not in git: `corpus/manifest.json` pins each source
+by URL and SHA-256, and `rake corpus:fetch` downloads and verifies them into
+`corpus/fonts/`. `corpus:verify` and `bench` run the fetch themselves, so a
+fresh clone needs no manual step.
+
+[source,shell]
+----
+bundle exec rake corpus:fetch    # download + checksum the ci tier (TIER=ci|large|all)
+bundle exec rake corpus:verify   # compare read goldens; never writes
+bundle exec rake bench           # run the benches, print the report, write BENCHMARKS.md
+----
+
+Goldens are compared, never regenerated, by the tests. `corpus:regenerate` is
+the one explicit rewrite and belongs in a PR that shows the golden diff.
+Baseline numbers are in link:BENCHMARKS.md[BENCHMARKS.md]; the `Perf Gate`
+workflow fails a PR that makes an operation more than 25% slower than its base.
+
 == Copyright and license
 
 Copyright https://www.ribose.com[Ribose].

data/Rakefile

@@ -146,7 +146,11 @@ namespace :fixtures do
 end
 
 # RSpec task depends on fixtures
-RSpec::Core::RakeTask.new(spec: "fixtures:download")
+# Corpus specs need `rake corpus:fetch` and run in the corpus workflow
+# (.github/workflows/corpus.yml), not in the default suite.
+RSpec::Core::RakeTask.new(spec: "fixtures:download") do |t|
+  t.exclude_pattern = "spec/corpus/**/*_spec.rb"
+end
 
 # Default task runs spec and rubocop
 task default: %i[spec rubocop]

data/benchmark/baseline.json

@@ -0,0 +1,5 @@
+{
+  "schema": 1,
+  "reference_commit": "d6bc12ad648e7a3fcca58fb3d2d0139091135c87",
+  "note": "fontisan main at d6bc12a (Phase 0), the first commit with Fontisan::Reference, so every bench op can run on it. The weekly gate compares head with this commit in one job and fails on an op the commit cannot run (NO-BASE). Move it deliberately in a reviewed change."
+}

data/benchmark/ci_gate.rb

@@ -0,0 +1,217 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Performance gate for the reference corpus benches (fontist/fontisan#157).
+#
+#   --mode pr      base (--base REF) vs head (--head REF, default HEAD), same
+#                  job, interleaved. This is the per-PR check.
+#   --mode weekly  head vs the pinned reference commit in benchmark/baseline.json,
+#                  same job (ratios, never absolute times). A missing or
+#                  unreachable reference fails, and so does an op the
+#                  reference cannot run (NO-BASE): move reference_commit
+#                  to a commit that can run every op.
+#   --mode tiers   ruby vs native vs ffi (FONTISAN_ENGINE, strict) on the working
+#                  tree, same job, interleaved. Hard floor (#160): native must be
+#                  at least as fast as ruby on audit_file, audit_dir and scan_dir
+#                  and its scan peak RSS must not exceed ruby's (3% tolerance).
+#                  Regression gate: native factors must stay within 25% of
+#                  benchmark/tier_baseline.json for --platform (default
+#                  Gem::Platform.local; no entry = floor only). With --write FILE the
+#                  factor table is written into the "Engine tier factors"
+#                  section of FILE (BENCHMARKS.md), tagged with --label.
+#   --mode report  head only (working tree); prints the report and, with
+#                  --write FILE, writes BENCHMARKS.md. Used by `rake bench`.
+#
+# Each side is a `git archive` copy with its own bundle. Ops the base cannot
+# run (e.g. Fontisan::Reference before it exists) are reported "new", not
+# compared. Exit 0 pass, 1 regression, 2 error.
+#
+# FONTISAN_BENCH_SLOWDOWN=2 slows only the head side 2x (gate self-test);
+# with FONTISAN_BENCH_SLOWDOWN_TIER=native only the native tier is slowed.
+
+require "json"
+require "optparse"
+require "etc"
+require "time"
+require_relative "corpus/harness"
+require_relative "corpus/tiers"
+
+module FontisanBench
+  # Command line front end.
+  class Gate
+    ROOT = File.expand_path("..", __dir__)
+    HARNESS = File.join(__dir__, "corpus")
+    BASELINE = File.join(__dir__, "baseline.json")
+    FACTORS_HEADING = "## Engine tier factors"
+    FACTORS_SECTION = /^#{FACTORS_HEADING}.*?(?=^## |\z)/m
+    FACTORS_TAIL = /^#{FACTORS_HEADING}.*/m
+
+    def initialize(argv)
+      @opts = { mode: "pr", head: "HEAD", rounds: 5, tolerance: 0.25,
+                corpus: File.join(ROOT, "corpus") }
+      OptionParser.new do |o|
+        o.on("--mode MODE") { |v| @opts[:mode] = v }
+        o.on("--base REF") { |v| @opts[:base] = v }
+        o.on("--head REF") { |v| @opts[:head] = v }
+        o.on("--rounds N", Integer) { |v| @opts[:rounds] = v }
+        o.on("--tolerance F", Float) { |v| @opts[:tolerance] = v }
+        o.on("--corpus DIR") { |v| @opts[:corpus] = v }
+        o.on("--baseline FILE") { |v| @opts[:baseline] = v }
+        o.on("--save FILE") { |v| @opts[:save] = v }
+        o.on("--write FILE") { |v| @opts[:write] = v }
+        o.on("--label TEXT") { |v| @opts[:label] = v }
+        o.on("--platform NAME") { |v| @opts[:platform] = v }
+        o.on("--tier-baseline FILE") { |v| @opts[:tier_baseline] = v }
+      end.parse!(argv)
+    end
+
+    def call
+      return report if @opts[:mode] == "report"
+      return tiers if @opts[:mode] == "tiers"
+
+      Dir.mktmpdir("fontisan-gate") { |work| compare(work) }
+    rescue Error => e
+      warn "ERROR: #{e.message}"
+      2
+    end
+
+    private
+
+    def compare(work)
+      base_ref = @opts[:mode] == "weekly" ? reference_commit : @opts[:base]
+      raise Error, "--base REF is required for --mode pr" unless base_ref
+
+      sides = [Side.from_ref("base", base_ref, root: ROOT, workdir: work),
+               Side.from_ref("head", @opts[:head], root: ROOT, workdir: work)]
+      m = Measurement.interleave(sides, rounds: @opts[:rounds], harness_dir: HARNESS, corpus: @opts[:corpus])
+      rows = Compare.rows(m, tolerance: @opts[:tolerance], strict: @opts[:mode] == "weekly")
+      rows = confirm(m, sides, rows)
+      title = @opts[:mode] == "weekly" ? "Perf gate: head vs pinned reference" : "Perf gate: head vs base"
+      puts Compare.markdown(rows, title: "#{title} (#{sides[0].ref[0, 8]} -> #{sides[1].ref[0, 8]})",
+                                  tolerance: @opts[:tolerance], rounds: @opts[:rounds])
+      save(m, rows, sides)
+      Compare.failed?(rows) ? 1 : 0
+    end
+
+    # A shared runner is noisy: ops that look regressed are re-measured in
+    # the same job (more interleaved rounds, medians over all rounds) and only
+    # fail if they still regress.
+    def confirm(measure, sides, rows)
+      suspects = rows.select { |r| r.status == "REGRESSION" }.map(&:metric)
+      return rows if suspects.empty?
+
+      ops = suspects - ["scan_peak_rss_kb"]
+      ops = ["scan_dir"] if ops.empty?
+      warn "confirming #{suspects.join(', ')} with #{@opts[:rounds]} more rounds"
+      Measurement.interleave(sides, rounds: @opts[:rounds], harness_dir: HARNESS,
+                                    corpus: @opts[:corpus], only: ops, into: measure)
+      Compare.rows(measure, tolerance: @opts[:tolerance], strict: @opts[:mode] == "weekly")
+    end
+
+    def tiers
+      sides = Tiers.sides(ROOT)
+      args = { harness_dir: HARNESS, corpus: @opts[:corpus] }
+      m = Tiers.measure(sides, rounds: @opts[:rounds], **args)
+      baseline = tier_baseline
+      rows = Tiers.rows(m, baseline: baseline)
+      if Tiers.failed?(rows)
+        warn "confirming with #{@opts[:rounds]} more rounds"
+        Tiers.measure(sides, rounds: @opts[:rounds], into: m, **args)
+        rows = Tiers.rows(m, baseline: baseline)
+      end
+      text = Tiers.markdown(rows, title: "Perf gate: engine tiers (#{@opts[:label] || runner_description})",
+                                  rounds: @opts[:rounds])
+      puts text
+      write_factors(text)
+      save(m, [], sides)
+      Tiers.failed?(rows) ? 1 : 0
+    end
+
+    # The committed expected factors for --platform (default: this Ruby's).
+    def tier_baseline
+      Tiers.baseline(@opts[:platform] || Gem::Platform.local.to_s,
+                     file: @opts[:tier_baseline] || Tiers::BASELINE_FILE)
+    end
+
+    def write_factors(text)
+      return unless @opts[:write]
+
+      file = @opts[:write]
+      body = File.exist?(file) ? File.read(file) : ""
+      section = "#{FACTORS_HEADING}\n\n#{factors_section(text)}\n"
+      body = body.sub(FACTORS_SECTION, "").rstrip
+      File.write(file, "#{body}\n\n#{section}")
+    end
+
+    def factors_section(text)
+      lines = text.lines.map(&:chomp).drop(1) # drop the "## title" line
+      ["- Ruby: #{RUBY_VERSION} (#{RUBY_PLATFORM}); #{@opts[:label] || runner_description}",
+       "- fontisan SHA: `#{Side.capture('git', 'rev-parse', 'HEAD', chdir: ROOT).strip}`", *lines].join("\n").rstrip
+    end
+
+    def reference_commit
+      file = @opts[:baseline] || BASELINE
+      raise Error, "reference baseline #{file} is missing" unless File.exist?(file)
+
+      ref = JSON.parse(File.read(file))["reference_commit"].to_s
+      raise Error, "#{file} has no reference_commit" if ref.empty?
+
+      ref
+    end
+
+    def report
+      head = Side.new("head", ROOT, ref: Side.capture("git", "rev-parse", "HEAD", chdir: ROOT).strip)
+      m = Measurement.interleave([head], rounds: @opts[:rounds], harness_dir: HARNESS, corpus: @opts[:corpus])
+      text = report_markdown(m, head)
+      puts text
+      File.write(@opts[:write], text + kept_factors) if @opts[:write]
+      save(m, [], [head])
+      0
+    end
+
+    # `rake bench` regenerates the file; the tier factor table (written by
+    # --mode tiers) is carried over.
+    def kept_factors
+      return "" unless File.exist?(@opts[:write])
+
+      kept = File.read(@opts[:write])[FACTORS_TAIL]
+      kept ? "\n#{kept.rstrip}\n" : ""
+    end
+
+    def report_markdown(measure, head)
+      dirty = Side.capture("git", "status", "--porcelain", "--", "lib", chdir: ROOT).strip.empty? ? "" : "+dirty"
+      lines = ["# Benchmarks", "",
+               "Reference corpus `ci` tier benches for the #157 operations (`rake bench`).", "",
+               "- fontisan SHA: `#{head.ref}#{dirty}`",
+               "- Ruby: #{RUBY_VERSION} (#{RUBY_PLATFORM})",
+               "- Runner: #{runner_description}",
+               "- Rounds: #{@opts[:rounds]} (median per op); each op is the fastest of repeated calls " \
+               "(at least 3 calls or 0.25 s of measured time)", "",
+               "| operation | median |", "|---|---|"]
+      measure.op_names.each { |op| lines << "| #{op} | #{Compare.fmt(op, measure.median_op('head', op))} |" }
+      lines << "| scan_peak_rss (directory scan) | #{Compare.fmt('scan_peak_rss_kb', measure.median_rss('head'))} |"
+      "#{lines.join("\n")}\n"
+    end
+
+    def runner_description
+      cpu = if RUBY_PLATFORM.include?("darwin")
+              Side.capture("sysctl", "-n", "machdep.cpu.brand_string").strip
+            else
+              File.foreach("/proc/cpuinfo").grep(/model name/).first.to_s.split(":", 2).last.to_s.strip
+            end
+      "#{ENV.fetch('RUNNER_OS', RbConfig::CONFIG['host_os'])}, #{cpu}, #{Etc.nprocessors} cores"
+    rescue StandardError
+      RbConfig::CONFIG["host_os"]
+    end
+
+    def save(measure, rows, sides)
+      return unless @opts[:save]
+
+      data = { "sides" => sides.to_h { |s| [s.name, s.ref] }, "runs" => measure.runs,
+               "rows" => rows.map(&:to_h) }
+      File.write(@opts[:save], JSON.pretty_generate(data))
+    end
+  end
+end
+
+exit FontisanBench::Gate.new(ARGV).call if $PROGRAM_NAME == __FILE__

data/benchmark/corpus/harness.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "open3"
+require "rbconfig"
+require "tmpdir"
+
+module FontisanBench
+  class Error < StandardError; end
+
+  # One copy of fontisan to measure, with its own bundle.
+  class Side
+    attr_reader :name, :dir, :ref
+
+    # @param name [String] "base" or "head"
+    # @param dir [String] checkout directory (own Gemfile)
+    def initialize(name, dir, ref: nil)
+      @name = name
+      @dir = dir
+      @ref = ref
+    end
+
+    # `git archive REF` into a fresh directory with its own bundle. A git
+    # archive has no .git, so the gemspec lists no files but still loads, and
+    # nothing here relies on exe/.
+    def self.from_ref(name, ref, root:, workdir:)
+      sha = capture("git", "rev-parse", "--verify", "#{ref}^{commit}", chdir: root).strip
+      dir = File.join(workdir, name)
+      FileUtils.mkdir_p(dir)
+      archive = File.join(workdir, "#{name}.tar")
+      run!("git", "archive", "--format=tar", "-o", archive, sha, chdir: root)
+      run!("tar", "-xf", archive, "-C", dir)
+      lock = File.join(root, "Gemfile.lock")
+      FileUtils.cp(lock, dir) if File.exist?(lock)
+      side = new(name, dir, ref: sha)
+      side.bundle_install
+      side
+    end
+
+    def self.capture(*cmd, chdir: nil)
+      out, err, st = Open3.capture3(*cmd, chdir: chdir || Dir.pwd)
+      raise Error, "#{cmd.join(' ')} failed: #{err}" unless st.success?
+
+      out
+    end
+
+    def self.run!(*cmd, chdir: nil, env: {})
+      out, st = Open3.capture2e(env, *cmd, chdir: chdir || Dir.pwd)
+      raise Error, "#{cmd.join(' ')} failed:\n#{out}" unless st.success?
+
+      out
+    end
+
+    def env
+      { "BUNDLE_GEMFILE" => File.join(dir, "Gemfile"), "BUNDLE_FROZEN" => "false",
+        "BUNDLE_DEPLOYMENT" => "false" }
+    end
+
+    def bundle_install
+      self.class.run!("bundle", "install", "--quiet", env: env, chdir: dir)
+    end
+
+    # One process: every op once-per-calibration, JSON result.
+    def run_once(harness_dir, corpus, only: nil)
+      cmd = ["bundle", "exec", RbConfig.ruby, File.join(harness_dir, "run.rb"),
+             "--corpus", corpus, "--side", name]
+      cmd += ["--only", only.join(",")] if only
+      out, err, st = Open3.capture3(env, *cmd, chdir: dir)
+      raise Error, "bench run on #{name} failed:\n#{err}" unless st.success?
+
+      JSON.parse(out.lines.reverse_each.find { |l| l.start_with?("{") })
+    end
+  end
+
+  # Interleaved rounds over two (or one) sides, median per metric.
+  class Measurement
+    METRICS_RSS = "scan_peak_rss_kb"
+
+    attr_reader :runs
+
+    def initialize
+      @runs = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def record(side_name, result)
+      @runs[side_name] << result
+    end
+
+    def op_names
+      @runs.values.flatten.flat_map { |r| r["ops"].keys }.uniq
+    end
+
+    def median_op(side, name)
+      median(@runs[side].map { |r| r["ops"][name] })
+    end
+
+    def median_rss(side)
+      median(@runs[side].map { |r| r[METRICS_RSS] })
+    end
+
+    def median(values)
+      v = values.compact.sort
+      return nil if v.empty?
+
+      mid = v.size / 2
+      v.size.odd? ? v[mid] : (v[mid - 1] + v[mid]) / 2.0
+    end
+
+    # Round i runs the sides in alternating order, so drift (thermal, noisy
+    # neighbours) hits both sides alike.
+    def self.interleave(sides, rounds:, harness_dir:, corpus:, log: $stderr, only: nil, into: nil)
+      m = into || new
+      rounds.times do |i|
+        order = i.even? ? sides : sides.reverse
+        order.each do |side|
+          log.puts "round #{i + 1}/#{rounds}: #{side.name}"
+          m.record(side.name, side.run_once(harness_dir, corpus, only: only))
+        end
+      end
+      m
+    end
+  end
+
+  # base vs head verdicts.
+  module Compare
+    Row = Struct.new(:metric, :base, :head, :ratio, :status, keyword_init: true)
+
+    module_function
+
+    # `strict` (weekly mode): the pinned reference must be able to run every
+    # op, so an op with no base number is "NO-BASE" and fails instead of "new".
+    def rows(measure, tolerance:, strict: false)
+      ops = measure.op_names.map do |op|
+        row(op, measure.median_op("base", op), measure.median_op("head", op), tolerance, strict: strict)
+      end
+      ops << row("scan_peak_rss_kb", measure.median_rss("base"), measure.median_rss("head"), tolerance, strict: strict)
+      ops
+    end
+
+    def row(metric, base, head, tolerance, strict: false)
+      return Row.new(metric: metric, base: base, head: head, status: "n/a") if head.nil? && base.nil?
+      return Row.new(metric: metric, base: base, head: head, status: "MISSING-ON-HEAD") if head.nil?
+      return Row.new(metric: metric, base: base, head: head, status: strict ? "NO-BASE" : "new") if base.nil?
+
+      ratio = head.to_f / base
+      Row.new(metric: metric, base: base, head: head, ratio: ratio,
+              status: ratio > 1 + tolerance ? "REGRESSION" : "ok")
+    end
+
+    def failed?(rows)
+      rows.any? { |r| %w[REGRESSION MISSING-ON-HEAD NO-BASE].include?(r.status) }
+    end
+
+    def markdown(rows, title:, tolerance:, rounds:)
+      out = ["## #{title}", "",
+             "Median of #{rounds} interleaved rounds; fails when head is more than " \
+             "#{(tolerance * 100).round}% slower than base.", "",
+             "| metric | base | head | head/base | status |", "|---|---|---|---|---|"]
+      rows.each do |r|
+        out << "| #{r.metric} | #{fmt(r.metric, r.base)} | #{fmt(r.metric, r.head)} | " \
+               "#{r.ratio ? format('%.2fx', r.ratio) : '-'} | #{r.status} |"
+      end
+      out << ""
+      out << (failed?(rows) ? "**RESULT: FAIL**" : "**RESULT: PASS**")
+      out.join("\n")
+    end
+
+    def fmt(metric, value)
+      return "-" if value.nil?
+
+      metric.end_with?("_kb") ? "#{(value / 1024.0).round(1)} MB" : format("%.1f ms", value * 1000)
+    end
+  end
+end

data/benchmark/corpus/ops.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+module FontisanBench
+  # One benchmarked operation. `requires` lists the constants the measured
+  # fontisan must define; an operation the measured tree cannot run is
+  # skipped, which the comparison reports as "new" (it has no base number).
+  Op = Struct.new(:name, :description, :requires, :body, keyword_init: true)
+
+  # The #157 operations, run against the `ci` tier of the reference corpus
+  # (corpus/fonts, fetched by `rake corpus:fetch`).
+  #
+  # Table parse, names, cmap, instancing and conversion call the classes the
+  # reference facade wraps, so the same code runs on a base that predates
+  # `Fontisan::Reference`; audit, audit_dir and scan go through the facade.
+  class Ops
+    SS_TTF = "source-sans-3-regular-ttf/SourceSans3-Regular.ttf"
+    SS_OTF = "source-sans-3-regular-otf/SourceSans3-Regular.otf"
+    SS_WOFF = "source-sans-3-regular-ttf-woff/SourceSans3-Regular.ttf.woff"
+    SS_WOFF2 = "source-sans-3-regular-ttf-woff2/SourceSans3-Regular.ttf.woff2"
+    SS_VF = "source-sans-3-vf-upright-ttf/SourceSans3VF-Upright.ttf"
+    NOTO = "noto-sans-hinted-regular/NotoSans-Regular.ttf"
+    TABLE_PARSE_FONTS = [SS_TTF, SS_OTF, NOTO].freeze
+    NAME_FONTS = [SS_TTF, SS_OTF, SS_VF, NOTO].freeze
+
+    attr_reader :corpus
+
+    def initialize(corpus)
+      @corpus = File.expand_path(corpus)
+      @fonts_dir = File.join(@corpus, "fonts")
+    end
+
+    def all
+      [table_parse, hmtx_metrics, names, cmap_coverage, audit_file, audit_dir, scan,
+       vf_instance, woff2_decode, convert_roundtrip, woff2_encode]
+    end
+
+    def scan_paths
+      Dir.glob(File.join(@fonts_dir, "**", "*")).select { |f| File.file?(f) }.sort
+    end
+
+    private
+
+    def font(rel)
+      File.join(@fonts_dir, rel)
+    end
+
+    def load_full(rel)
+      Fontisan::FontLoader.load(font(rel), mode: :full, lazy: false)
+    end
+
+    def op(name, description, requires: [], &body)
+      Op.new(name: name, description: description, requires: requires, body: body)
+    end
+
+    def table_parse
+      op("table_parse", "load (full) and parse every table of 3 static fonts") do
+        TABLE_PARSE_FONTS.each do |rel|
+          f = load_full(rel)
+          f.table_names.each { |tag| f.table(tag) }
+        end
+      end
+    end
+
+    # Tables::Hmtx#metric_for is the per-glyph metric lookup; table_parse only
+    # parses the table, so a slowdown inside the lookup was invisible.
+    def hmtx_metrics
+      op("hmtx_metrics", "hmtx metric_for every glyph of 3 static fonts") do
+        TABLE_PARSE_FONTS.each do |rel|
+          f = load_full(rel)
+          hmtx = f.table("hmtx")
+          hmtx.parse_with_context(f.table("hhea").number_of_h_metrics, f.table("maxp").num_glyphs) unless hmtx.parsed?
+          f.table("maxp").num_glyphs.times { |gid| hmtx.metric_for(gid) }
+        end
+      end
+    end
+
+    def names
+      op("names", "name table: full, family, subfamily, postscript, 4 fonts") do
+        ids = [Fontisan::Tables::Name::FULL_NAME, Fontisan::Tables::Name::FAMILY,
+               Fontisan::Tables::Name::SUBFAMILY, Fontisan::Tables::Name::POSTSCRIPT_NAME]
+        NAME_FONTS.each do |rel|
+          f = Fontisan::FontLoader.load(font(rel), mode: :metadata)
+          name = f.table("name")
+          ids.each { |id| name.english_name(id) }
+        end
+      end
+    end
+
+    def cmap_coverage
+      op("cmap_coverage", "cmap unicode mappings of 3 static fonts") do
+        TABLE_PARSE_FONTS.each do |rel|
+          load_full(rel).table("cmap").unicode_mappings.size
+        end
+      end
+    end
+
+    def audit_file
+      op("audit_file", "audit with validation, one font (facade)", requires: ["Fontisan::Reference"]) do
+        Fontisan::Reference.audit(font(SS_TTF), validate: true)
+      end
+    end
+
+    def audit_dir
+      op("audit_dir", "audit every file of the ci corpus directory (facade)",
+         requires: ["Fontisan::Reference"]) do
+        Fontisan::Reference.audit_dir(@fonts_dir, validate: false)
+      end
+    end
+
+    def scan
+      op("scan_dir", "scan rows for every file of the ci corpus directory (facade)",
+         requires: ["Fontisan::Reference"]) do
+        Fontisan::Reference.scan(scan_paths)
+      end
+    end
+
+    def vf_instance
+      op("vf_instance", "variable font instance at wght=700") do
+        Fontisan::Variable::Instancer.new(load_full(SS_VF)).instance({ "wght" => 700.0 })
+      end
+    end
+
+    def woff2_decode
+      op("woff2_decode", "load a WOFF2 and parse every table") do
+        f = load_full(SS_WOFF2)
+        f.table_names.each { |tag| f.table(tag) }
+      end
+    end
+
+    def convert_roundtrip
+      op("convert_roundtrip", "ttf -> woff -> ttf") do
+        Dir.mktmpdir("fontisan-bench") do |dir|
+          Fontisan.convert(font(SS_TTF), to: :woff, output: File.join(dir, "a.woff"), quiet: true)
+          Fontisan.convert(File.join(dir, "a.woff"), to: :ttf, output: File.join(dir, "b.ttf"), quiet: true)
+        end
+      end
+    end
+
+    def woff2_encode
+      op("woff2_encode", "ttf -> woff2") do
+        Dir.mktmpdir("fontisan-bench") do |dir|
+          Fontisan.convert(font(SS_TTF), to: :woff2, output: File.join(dir, "a.woff2"), quiet: true)
+        end
+      end
+    end
+  end
+end