fontico 0.2.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ad5f56ad9c1523dbd17d2cdb07da3a2d6aac315008ebd08ba84551d125083c0
-  data.tar.gz: 207804df603f81d1da9117d5b081a73dbcf649bf882dbeb43fdec33678fcacb4
+  metadata.gz: 1ee86cae31c0f7f4acb9b303bfd2c06638ea383d86e27ff603452537ec58cfed
+  data.tar.gz: cf9b3485369dd8601822dad9b1e367bccb41c440620071412b595b755afa97c9
 SHA512:
-  metadata.gz: 4a4bf9595c5257803d26ff2c79607d0a44b48b0c4bc7b1584ce9a71e6e61f18fd71447884eba9d9e48d296a5aec6c42ad6973b7c82e197443be02c6b1032756e
-  data.tar.gz: 3132cfd1d3a9fa3997a23ed450fa749416aac364414b883e5c65e6995b7708cbbb4155ed672de376c0089543ea3b36167cc1d93deb055e402529ca705685f030
+  metadata.gz: e9e776c9fb99a18085b38a4069f23b72c808ba48c45b321d7948a166c99dd0bf9e93f413dd13a729a5a085148ffdf8e4a1feef544c4babec168e37d037e3b316
+  data.tar.gz: c5e3727514c2ebaff8c1b879ca9c2468bd2b14df0bef16797f983580b5830ac52b75fd93b9b3f639d433b7e11bac28aedc4c6cacf1d448d66bb2a715cdeccbc5

data/README.md

@@ -1,5 +1,3 @@
-<div align="center">
-
 ```
 ╔═╗╔═╗╔╗╔╔╦╗╦╔═╗╔═╗
 ╠╣ ║ ║║║║ ║ ║║  ║ ║
@@ -12,8 +10,6 @@
 [![CI](https://github.com/fireho/fontico/actions/workflows/ci.yml/badge.svg)](https://github.com/fireho/fontico/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/license-MIT-blue)](LICENSE.txt)
 
-</div>
-
 ---
 
 ```erb
@@ -25,13 +21,15 @@
 Three providers, one call. Templates never name a vendor, so re-skinning the
 app — or surviving an upstream rename — is a diff in one file.
 
