fontico 0.1.1 → 1.2.0

data/lib/fontico/emitters/header.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Fontico
+  module Emitters
+    # A C header, so firmware names icons by intent like every other consumer.
+    # The device draws them out of the TTF this is emitted alongside, and the
+    # two agree because both read codepoints from icons.lock.
+    #
+    # That pinning matters more here than anywhere else fontico uses it. A
+    # codepoint compiled into a flashed .bin cannot be hotfixed: if adding an
+    # icon renumbered the others, every board in the field would start drawing
+    # the wrong picture after an OTA. The lock is append-only precisely so that
+    # cannot happen.
+    #
+    # What the firmware gets out of this, beyond the naming: the UTF-8 bytes
+    # are literals decided at build time, so nothing parses "U+e63e" or
+    # assembles a String on the heap inside a draw loop.
+    class Header
+      PREFIX = "ICON_"
+
+      # Every byte of a private-use codepoint's UTF-8 is emitted as a \x
+      # escape and nothing else follows it inside the quotes, so C's greedy
+      # hex escapes have nothing extra to swallow.
+      def initialize(manifest, build, lock: nil)
+        @manifest = manifest
+        @build = build
+        @lock = lock
+      end
+
+      # A glyph carries no colour, so the same icons the font refuses are the
+      # ones this cannot name — there would be no glyph at the codepoint.
+      def accepts?(icon) = !(@lock&.multicolor?(icon.name) || icon.multicolor?)
+      def rules_only? = false
+
+      def self.identifier(name) = "#{PREFIX}#{name.upcase.gsub(/[^A-Z0-9]+/, "_")}"
+
+      # U+E001 -> "\xEE\x80\x81"
+      def self.utf8_literal(codepoint)
+        [codepoint].pack("U").bytes.map { format("\\x%02X", _1) }.join
+      end
+
+      def call
+        rows = @build.map { |icon, _| row(icon) }.sort_by { _1[:name] }
+        guard_ascii!(rows)
+        guard_collisions!(rows)
+
+        <<~HEADER
+          /* generated by fontico — do not edit.
+           *
+           * #{rows.size} icon(s) from #{File.basename(@manifest.path || "icons.yml")}, drawn out of
+           * the icons.ttf built beside it. Codepoints are pinned in icons.lock
+           * and never reissued, so a name compiled into a flashed image keeps
+           * meaning the same picture across every later build.
+           */
+          #ifndef FONTICO_ICONS_H
+          #define FONTICO_ICONS_H
+
+          #include <stdint.h>
+
+          #ifdef __cplusplus
+          extern "C" {
+          #endif
+
+          #define FONTICO_ICON_COUNT #{rows.size}
+
+          /* UTF-8 literals, ready to hand to OpenFontRender / FreeType. */
+          #{defines(rows).join("\n")}
+
+          typedef struct {
+            const char *name;
+            const char *utf8;
+            uint16_t codepoint;
+          } FonticoIcon;
+
+          /* Sorted by name, for an icon chosen at runtime rather than compiled
+           * in — a name arriving in an MQTT payload, say. Returns NULL when the
+           * manifest has no such icon, which is the one honest answer: drawing
+           * a codepoint the font has no glyph for is an invisible box.
+           *
+           * The table lives in whichever translation unit defines
+           * FONTICO_ICONS_IMPLEMENTATION before including this file. Exactly
+           * one must, or the linker will say so. Nothing else needs to change,
+           * and a firmware that only ever uses the #{PREFIX}* defines can skip it
+           * entirely and carry no table at all.
+           */
+          const char *fontico_icon(const char *name);
+          extern const FonticoIcon fontico_icons[FONTICO_ICON_COUNT];
+
+          #ifdef FONTICO_ICONS_IMPLEMENTATION
+          #include <stdlib.h>
+          #include <string.h>
+
+          const FonticoIcon fontico_icons[FONTICO_ICON_COUNT] = {
+          #{rows.map { %(  { "#{_1[:name]}", #{_1[:ident]}, 0x#{format("%04X", _1[:codepoint])} },) }.join("\n")}
+          };
+
+          static int fontico_icon_cmp(const void *key, const void *el) {
+            return strcmp((const char *)key, ((const FonticoIcon *)el)->name);
+          }
+
+          const char *fontico_icon(const char *name) {
+            const FonticoIcon *hit;
+            if (!name) return NULL;
+            hit = (const FonticoIcon *)bsearch(name, fontico_icons, FONTICO_ICON_COUNT,
+                                               sizeof(FonticoIcon), fontico_icon_cmp);
+            return hit ? hit->utf8 : NULL;
+          }
+          #endif /* FONTICO_ICONS_IMPLEMENTATION */
+
+          #ifdef __cplusplus
+          }
+          #endif
+
+          #endif /* FONTICO_ICONS_H */
+        HEADER
+      end
+
+      private
+
+      def row(icon)
+        # Never mint one here. The builder has already save!d the lock by the
+        # time it emits, so a codepoint invented now would reach the firmware
+        # without ever reaching disk — and the font would have no glyph there.
+        cp = @lock&.codepoint_for(icon.name)
+        raise Fontico::Error, "#{icon.name} has no codepoint in icons.lock" if cp.nil?
+
+        { name: icon.name, ident: self.class.identifier(icon.name),
+          codepoint: cp, source: icon.source }
+      end
+
+      # The table is sorted here with Ruby's byte-order <=> and searched on the
+      # device with strcmp, where `char` is signed on most toolchains. A byte
+      # above 0x7F orders one way here and the opposite there, so bsearch would
+      # quietly miss the icon rather than fail — an invisible box again.
+      def guard_ascii!(rows)
+        wide = rows.reject { _1[:name].ascii_only? }
+        return if wide.empty?
+
+        raise Fontico::Error,
+              "the c target needs ASCII icon names; these are not: " \
+              "#{wide.map { _1[:name] }.join(", ")}"
+      end
+
+      # ICON_NAV_MENU can be reached from nav.menu and from nav-menu, and C
+      # would take the second #define silently. Name both instead.
+      def guard_collisions!(rows)
+        clashes = rows.group_by { _1[:ident] }.select { |_, v| v.size > 1 }
+        return if clashes.empty?
+
+        detail = clashes.map { |ident, group| "#{ident} <- #{group.map { _1[:name] }.join(", ")}" }
+        raise Fontico::Error,
+              "icon names collide as C identifiers:\n  #{detail.join("\n  ")}\n" \
+              "Rename one side in icons.yml; dots, dashes and case all fold to the same macro."
+      end
+
+      def defines(rows)
+        width = rows.map { _1[:ident].length }.max.to_i
+        rows.map do |r|
+          format(%(#define %-#{width}s "%s" /* %s  U+%04X */),
+                 r[:ident], self.class.utf8_literal(r[:codepoint]), r[:source], r[:codepoint])
+        end
+      end
+    end
+  end
+end

data/lib/fontico/emitters/stylesheet.rb

@@ -18,9 +18,13 @@ module Fontico
       def accepts?(_icon) = false
       def rules_only?     = true
 
+      # In `@layer base`: an unlayered rule outranks every layered one, so
+      # Tailwind 4's `size-6` (in `@layer utilities`) used to lose to the
+      # 1em default here. Layered, the defaults hold and a class still wins.
       def call
         <<~CSS
           /* generated by fontico — do not edit */
+          @layer base {
           .#{Fontico.css_class} {
             display: inline-block;
             width: 1em;
@@ -38,6 +42,7 @@ module Fontico
           /* Optical sizing for icons set beside larger text. */
           .#{Fontico.css_class}-lg { width: 1.25em; height: 1.25em; }
           .#{Fontico.css_class}-xl { width: 1.5em;  height: 1.5em;  }
+          }
         CSS
       end
     end

data/lib/fontico/helper.rb

@@ -10,27 +10,22 @@ module Fontico
     # it on the baseline. Pass size: to override, or a CSS class — classes win
     # over the attributes, so `class: "size-6"` works untouched.
     def icon(name, size: nil, variant: nil, **options)
-      Fontico.check!(name.to_s)
-      entry = Fontico.manifest[name.to_s]
-      return missing(name) if entry.nil?
+      key = name.to_s
+      Fontico.check!(key)
 
-      symbol = entry.key
-      attrs = {
-        class: [Fontico.css_class, options.delete(:class)].compact.join(" "),
-        width: size || "1em",
-        height: size || "1em",
-        style: inline_size(size, options.delete(:style)),
-        "aria-hidden": options.key?(:title) ? nil : "true",
-        role: options.key?(:title) ? "img" : nil
-      }.merge(options).compact
-
-      title = attrs.delete(:title)
-      body = +""
-      body << "<title>#{ERB::Util.html_escape(title)}</title>" if title
-      body << %(<use href="#{sprite_path(variant)}##{symbol}"></use>)
+      # A bare icon(name) is deterministic apart from one thing. The attrs
+      # hash, the html_escape of constants like "1em" and "true", the string
+      # assembly — 22 objects a call, every call, for markup that never
+      # changes. The exception is the sprite path, because asset_host is
+      # allowed to be a proc that reads the request, so what gets cached is
+      # the markup either side of the href and the path is still resolved per
+      # call. Fontico.reset! drops the cache, which the dev watcher already
+      # calls after every rebuild.
+      bare = size.nil? && variant.nil? && options.empty?
+      pair = bare ? Fontico.icon_cache[key] ||= halves(key) : halves(key, size: size, **options)
+      return missing(name) if pair.nil?
 
-      tag = %(<svg #{attrs.map { |k, v| %(#{k}="#{ERB::Util.html_escape(v)}") }.join(" ")}>#{body}</svg>)
-      tag.respond_to?(:html_safe) ? tag.html_safe : tag
+      safe("#{pair[0]}#{sprite_path(variant)}#{pair[1]}")
     end
 
     # The `<use href>` for one icon, for markup this helper doesn't build —
@@ -45,8 +40,9 @@ module Fontico
     # icons_sprite for the inline case, where the path half is empty and the
     # fragment resolves against the current document.
     def icon_href(name)
-      Fontico.check!(name.to_s)
-      entry = Fontico.manifest[name.to_s]
+      key = name.to_s
+      Fontico.check!(key)
+      entry = Fontico.manifest[key]
       raise Fontico::Error, "no icon named #{name.inspect} in #{Fontico.manifest_path}" if entry.nil?
 
       "#{sprite_path}##{entry.key}"
@@ -56,12 +52,38 @@ module Fontico
     # where a cross-origin <use href> would silently render nothing.
     def icons_sprite
       Fontico.check!
-      svg = File.read(Fontico.sprite_file)
-      svg.respond_to?(:html_safe) ? svg.html_safe : svg
+      safe(Fontico.sprite_markup)
     end
 
     private
 
+    # The markup either side of the `href` value, so a caller can drop a
+    # freshly resolved sprite path between them. Nil when the manifest has no
+    # such name. Everything in here is a pure function of the entry and the
+    # options, which is exactly what makes the bare case worth caching.
+    def halves(key, size: nil, **options)
+      entry = Fontico.manifest[key]
+      return nil if entry.nil?
+
+      attrs = {
+        class: [Fontico.css_class, options.delete(:class)].compact.join(" "),
+        width: size || "1em",
+        height: size || "1em",
+        style: inline_size(size, options.delete(:style)),
+        "aria-hidden": options.key?(:title) ? nil : "true",
+        role: options.key?(:title) ? "img" : nil
+      }.merge(options).compact
+
+      title = attrs.delete(:title)
+      open = +"<svg #{attrs.map { |k, v| %(#{k}="#{ERB::Util.html_escape(v)}") }.join(" ")}>"
+      open << "<title>#{ERB::Util.html_escape(title)}</title>" if title
+      open << %(<use href=")
+
+      [open.freeze, %(##{entry.key}"></use></svg>).freeze]
+    end
+
+    def safe(str) = str.respond_to?(:html_safe) ? str.html_safe : str
+
     # width/height on an <svg> are presentation attributes, and *any* CSS
     # declaration outranks those — including icons.css's own `.ico { width:
     # 1em }`. So an explicitly requested size has to be inline or the

data/lib/fontico/lockfile.rb

@@ -29,21 +29,40 @@ module Fontico
       @entries    = data["icons"]      || {}
     end
 
-    def codepoint_for(name)
+    # Lookup only. A missing name is nil — callers that draw a glyph must
+    # not invent a codepoint, or a typo silently becomes a .notdef.
+    def codepoint_for(name) = @codepoints[name]
+
+    # Append-only reservation. store is the production caller; tests use it
+    # to pin order without going through a full build.
+    def allocate(name)
       @codepoints[name] ||= next_free
     end
 
     def entry(name) = @entries[name]
 
-    def store(name, source:, body:, multicolor: false, warnings: [])
+    # +size+ is the grid the body was refit to. It is recorded because it is
+    # an input to the body, not a property of the request for it — see #fresh?.
+    def store(name, source:, body:, size:, multicolor: false, warnings: [])
       @entries[name] = {
         "source"     => source,
+        "size"       => size,
         "digest"     => Digest::SHA256.hexdigest(body)[0, 16],
         "multicolor" => multicolor,
         "warnings"   => warnings,
         "body"       => body
       }
-      codepoint_for(name)
+      allocate(name)
+    end
+
+    # A lock written before sizes were recorded cannot say what grid its
+    # bodies were refit to. Taking them at the size now in the manifest costs
+    # nothing when it is right, and `rake fontico:update` fixes it when it is
+    # not. The alternative — calling every body stale — would re-fetch a whole
+    # manifest on a gem upgrade, and put a network round trip in the first
+    # deploy after it.
+    def assume_size(size)
+      @entries.each_value { _1["size"] ||= size }
     end
 
     # Names present in the lock but absent from the manifest keep their
@@ -55,8 +74,28 @@ module Fontico
       end
     end
 
-    def fresh?(name, source)
-      entry(name)&.fetch("source", nil) == source && entry(name)["body"]
+    # A cached body is only reusable if every input that produced it still
+    # holds. The source is the obvious one; the other two were the bug.
+    #
+    #   size        the body carries its refit baked in as a <g transform>,
+    #               while the sprite emitter reads the target size live. Keyed
+    #               on the source alone, changing `defaults: size:` moved every
+    #               <symbol> to the new viewBox and left the geometry inside
+    #               fit to the old grid — every icon a fraction of its size in
+    #               the corner of its box, on a page that 200s. Local files are
+    #               re-read every build and self-heal, so this only ever showed
+    #               on cached remotes: most of a real manifest.
+    #
+    #   multicolor  the *override* from the manifest, not the detected result.
+    #               When one is set the result always equals it, so the stored
+    #               result is the record of whether this body was preprocessed
+    #               under it. Nil leaves detection in charge, and detection on
+    #               an unchanged body gives an unchanged answer.
+    def fresh?(name, source, size:, multicolor: nil)
+      e = entry(name)
+      return false unless e && e["body"] && e["source"] == source && e["size"] == size
+
+      multicolor.nil? || e["multicolor"] == multicolor
     end
 
     def body(name) = entry(name)&.fetch("body", nil)

data/lib/fontico/manifest.rb

@@ -11,24 +11,58 @@ module Fontico
     # Where local/ SVGs live when the manifest doesn't say otherwise.
     LOCAL_PATH = "app/assets/icons"
 
-    attr_reader :path, :defaults, :providers, :targets, :icons
+    attr_reader :path, :defaults, :providers, :targets, :target_paths, :icons
 
-    def self.load(path) = new(YAML.safe_load_file(path), path: path)
+    def self.load(*paths)
+      paths = paths.flatten.compact.select { File.file?(_1) }
+      raise Errno::ENOENT, "icons.yml" if paths.empty?
+
+      data = paths.map { YAML.safe_load_file(_1) || {} }.reduce { |a, b| merge_data(a, b) }
+      new(data, path: paths.last)
+    end
+
+    # Later overlay wins a leaf; nested groups merge so an engine can ship
+    # `auth.google` and the app can add `auth.apple` without copying.
+    def self.merge_data(base, overlay)
+      {
+        "defaults" => (base["defaults"] || {}).merge(overlay["defaults"] || {}),
+        "targets" => overlay["targets"] || base["targets"] || ["sprite"],
+        "providers" => (base["providers"] || {}).merge(overlay["providers"] || {}),
+        "icons" => deep_merge(base["icons"] || {}, overlay["icons"] || {})
+      }
+    end
+
+    def self.deep_merge(left, right)
+      left.merge(right) { |_, a, b| a.is_a?(Hash) && b.is_a?(Hash) ? deep_merge(a, b) : b }
+    end
 
     def initialize(data, path: nil)
       @path      = path
       @defaults  = data["defaults"]  || {}
       @providers = data["providers"] || {}
-      @targets   = data["targets"]   || ["sprite"]
+      @targets, @target_paths = parse_targets(data["targets"])
       @icons     = flatten(data["icons"] || {}).freeze
       validate!
     end
 
+    # Where a target's artifact goes, relative to the root, or nil to take the
+    # default name in output_dir.
+    def target_path(target) = target_options(target)["path"]
+
+    # Anything else the target was given in the manifest, e.g. a gfxfont size.
+    def target_options(target) = target_paths.fetch(target.to_s, {})
+
     def default_provider = defaults.fetch("provider", "lucide")
     def local_path       = providers.dig("local", "path") || LOCAL_PATH
     def size             = defaults.fetch("size", 24).to_i
 
-    def [](name) = icons.find { _1.name == name }
+    # Every icon() call in every template comes through here, and a linear
+    # scan charged for the size of the manifest rather than for the icons a
+    # page actually draws: 11.5us a call at 300 names against 5us at 92, so
+    # naming icons you never draw slowed down the ones you do. Backwards for
+    # a gem whose pitch is 353,000 icons to choose from. The table is built
+    # once and @icons is frozen, so there is nothing to invalidate.
+    def [](name) = index[name]
 
     # Vendor icons grouped by provider so the resolver can batch one HTTP
     # request per provider instead of one per icon.
@@ -40,6 +74,43 @@ module Fontico
 
     private
 
+    # A list names the targets and each takes its default filename inside
+    # output_dir. A mapping also says where one goes, which is what firmware
+    # needs: icons.h belongs in the device's include/ directory, not in
+    # app/assets/builds next to the web artifacts. A target with more to say
+    # than a path takes a block instead.
+    #
+    #   targets: [sprite, ttf]
+    #
+    #   targets:
+    #     sprite:                                   # default location
+    #     ttf:  devs/data/icons.ttf                 # just a path
+    #     gfxfont:                                  # a path and a size
+    #       path: devs/include/icons_font.h
+    #       size: 24
+    def parse_targets(value)
+      case value
+      when nil   then [["sprite"], {}]
+      when Array then [value.map(&:to_s), {}]
+      when Hash
+        [value.keys.map(&:to_s),
+         value.compact.to_h { [_1.to_s, target_settings(_1, _2)] }]
+      else
+        raise Error, "targets: must be a list or a mapping, got #{value.class}"
+      end
+    end
+
+    def target_settings(target, value)
+      case value
+      when String then { "path" => value }
+      when Hash   then value.to_h { [_1.to_s, _2] }
+      else
+        raise Error, "targets: #{target} must be a path or a mapping, got #{value.class}"
+      end
+    end
+
+    def index = @index ||= icons.to_h { [_1.name, _1] }
+
     def flatten(tree, prefix = nil)
       tree.flat_map do |key, value|
         name = [prefix, key].compact.join(".")

data/lib/fontico/node/rasterize.mjs

@@ -0,0 +1,192 @@
+// Rasterise glyphs out of a built TTF into 1-bit bitmaps.
+//
+// Reading the font rather than the SVG bodies is deliberate: build_font.mjs
+// has already normalised every icon to the em box and put it on a common
+// baseline, so bitmaps taken from here inherit the same geometry the PDF
+// uses. Rasterising the SVGs separately would re-derive all of that and drift.
+//
+// opentype.js is already a toolchain dependency, so this needs nothing new —
+// it gives us outlines, and a scanline fill turns those into pixels.
+//
+// stdin:  { ttf, size, glyphs: [{ name, codepoint }] }
+// stdout: { glyphs: [{ name, codepoint, width, height, xAdvance,
+//                      xOffset, yOffset, bytes: [...] }], yAdvance }
+import fs from 'fs';
+import opentype from 'opentype.js';
+
+const job = JSON.parse(fs.readFileSync(0, 'utf8'));
+
+// Coverage is sampled this many times per pixel on each axis. 4 is enough to
+// place an edge convincingly at 24px and still runs in milliseconds; the
+// result is thresholded to one bit regardless, so more buys very little.
+const SS = 4;
+// Curve subdivision. Flat enough that the error sits well under a subsample.
+const CURVE_STEPS = 12;
+
+const lerp = (a, b, t) => a + (b - a) * t;
+
+function cubicAt(x0, y0, x1, y1, x2, y2, x3, y3, t) {
+  const ax = lerp(x0, x1, t), ay = lerp(y0, y1, t);
+  const bx = lerp(x1, x2, t), by = lerp(y1, y2, t);
+  const cx = lerp(x2, x3, t), cy = lerp(y2, y3, t);
+  const dx = lerp(ax, bx, t), dy = lerp(ay, by, t);
+  const ex = lerp(bx, cx, t), ey = lerp(by, cy, t);
+  return { x: lerp(dx, ex, t), y: lerp(dy, ey, t) };
+}
+
+function quadAt(x0, y0, x1, y1, x2, y2, t) {
+  const ax = lerp(x0, x1, t), ay = lerp(y0, y1, t);
+  const bx = lerp(x1, x2, t), by = lerp(y1, y2, t);
+  return { x: lerp(ax, bx, t), y: lerp(ay, by, t) };
+}
+
+// Path commands to closed polygons. Every contour is implicitly closed: a
+// fill has no notion of an open one, and leaving it open drops an edge.
+function contoursOf(path) {
+  const out = [];
+  let cur = null;
+  let cx = 0, cy = 0, sx = 0, sy = 0;
+
+  const close = () => {
+    if (cur && cur.length > 2) out.push(cur);
+    cur = null;
+  };
+
+  for (const cmd of path.commands) {
+    switch (cmd.type) {
+      case 'M':
+        close();
+        cur = [{ x: cmd.x, y: cmd.y }];
+        cx = sx = cmd.x; cy = sy = cmd.y;
+        break;
+      case 'L':
+        if (cur) cur.push({ x: cmd.x, y: cmd.y });
+        cx = cmd.x; cy = cmd.y;
+        break;
+      case 'C':
+        for (let i = 1; i <= CURVE_STEPS; i++) {
+          cur.push(cubicAt(cx, cy, cmd.x1, cmd.y1, cmd.x2, cmd.y2, cmd.x, cmd.y, i / CURVE_STEPS));
+        }
+        cx = cmd.x; cy = cmd.y;
+        break;
+      case 'Q':
+        for (let i = 1; i <= CURVE_STEPS; i++) {
+          cur.push(quadAt(cx, cy, cmd.x1, cmd.y1, cmd.x, cmd.y, i / CURVE_STEPS));
+        }
+        cx = cmd.x; cy = cmd.y;
+        break;
+      case 'Z':
+        close();
+        cx = sx; cy = sy;
+        break;
+    }
+  }
+  close();
+  return out;
+}
+
+function edgesOf(contours) {
+  const edges = [];
+  for (const c of contours) {
+    for (let i = 0; i < c.length; i++) {
+      const a = c[i], b = c[(i + 1) % c.length];
+      if (a.y !== b.y) edges.push([a.x, a.y, b.x, b.y]);
+    }
+  }
+  return edges;
+}
+
+// Add a horizontal span's contribution, splitting it across the pixels it
+// partially covers so edges land between pixels rather than on one side.
+function addSpan(cov, w, row, xa, xb, weight) {
+  const lo = Math.max(0, xa), hi = Math.min(w, xb);
+  if (hi <= lo) return;
+  for (let px = Math.floor(lo); px < Math.ceil(hi); px++) {
+    const l = Math.max(lo, px), r = Math.min(hi, px + 1);
+    if (r > l) cov[row + px] += (r - l) * weight;
+  }
+}
+
+// Scanline fill with the nonzero winding rule, which is what TrueType uses —
+// even-odd would punch holes in any glyph whose contours overlap.
+function coverage(edges, x0, y0, w, h) {
+  const cov = new Float64Array(w * h);
+  const weight = 1 / SS;
+
+  for (let py = 0; py < h; py++) {
+    for (let s = 0; s < SS; s++) {
+      const sy = y0 + py + (s + 0.5) / SS;
+      const hits = [];
+      for (const [ex0, ey0, ex1, ey1] of edges) {
+        const lo = Math.min(ey0, ey1), hi = Math.max(ey0, ey1);
+        if (sy < lo || sy >= hi) continue;
+        hits.push({ x: ex0 + ((sy - ey0) / (ey1 - ey0)) * (ex1 - ex0), dir: ey1 > ey0 ? 1 : -1 });
+      }
+      if (hits.length < 2) continue;
+      hits.sort((a, b) => a.x - b.x);
+
+      let wind = 0;
+      for (let i = 0; i < hits.length - 1; i++) {
+        wind += hits[i].dir;
+        if (wind !== 0) addSpan(cov, w, py * w, hits[i].x - x0, hits[i + 1].x - x0, weight);
+      }
+    }
+  }
+  return cov;
+}
+
+// GFXfont bitmaps are one continuous MSB-first bitstream with no padding
+// between rows — drawBitmap's row-aligned layout is a different format, and
+// mixing them up shears the glyph.
+function pack(cov, w, h) {
+  const bytes = [];
+  let acc = 0, n = 0;
+  for (let i = 0; i < w * h; i++) {
+    acc = (acc << 1) | (cov[i] > 0.5 ? 1 : 0);
+    if (++n === 8) { bytes.push(acc & 0xff); acc = 0; n = 0; }
+  }
+  if (n) bytes.push((acc << (8 - n)) & 0xff);
+  return bytes;
+}
+
+const font = opentype.parse(new Uint8Array(fs.readFileSync(job.ttf)).buffer);
+const size = job.size;
+const scale = size / font.unitsPerEm;
+const out = [];
+
+for (const g of job.glyphs) {
+  const glyph = font.charToGlyph(String.fromCodePoint(g.codepoint));
+  // getPath flips y so it grows downward from the baseline, which is the
+  // direction GFXglyph's yOffset is measured in too.
+  const contours = contoursOf(glyph.getPath(0, 0, size));
+  const edges = edgesOf(contours);
+  const advance = Math.round((glyph.advanceWidth ?? font.unitsPerEm) * scale);
+
+  if (!edges.length) {
+    out.push({ ...g, width: 0, height: 0, xAdvance: advance, xOffset: 0, yOffset: 0, bytes: [], blank: true });
+    continue;
+  }
+
+  // Tight box: a GFXglyph stores only the inked area and offsets it, so
+  // whitespace costs nothing in flash.
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const [ex0, ey0, ex1, ey1] of edges) {
+    minX = Math.min(minX, ex0, ex1); maxX = Math.max(maxX, ex0, ex1);
+    minY = Math.min(minY, ey0, ey1); maxY = Math.max(maxY, ey0, ey1);
+  }
+  const x0 = Math.floor(minX), y0 = Math.floor(minY);
+  const w = Math.max(1, Math.ceil(maxX) - x0);
+  const h = Math.max(1, Math.ceil(maxY) - y0);
+
+  const cov = coverage(edges, x0, y0, w, h);
+  const bytes = pack(cov, w, h);
+  const inked = cov.some((v) => v > 0.5);
+
+  out.push({
+    ...g,
+    width: w, height: h, xAdvance: advance, xOffset: x0, yOffset: y0,
+    bytes, blank: !inked
+  });
+}
+
+process.stdout.write(JSON.stringify({ glyphs: out, yAdvance: Math.round(size * 1.2) }));

data/lib/fontico/railtie.rb

@@ -12,6 +12,12 @@ module Fontico
       Fontico.root = Rails.root.to_s
     end
 
+    # Engines' config/icons.yml under the app's icons.yml. After root: the
+    # app file is Rails.root/icons.yml, not whatever Dir.pwd was at require.
+    initializer "fontico.load_path", after: "fontico.root" do |app|
+      Fontico.load_path = Fontico.discover(app)
+    end
+
     # Saving icons.yml — or a local SVG — rebuilds the artifacts and drops the
     # memoized manifest, so a new icon is live on the next request with no
     # restart and no rake. That memo is the only thing that ever needed one:
@@ -20,7 +26,7 @@ module Fontico
     initializer "fontico.reloader" do |app|
       next unless app.config.enable_reloading
 
-      watcher = app.config.file_watcher.new([Fontico.manifest_path], Railtie.local_dirs) do
+      watcher = app.config.file_watcher.new(Fontico.load_path, Railtie.local_dirs) do
         Fontico.reset!
         Fontico.rebuild!
         # Recorded rather than raised: a save that half-breaks the manifest