-| | |
-| --- | --- |
-| **353,000 icons** | any of [Iconify's 238 sets](https://icon-sets.iconify.design/), plus your own folder |
-| **One request** | a single sprite, 2.3KB brotli, not render-blocking |
-| **361ms cold, 2ms warm** | measured on 35 icons across two remote providers and five local files |
-| **No Node, no npm** | the sprite target is pure Ruby; deploys rebuild offline from the lockfile |
-| **Also PDFs** | a real TTF for Prawn, with pinned codepoints |
+|                          |                                                                                     |
+| ------------------------ | ----------------------------------------------------------------------------------- |
+| **353,000 icons**        | any of[Iconify's 238 sets](https://icon-sets.iconify.design/), plus your own folder |
+| **One request**          | a single sprite, 2.3KB brotli, not render-blocking                                  |
+| **361ms cold, 2ms warm** | measured on 35 icons across two remote providers and five local files               |
+| **No Node, no npm**      | the sprite target is pure Ruby; deploys rebuild offline from the lockfile           |
+| **Also PDFs**            | a real TTF for Prawn, with pinned codepoints                                        |
+| **Also firmware**        | `icons.h` for C/C++, same names, 7KB of font instead of 357KB                        |
+| **Also bare metal**      | a `GFXfont` compiled in — 11KB for 221 icons, no renderer, no filesystem            |
 
 ## Install
 
@@ -134,13 +132,13 @@ and no Node. Commit it.
 First-party exports are not uniform the way vendor icons are, so everything
 entering `app/assets/icons/` is normalised first:
 
-| | |
-| --- | --- |
-| Editor chrome | `sodipodi:`, `inkscape:`, `<metadata>`, RDF, empty `<defs>` stripped |
-| Ids | rewritten to `slug__id`, with `url(#…)`, `href`, `clip-path`, `mask` following |
-| viewBox | any source box refitted into the target, centred, aspect preserved |
-| Colour | folded to `currentColor`, unless the icon is detected as multicolour |
-| Safety | `<script>`, `on*` handlers, `<foreignObject>`, external refs removed |
+|               |                                                                                |
+| ------------- | ------------------------------------------------------------------------------ |
+| Editor chrome | `sodipodi:`, `inkscape:`, `<metadata>`, RDF, empty `<defs>` stripped           |
+| Ids           | rewritten to`slug__id`, with `url(#…)`, `href`, `clip-path`, `mask` following |
+| viewBox       | any source box refitted into the target, centred, aspect preserved             |
+| Colour        | folded to`currentColor`, unless the icon is detected as multicolour            |
+| Safety        | `<script>`, `on*` handlers, `<foreignObject>`, external refs removed           |
 
 The id rewriting is not optional hygiene. Across 40 SVGs sampled from a real
 machine, **34 shared `id="layer1"`** and 11 shared `id="path1"` — merging any
@@ -223,11 +221,11 @@ codepoint, so nothing gets hardcoded.
 A font glyph is filled contours; it has no strokes and no colour. Each icon
 takes one of three routes:
 
-| | |
-| --- | --- |
-| **filled** | used as-is — Material Symbols, most Iconify sets, flat first-party exports |
+|               |                                                                                                                         |
+| ------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| **filled**    | used as-is — Material Symbols, most Iconify sets, flat first-party exports                                             |
 | **extracted** | stroke-based, but the provider ships a font whose glyphs are already expanded — lifted from there, losslessly (Lucide) |
-| **refused** | stroke-based with no provider font — the build stops and names the icon |
+| **refused**   | stroke-based with no provider font — the build stops and names the icon                                                |
 
 There is deliberately no raster-trace fallback. Both published JS expanders
 (`svg-outline-stroke`, `oslllo-svg-fixer`) run artwork through potrace and hand
@@ -243,22 +241,121 @@ build names each one it dropped.
 Font targets need Node, installed on demand into `~/.cache/fontico`. A manifest
 with `targets: [sprite]` never touches it and stays pure Ruby.
 
+## Firmware, and C
+
+The `c` target emits `icons.h`, so a device names icons by intent like every
+other consumer. It draws them out of the same TTF, which is why `c` implies
+`ttf` the way `sprite` implies `css`.
+
+`targets:` takes a mapping when an artifact belongs somewhere specific — a
+firmware header goes in the device's `include/`, not in `app/assets/builds`
+next to the web files:
+
+```yaml
+targets:
+  sprite:                                 # default location
+  ttf:  devs/esplay/data/icons.ttf
+  c:    devs/esplay/include/icons.h
+```
+
+```c
+#include "icons.h"
+
+display.drawIcon(ICON_WIFI, 86, 5, COLOR_WHITE, 20);   /* "\xEE\x80\x81" */
+```
+
+The UTF-8 bytes are literals decided at build time, so nothing parses
+`"U+e63e"` or builds a `String` on the heap inside a draw loop. For an icon
+named at runtime rather than compiled in — arriving in an MQTT payload, say —
+the header also carries a name-sorted table:
+
+```c
+#define FONTICO_ICONS_IMPLEMENTATION   /* in exactly one translation unit */
+#include "icons.h"
+
+const char *glyph = fontico_icon(payload["icon"]);   /* NULL if unknown */
+```
+
+Two reasons this is a better deal than a vendor icon font on the device:
+
+- **Size.** The font carries only the icons your manifest names. 35 icons
+  build a 7KB TTF, against the 357KB an unsubsetted Material Symbols drop-in
+  costs — and flash is the budget that actually binds.
+- **Codepoints that cannot move.** They are pinned append-only in
+  `icons.lock`, which matters more here than anywhere else: a codepoint
+  compiled into a flashed image cannot be hotfixed. If adding an icon
+  renumbered the others, every board in the field would draw the wrong
+  picture after an OTA.
+
+Names become macros — `nav.menu` is `ICON_NAV_MENU`. Two names that fold to
+the same macro are refused rather than silently redefined, and non-ASCII
+names are refused too: the table is sorted here and `bsearch`ed there, and a
+byte above `0x7F` orders the other way under a signed `char`.
+
+Multicolour icons are left out, the same as they are left out of the font —
+there would be no glyph behind the codepoint. The build names each one.
+
+### `gfxfont`: no font renderer on the device at all
+
+The `c` target still needs something on the device that can read a TTF. The
+`gfxfont` target removes that: it emits an Adafruit `GFXfont` — 1-bit bitmaps
+and a glyph table, compiled straight into the binary. No FreeType, no
+OpenFontRender, no filesystem partition to flash. `Adafruit_GFX` and
+`Arduino_GFX` both take it as-is:
+
+```yaml
+targets:
+  sprite:
+  gfxfont:
+    path: devs/include/icons_font.h
+    size: 24
+```
+
+```c
+#include <Arduino_GFX_Library.h>
+#include "icons_font.h"
+
+gfx->setFont(&fontico_icons24);
+gfx->drawChar(x, y, ICON_WIFI, fg, bg, 1);
+```
+
+221 icons at 24px come to **9,961 bytes of bitmap** plus a 1,547-byte glyph
+table — about 11KB for the set, against 357KB for an unsubsetted vendor font
+on a filesystem. Bitmaps are rasterised out of the TTF fontico already
+builds, not from the SVGs, so they inherit the same normalised geometry the
+PDF uses instead of drifting from it through a second pipeline.
+
+Two things follow from the format. A `GFXfont` is **fixed size**, so ask for
+the size you will draw at rather than scaling one up. And it is indexed off a
+byte, so it holds 224 icons; past that the build says so and points you at the
+`c` target, which addresses codepoints directly. The char codes are positional
+for that reason, which is why they and the bitmaps are emitted into one file —
+they cannot disagree. Their order follows the append-only codepoints in
+`icons.lock`, so adding an icon appends instead of renumbering what is already
+flashed.
+
+At one bit deep, thin strokes fall through the threshold at small sizes. An
+icon that rasterises to nothing is refused rather than shipped as an icon that
+draws as nothing.
+
 ## How it compares
 
-| | vendor gems (`lucide-rails`, `heroicon`) | `iconify-icon` web component | fontico |
-| --- | --- | --- | --- |
-| Icon sets | one, per gem | 238 | 238, plus your own folder |
-| Where the SVG comes from | inlined per render | fetched at runtime, per client | one build-time sprite |
-| Requests | 0, but repeated in every response body | 1+ per icon, per visitor | 1, cached |
-| JS required | no | yes | no |
-| Rename-proof templates | no — `lucide_icon "pencil"` | no — `icon="lucide:pencil"` | yes — `icon "edit"` |
-| Offline / reproducible build | yes | no | yes, via `icons.lock` |
-| PDF | no | no | yes, TTF for Prawn |
+|                              | vendor gems (`lucide-rails`, `heroicon`) | `iconify-icon` web component   | fontico               |
+| ---------------------------- | ---------------------------------------- | ------------------------------ | --------------------- |
+| Icon sets                    | one, per gem                             | 238                            | 238 + your own       |
+| Where the SVG comes from     | inlined per render                       | fetched at runtime, per client | one build-time sprite |
+| Requests                     | 0, but repeated in every response body   | 1+ per icon, per visitor       | 1, cached             |
+| JS required                  | no                                       | yes                            | no                    |
+| Rename-proof templates       | no —`lucide_icon "pencil"`              | no —`icon="lucide:pencil"`    | yes —`icon "edit"`   |
+| Offline / reproducible build | yes                                      | no                             | yes, via`icons.lock`  |
+| PDF                          | no                                       | no                             | yes, TTF for Prawn    |
 
 ## Status
 
 - ✅ Manifest, resolver, preprocessor, lockfile, sprite emitter, Rails helper
 - ✅ TTF emitter with glyph extraction, codepoint API, Prawn helpers
+- ✅ `c` target: `icons.h` for firmware, with per-target output paths
+- ✅ `gfxfont` target: 1-bit bitmaps compiled in, for Adafruit_GFX / Arduino_GFX
 - ⏳ `woff2` — declared targets are skipped with a notice
 - ⏳ `variant:` — accepted and ignored by the helper; see [TODO.md](TODO.md)
 

data/lib/fontico/builder.rb

@@ -31,7 +31,15 @@ module Fontico
       # are already on disk: treating them as fresh meant editing logo.svg
       # rebuilt nothing. Force is `rake fontico:update` — re-fetch remotes,
       # keep the append-only codepoints.
-      stale = @manifest.icons.select { _1.local? || @force || !@lock.fresh?(_1.name, _1.source) }
+      # A lock from before sizes were recorded is taken at the manifest's word
+      # once, here, so an upgrade does not re-fetch everything. From then on a
+      # change to `defaults: size:` is caught like any other input change.
+      @lock.assume_size(@manifest.size)
+
+      stale = @manifest.icons.select do |icon|
+        icon.local? || @force ||
+          !@lock.fresh?(icon.name, icon.source, size: @manifest.size, multicolor: icon.multicolor)
+      end
       cached = @manifest.icons.map(&:name) - stale.map(&:name)
 
       unless stale.empty?
@@ -40,10 +48,7 @@ module Fontico
         # when a remote body has to come off the wire — which under force is
         # every remote, lock or no lock. Saying "missing" there would be a
         # lie: the bodies are present, force is what made them stale.
-        if @offline && remote_stale.any?
-          reason = @force ? "re-fetch #{remote_stale.size} icon(s)" : "resolve #{remote_stale.size} icon(s) missing from icons.lock"
-          raise Error, "cannot #{reason} and --offline was given"
-        end
+        raise Error, "cannot #{offline_blocker(remote_stale)} and --offline was given" if @offline && remote_stale.any?
 
         resolver = Resolver.new(@manifest, root: @root)
         sources = resolver.call(only: stale.map(&:name))
@@ -63,7 +68,7 @@ module Fontico
           # remote is judged by the wire, not the digest: under force it was
           # genuinely re-fetched even when it came back byte-identical.
           before = @lock.entry(icon.name)&.fetch("digest", nil)
-          @lock.store(icon.name, source: icon.source, body: pre.body,
+          @lock.store(icon.name, source: icon.source, body: pre.body, size: @manifest.size,
                       multicolor: pre.multicolor, warnings: pre.warnings)
           unchanged = icon.local? && @lock.entry(icon.name)["digest"] == before
           (unchanged ? cached : fetched) << icon.name
@@ -89,6 +94,25 @@ module Fontico
 
     private
 
+    # "missing from icons.lock" is a lie when every body is present and
+    # something else invalidated them, so name the thing that actually did.
+    # A body carries its refit baked in, so a new size needs the original
+    # geometry back off the wire — there is nothing on disk to redo it from.
+    def offline_blocker(remote_stale)
+      count = remote_stale.size
+      return "re-fetch #{count} icon(s)" if @force
+      return "resolve #{count} icon(s) missing from icons.lock" unless remote_stale.all? { locked?(_1) }
+
+      "re-preprocess #{count} icon(s) at size: #{@manifest.size}"
+    end
+
+    # Present in the lock, with a body, for this source — so not "missing",
+    # only invalidated by one of the inputs #fresh? checks alongside it.
+    def locked?(icon)
+      e = @lock.entry(icon.name)
+      !e.nil? && !e["body"].nil? && e["source"] == icon.source
+    end
+
     def emit(icons)
       FileUtils.mkdir_p(@output)
       written = []
@@ -96,9 +120,18 @@ module Fontico
 
       targets = @manifest.targets - PENDING
       targets += ["css"] if targets.include?("sprite") && !targets.include?("css")
+      # Both C targets lean on the font: the header is a map into it, and the
+      # gfxfont is rasterised out of it. Same implication as sprite -> css.
+      needs_font = targets.include?("c") || targets.include?("gfxfont")
+      targets += ["ttf"] if needs_font && !targets.include?("ttf")
+      # And the gfxfont reads the .ttf off disk, so it has to run after it.
+      targets = targets.partition { _1 != "gfxfont" }.flatten
 
       targets.each do |target|
-        path = File.join(@output, filename_for(target))
+        path = path_for(target)
+        # Before the emitter runs, not after it returns: a font target writes
+        # its own file through Node and needs the directory already there.
+        FileUtils.mkdir_p(File.dirname(path))
         emitter = emitter_for(target, [], path: path)
 
         accepted = icons.select { emitter.accepts?(_1) }
@@ -115,12 +148,29 @@ module Fontico
       [written, skipped]
     end
 
+    # An explicit path in the manifest wins, so a firmware header can land in
+    # the device's include/ directory instead of among the web artifacts.
+    #
+    # Always absolute: a font target hands its path to Node, which runs from
+    # its own toolchain directory and cannot resolve a relative one.
+    def path_for(target)
+      override = @manifest.target_path(target)
+      return File.expand_path(override, @root) if override
+
+      File.expand_path(filename_for(target), @output)
+    end
+
     def emitter_for(target, build = [], path: nil)
       case target
       when "sprite" then Emitters::Sprite.new(@manifest, build)
       when "css"    then Emitters::Stylesheet.new(@manifest, build)
       when "ttf"    then Emitters::Font.new(@manifest, build, lock: @lock, output: path)
-      else raise Error, "unknown target #{target.inspect} (have: sprite, ttf)"
+      when "c"      then Emitters::Header.new(@manifest, build, lock: @lock)
+      when "gfxfont"
+        opts = @manifest.target_options(target)
+        Emitters::GfxFont.new(@manifest, build, lock: @lock, ttf: path_for("ttf"),
+                                                size: (opts["size"] || 24).to_i)
+      else raise Error, "unknown target #{target.inspect} (have: sprite, ttf, c, gfxfont)"
       end
     end
 
@@ -128,7 +178,9 @@ module Fontico
       case target
       when "sprite" then "icons.svg"
       when "css"    then "icons.css"
-      when "ttf"    then "icons.ttf"
+      when "ttf"     then "icons.ttf"
+      when "c"       then "icons.h"
+      when "gfxfont" then "icons_font.h"
       else raise Error, "unknown target #{target.inspect}"
       end
     end

data/lib/fontico/emitters/gfx_font.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Fontico
+  module Emitters
+    # An Adafruit GFXfont, for a display driven by Adafruit_GFX or Arduino_GFX.
+    # It compiles into the binary, so unlike the TTF target there is no
+    # FreeType on the device, no font renderer, and no filesystem to flash.
+    #
+    # The trade is that a GFXfont is a fixed size and one bit deep. Ask for the
+    # size you will draw at; scaling one up is what the built-in 6x8 font
+    # already does badly.
+    #
+    # Char codes rather than codepoints, because that is what the draw path
+    # takes: Adafruit_GFX and Arduino_GFX both index glyphs as `c - first` off
+    # a byte. They are therefore positional, which is exactly why the codes and
+    # the bitmaps are emitted into one file — they cannot fall out of step with
+    # each other. What keeps them stable across builds is the order, and the
+    # order comes from the append-only codepoints in icons.lock.
+    class GfxFont
+      # 0x20..0xFF. Below 0x20 is control characters, which some print paths
+      # intercept before the font ever sees them.
+      FIRST = 0x20
+      LAST  = 0xFF
+      CAPACITY = LAST - FIRST + 1
+
+      def initialize(manifest, build, lock: nil, ttf: nil, size: 24, runner: nil)
+        @manifest = manifest
+        @build = build
+        @lock = lock
+        @ttf = ttf
+        @size = size
+        @runner = runner || NodeRunner.new
+      end
+
+      # Same rule as the font it is rasterised from: one bit cannot hold
+      # colour, so a multicolour icon has nothing to become.
+      def accepts?(icon) = !(@lock&.multicolor?(icon.name) || icon.multicolor?)
+      def rules_only? = false
+
+      def call
+        icons = @build.map(&:first).sort_by { codepoint!(_1) }
+        # A GFXfont with no glyphs is not a font. This is reachable when every
+        # icon in the manifest was dropped as multicolour.
+        raise Fontico::Error, "the gfxfont target has no icons left to rasterise" if icons.empty?
+
+        guard_capacity!(icons)
+
+        result = @runner.run("rasterize.mjs", {
+                               ttf: @ttf, size: @size,
+                               glyphs: icons.map { { name: _1.name, codepoint: codepoint!(_1) } }
+                             })
+        rows = rows_for(result["glyphs"], icons)
+        guard_blank!(rows)
+
+        render(rows, result["yAdvance"])
+      end
+
+      private
+
+      def codepoint!(icon)
+        @lock&.codepoint_for(icon.name) ||
+          raise(Fontico::Error, "#{icon.name} has no codepoint in icons.lock")
+      end
+
+      def rows_for(glyphs, icons)
+        by_name = glyphs.to_h { [_1["name"], _1] }
+        offset = 0
+        icons.each_with_index.map do |icon, i|
+          g = by_name.fetch(icon.name)
+          row = { name: icon.name, source: icon.source, char: FIRST + i,
+                  ident: Header.identifier(icon.name), offset: offset, glyph: g }
+          offset += g["bytes"].size
+          row
+        end
+      end
+
+      # A GFXfont has room for one byte's worth of glyphs and no more. Failing
+      # here beats emitting a font that silently stops at icon 224.
+      def guard_capacity!(icons)
+        return if icons.size <= CAPACITY
+
+        raise Fontico::Error,
+              "the gfxfont target holds #{CAPACITY} icons (a GFXfont is indexed off a byte) " \
+              "and this manifest has #{icons.size}. Split the icons across two fonts, or " \
+              "build the c target instead, which addresses codepoints directly."
+      end
+
+      # An icon that rasterised to nothing would draw as empty space with no
+      # complaint, on a screen nobody is watching.
+      def guard_blank!(rows)
+        blank = rows.select { _1[:glyph]["blank"] }
+        return if blank.empty?
+
+        raise Fontico::Error, <<~MSG
+          #{blank.size} icon(s) rasterised blank at #{@size}px and would draw as nothing:
+
+            #{blank.map { _1[:name] }.join("\n  ")}
+
+          Thin strokes fall through a one-bit threshold at small sizes. Either
+          raise the gfxfont size, or drop these from the target.
+        MSG
+      end
+
+      def render(rows, y_advance)
+        bytes = rows.flat_map { _1[:glyph]["bytes"] }
+        tag = "fontico_icons#{@size}"
+
+        <<~HEADER
+          /* generated by fontico — do not edit.
+           *
+           * #{rows.size} icon(s) as an Adafruit GFXfont, rasterised at #{@size}px, one bit
+           * deep. #{bytes.size} bytes of bitmap. Include this after your GFX library
+           * header; it defines the GFXglyph/GFXfont structs only if that has
+           * not already done so.
+           *
+           *   gfx->setFont(&#{tag});
+           *   gfx->drawChar(x, y, #{rows.first[:ident]}, fg, bg, 1);
+           *
+           * The char codes below are positional, so they and the bitmaps are
+           * one artifact and are regenerated together. Their order follows the
+           * append-only codepoints in icons.lock, so adding an icon appends
+           * rather than renumbering what is already flashed.
+           */
+          #ifndef FONTICO_GFXFONT_H
+          #define FONTICO_GFXFONT_H
+
+          #include <stdint.h>
+
+          /* Adafruit_GFX's own guard, so the library wins when it is present. */
+          #ifndef _GFXFONT_H_
+          #define _GFXFONT_H_
+          typedef struct {
+            uint16_t bitmapOffset;
+            uint8_t  width, height, xAdvance;
+            int8_t   xOffset, yOffset;
+          } GFXglyph;
+          typedef struct {
+            uint8_t  *bitmap;
+            GFXglyph *glyph;
+            uint16_t  first, last;
+            uint8_t   yAdvance;
+          } GFXfont;
+          #endif
+
+          #ifndef PROGMEM
+          #define PROGMEM
+          #endif
+
+          #{defines(rows).join("\n")}
+
+          /* One continuous MSB-first bitstream, no padding between rows. */
+          static const uint8_t #{tag}_bitmaps[] PROGMEM = {
+          #{bitmap_lines(bytes).join("\n")}
+          };
+
+          static const GFXglyph #{tag}_glyphs[] PROGMEM = {
+          #{rows.map { glyph_line(_1) }.join("\n")}
+          };
+
+          static const GFXfont #{tag} PROGMEM = {
+            (uint8_t *)#{tag}_bitmaps,
+            (GFXglyph *)#{tag}_glyphs,
+            0x#{format("%02X", FIRST)}, 0x#{format("%02X", rows.last[:char])}, #{y_advance}
+          };
+
+          #endif /* FONTICO_GFXFONT_H */
+        HEADER
+      end
+
+      def defines(rows)
+        width = rows.map { _1[:ident].length }.max.to_i
+        rows.map do |r|
+          format("#define %-#{width}s 0x%02X /* %s  %s */",
+                 r[:ident], r[:char], r[:name], r[:source])
+        end
+      end
+
+      def bitmap_lines(bytes)
+        bytes.each_slice(16).map { "  #{_1.map { |b| format("0x%02X", b) }.join(", ")}," }
+      end
+
+      def glyph_line(row)
+        g = row[:glyph]
+        format("  { %5d, %3d, %3d, %3d, %4d, %4d }, /* %s */",
+               row[:offset], g["width"], g["height"], g["xAdvance"],
+               g["xOffset"], g["yOffset"], row[:name])
+      end
+    end
+  end
+end

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

@@ -41,9 +41,12 @@ module Fontico
 
     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,
@@ -52,6 +55,16 @@ module Fontico
       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
     # codepoint reserved so it is never handed to a different icon.
     def retire_missing!(names)
@@ -61,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,7 +11,7 @@ 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(*paths)
       paths = paths.flatten.compact.select { File.file?(_1) }
@@ -40,16 +40,29 @@ module Fontico
       @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.
@@ -61,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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontico
-  VERSION = "0.2.0"
+  VERSION = "1.2.0"
 end

data/lib/fontico.rb

@@ -23,6 +23,8 @@ module Fontico
     autoload :Sprite,     "fontico/emitters/sprite"
     autoload :Font,       "fontico/emitters/font"
     autoload :Stylesheet, "fontico/emitters/stylesheet"
+    autoload :Header,     "fontico/emitters/header"
+    autoload :GfxFont,    "fontico/emitters/gfx_font"
   end
 
   class << self
@@ -46,6 +48,24 @@ module Fontico
     def manifest      = @manifest ||= Manifest.load(*load_path)
     def sprite_file   = File.join(root, output_dir, "icons.svg")
 
+    # Rendered markup for bare icon() calls, minus the sprite path. Keyed by
+    # name and bounded by the manifest, so it cannot grow with traffic.
+    def icon_cache = @icon_cache ||= {}
+
+    # Inline mode embeds the sprite in every response, and it used to be
+    # re-read off disk on every call: 13us and a fresh 10KB string per
+    # request, more than a whole page of icon() calls costs. Held instead,
+    # behind a stat, which is cheap next to the read and means a rebuild from
+    # anywhere — the dev watcher, or `rake fontico:build` in another terminal
+    # — is picked up without waiting for a reset!.
+    def sprite_markup
+      stamp = File.stat(sprite_file).then { [_1.mtime, _1.size] }
+      return @sprite_markup if @sprite_stamp == stamp
+
+      @sprite_stamp = stamp
+      @sprite_markup = File.read(sprite_file).freeze
+    end
+
     # Rails engines that ship config/icons.yml (or icons.yml at the gem
     # root), then the app's file. The app is last on purpose.
     def discover(app)
@@ -117,7 +137,12 @@ module Fontico
     end
 
     def glyph(name) = [codepoint(name)].pack("U")
-    def reset!        = (@manifest = @build_error = @missing_icons = nil)
+    # Drops everything derived from a build. The dev watcher calls this after
+    # every rebuild, which is what keeps the caches above honest.
+    def reset!
+      @manifest = @build_error = @missing_icons = nil
+      @icon_cache = @sprite_markup = @sprite_stamp = nil
+    end
 
     def configure = yield(self)
   end

data/lib/tasks/fontico.rake

@@ -67,10 +67,13 @@ if Rake::Task.task_defined?("assets:clobber")
 end
 
 namespace :fontico do
+  # Only what lands in output_dir. A target given an explicit path in the
+  # manifest is pointing somewhere the app owns — a firmware include/ that is
+  # very likely committed — and deleting that is not precompile's business.
   desc "Remove generated icon artifacts (icons.lock is kept: it is source)"
   task :clobber do
     require "fontico"
-    %w[icons.svg icons.css icons.ttf].each do |name|
+    %w[icons.svg icons.css icons.ttf icons.h icons_font.h].each do |name|
       path = File.join(Fontico.root, Fontico.output_dir, name)
       File.delete(path) if File.exist?(path)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontico
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.2.0
 platform: ruby
 authors:
 - nofxx
@@ -86,6 +86,8 @@ files:
 - lib/fontico.rb
 - lib/fontico/builder.rb
 - lib/fontico/emitters/font.rb
+- lib/fontico/emitters/gfx_font.rb
+- lib/fontico/emitters/header.rb
 - lib/fontico/emitters/sprite.rb
 - lib/fontico/emitters/stylesheet.rb
 - lib/fontico/helper.rb
@@ -95,6 +97,7 @@ files:
 - lib/fontico/node/build_font.mjs
 - lib/fontico/node/extract_glyphs.mjs
 - lib/fontico/node/package.json
+- lib/fontico/node/rasterize.mjs
 - lib/fontico/node_runner.rb
 - lib/fontico/outliner.rb
 - lib/fontico/prawn.rb