stationery 0.12.2 → 0.13.0

data/lib/stationery/fonts/font.rb

@@ -56,6 +56,7 @@ module Stationery
         @blanks = {}
         @shapes = {}.compare_by_identity
         @metrics = {}.compare_by_identity
+        @plans = {}.compare_by_identity
         @memoised = 0
         @keys = { true => {}, false => {} }
         @frozen_keys = { true => {}.compare_by_identity, false => {}.compare_by_identity }
@@ -256,7 +257,9 @@ module Stationery
 
       def substitute(gids, text, tags)
         start = 0
-        glyphs = @ttf.ligatures.substitute(gids, tags)
+        ligatures = @ttf.ligatures
+        plan = @plans.fetch(tags) { @plans[tags] = ligatures.plan(tags) }
+        glyphs = ligatures.substitute(gids, tags, plan:)
         chars = glyphs.map { |_gid, count| text[start, count].tap { start += count } }
         [glyphs.map(&:first), chars]
       end

data/lib/stationery/fonts/gsub.rb

@@ -69,7 +69,7 @@ module Stationery
 
       def initialize(features)
         @features = features.freeze
-        @plans = {}
+        @liga = plan_for(LIGA)
         freeze
       end
 
@@ -79,17 +79,21 @@ module Stationery
       # [[gid, number of source glyphs it stands for], ...] after applying the
       # lookups of `tags` (feature tag Strings) in LookupList order, each once.
       # Within a lookup the first subtable matching at a position wins and its
-      # glyph is not matched again by that lookup.
-      def substitute(gids, tags = LIGA)
-        plan(tags).reduce(gids.map { |gid| [gid, 1] }) { |glyphs, subtables| apply(subtables, glyphs) }
+      # glyph is not matched again by that lookup. `plan:` is #plan of the
+      # tags, for a caller that keeps it.
+      def substitute(gids, tags = LIGA, plan: plan(tags))
+        plan.reduce(gids.map { |gid| [gid, 1] }) { |glyphs, subtables| apply(subtables, glyphs) }
       end
 
+      # The lookups the tags name, merged and ordered: those of the default
+      # tags made with the parse, so it never changes once built, any other
+      # list's when asked (each Font keeps the plans it uses).
+      def plan(tags) = tags == LIGA ? @liga : plan_for(tags)
+
       private
 
-      # The lookups the tags name, merged and ordered; remembered per tag list.
-      def plan(tags)
-        @plans[tags] ||= tags.flat_map { |tag| @features[tag] || [] }.uniq(&:first).sort_by(&:first)
-                             .map(&:last).freeze
+      def plan_for(tags)
+        tags.flat_map { |tag| @features[tag] || [] }.uniq(&:first).sort_by(&:first).map(&:last).freeze
       end
 
       def apply(subtables, glyphs)

data/lib/stationery/fonts/installer.rb

@@ -9,7 +9,7 @@ module Stationery
     # `force:`. Development-time only; documents never download fonts.
     class Installer
       # Fetches an https URL, following up to five redirects.
-      HTTP = lambda do |url, redirects = 5|
+      HTTP = Stationery.shareable(lambda do |url, redirects = 5|
         require "net/http"
         uri = URI(url)
         raise Error, "refusing to download over #{uri.scheme}: #{url} (https only)" unless uri.scheme == "https"
@@ -23,7 +23,7 @@ module Stationery
           HTTP.call(uri.merge(response["location"]).to_s, redirects - 1)
         else raise Error, "HTTP #{response.code} fetching #{url}"
         end
-      end
+      end)
 
       attr_reader :into
 

data/lib/stationery/fonts/ligatures.rb

@@ -3,12 +3,14 @@
 module Stationery
   module Fonts
     # Chooses where a font's glyph substitutions come from. Every source
-    # answers `substitute(gids, feature_tags)` with [[gid, source glyph
-    # count], ...] and `features` with the tags it can apply.
+    # answers `substitute(gids, feature_tags, plan: plan(feature_tags))` with
+    # [[gid, source glyph count], ...] and `features` with the tags it can
+    # apply.
     module Ligatures
       # For fonts without a usable GSUB table: every glyph stands for itself.
       module NONE
-        def self.substitute(gids, _tags = Gsub::LIGA) = gids.map { |gid| [gid, 1] }
+        def self.substitute(gids, _tags = Gsub::LIGA, **) = gids.map { |gid| [gid, 1] }
+        def self.plan(_tags) = nil
         def self.features = []
       end
 

data/lib/stationery/fonts/registry.rb

@@ -2,15 +2,14 @@
 
 module Stationery
   module Fonts
-    # Process-wide cache of parsed TrueType files, keyed by path, face and
-    # mtime so an edited font is re-read. Parsing is the expensive part; the
-    # per-document Font objects that track used glyphs are cheap wrappers
-    # around a parse. A `#N` suffix on the path picks face N of a collection.
+    # The parsed TrueType files of one Ractor (see Store), the SIZE most
+    # recently used, keyed by path and face and read again when the file's
+    # mtime changes. Parsing is the expensive part; the per-document Font
+    # objects that track used glyphs are cheap wrappers around a parse. A
+    # `#N` suffix on the path picks face N of a collection.
     module Registry
       SIZE = 16
       FACE = /\A(.+)#(\d+)\z/
-      @cache = {}
-      @mutex = Mutex.new
 
       class << self
         def load(path)
@@ -19,29 +18,20 @@ module Stationery
           raise UnsupportedFont, "font file not found: #{path}" unless File.file?(path)
 
           mtime = File.mtime(path)
-          @mutex.synchronize { fetch(path, index, mtime) }
+          lru.fetch([path, index]) { |held| held&.first == mtime ? held : [mtime, parse(path, index)] }.last
         end
 
-        def clear
-          @mutex.synchronize { @cache.clear }
-        end
+        def clear = lru.clear
 
         private
 
+        def lru = Store.fetch(:stationery_fonts) { LRU.new(SIZE) }
+
         def split(path)
           match = FACE.match(path)
           match ? [match[1], match[2].to_i] : [path, 0]
         end
 
-        def fetch(path, index, mtime)
-          key = [path, index]
-          cached_mtime, ttf = @cache.delete(key)
-          ttf = parse(path, index) unless cached_mtime == mtime
-          @cache[key] = [mtime, ttf]
-          @cache.shift while @cache.size > SIZE
-          ttf
-        end
-
         def parse(path, index)
           Stationery.instrument("font.stationery", path: File.basename(path), action: :parse) do
             TrueType.new(File.binread(path), index:)

data/lib/stationery/fonts/true_type.rb

@@ -10,9 +10,9 @@ module Stationery
       include SfntMetrics
 
       REQUIRED_TABLES = %w[head hhea maxp hmtx].freeze
-      OUTLINE_TABLES = { "OTTO" => ["CFF "] }.freeze
+      OUTLINE_TABLES = Stationery.shareable({ "OTTO" => ["CFF "] })
       GLYF_TABLES = %w[loca glyf].freeze
-      SFNT_VERSIONS = ["\x00\x01\x00\x00".b, "true", "OTTO"].freeze
+      SFNT_VERSIONS = Stationery.shareable(["\x00\x01\x00\x00".b, "true", "OTTO"])
       COLLECTION = "ttcf"
       SIGNATURES = {
         "wOF2" => "WOFF2 needs Brotli; convert to .ttf or .woff"
@@ -40,6 +40,7 @@ module Stationery
         parse_post
         parse_os2
         @postscript_name = NameTable.postscript_name(self)
+        read_layout
       end
 
       def self.collection?(data) = data.byteslice(0, 4) == COLLECTION
@@ -70,26 +71,16 @@ module Stationery
         end
       end
 
-      # Pair kerning, read on first use. Shared by every document using this
-      # parse; the source is immutable once built.
-      def kerning
-        @kerning ||= Kerning.for(self)
-      end
-
-      # Standard ligatures, read on first use and shared like #kerning.
-      def ligatures
-        @ligatures ||= Ligatures.for(self)
-      end
+      # Pair kerning (see Kerning), standard ligatures (see Ligatures) and
+      # the CFF table, nil for TrueType outlines: read with the rest of the
+      # parse, so it never changes once built and is shared as it is by every
+      # document and every thread using it, and can be made Ractor-shareable.
+      attr_reader :kerning, :ligatures, :cff
 
       def cff?
         @tables.key?("CFF ")
       end
 
-      # The CFF table, read on first use; nil for TrueType outlines.
-      def cff
-        @cff ||= CFF.new(table_data("CFF ")) if cff?
-      end
-
       # The contours of a glyph in font units, y up (an Outline), from the
       # `glyf` table or the CFF charstrings. Read afresh on every call;
       # Font#outline remembers them for a document.
@@ -126,6 +117,12 @@ module Stationery
 
       private
 
+      def read_layout
+        @cff = CFF.new(table_data("CFF ")) if cff?
+        @kerning = Kerning.for(self)
+        @ligatures = Ligatures.for(self)
+      end
+
       # Table offsets in a collection are already absolute, so a face is read
       # from the shared data at its own table directory.
       def face_offset(index)

data/lib/stationery/forms/appearance.rb

@@ -14,14 +14,14 @@ module Stationery
       PADDING = 2
       LEADING = 1.15
       # The check mark's corners in the unit square (y down) and its stroke.
-      CHECK = { points: [[0.22, 0.52], [0.42, 0.72], [0.78, 0.28]], stroke: 0.12 }.freeze
+      CHECK = Stationery.shareable({ points: [[0.22, 0.52], [0.42, 0.72], [0.78, 0.28]], stroke: 0.12 })
       DOT = 0.45
       # What /DA and the appearance say when the value is black.
       BLACK = "0 g"
       SIGNATURE = { rule: 14, label_size: 7, label_baseline: 4, label_gray: 0.42 }.freeze
 
       # The size the value is drawn at: the field's, or what `font_size:
-      # :auto` fits (see AutoSize).
+      # :auto` or `:fit` fits (see AutoSize).
       attr_reader :size
 
       # `resources` are the render's, where the field's fonts get their names.
@@ -30,7 +30,7 @@ module Stationery
         @width = width
         @height = height
         @type = field.typeface.with(resources)
-        @size = field.auto_size? ? AutoSize.new(field, @type, width, height).size : field.font_size
+        @size = field.sized? ? AutoSize.new(field, @type, width, height).size : field.font_size
         @contents = contents
         keep
       end
@@ -41,8 +41,9 @@ module Stationery
       # The resource names of the fonts it draws with or keeps for editing.
       def font_names = @type.names
 
-      # What the field's /DA says: the font, size (0 for auto) and colour a
-      # viewer redraws the value with. nil for a field without variable text.
+      # What the field's /DA says: the font, size (0 for `:auto`, the fitted
+      # number for `:fit`) and colour a viewer redraws the value with. nil for
+      # a field without variable text.
       def default_appearance
         return unless @field.variable_text?
 

data/lib/stationery/forms/field.rb

@@ -17,13 +17,13 @@ module Stationery
       DEFAULTS = { font_size: 10, read_only: false, required: false, border: "#9CA3AF", background: "#FFFFFF",
                    radius: 2, tooltip: nil }.freeze
       # What a text field and a select take beyond the defaults: where the
-      # value sits, its colour, and the bounds of `font_size: :auto`.
+      # value sits, its colour, and the bounds of `font_size: :auto` or `:fit`.
       BOUNDS = %i[min_font_size max_font_size].freeze
       STYLE = [:align, :color, *BOUNDS].freeze
-      OPTIONS = {
+      OPTIONS = Stationery.shareable(
         text: [:multiline, :max_length, :comb, *STYLE], checkbox: [], radio: %i[checked],
         select: [:options, :editable, *STYLE], signature: %i[label]
-      }.freeze
+      )
       VARIABLE_TEXT = %i[text select].freeze
       # The /Q (quadding) of each `align:` (PDF 32000-1, 12.7.3.3).
       ALIGNMENTS = { left: 0, center: 1, right: 2 }.freeze
@@ -55,6 +55,10 @@ module Stationery
       def font_size = @options[:font_size]
       # Whether the value is drawn at the largest size that fits (`font_size: :auto`).
       def auto_size? = font_size == :auto
+      # Whether it is the size `:auto` would draw, written as a number (`font_size: :fit`).
+      def fit? = font_size == :fit
+      # Whether the gem chooses the size the value is drawn at (`:auto` or `:fit`).
+      def sized? = auto_size? || fit?
       def min_font_size = @options[:min_font_size]
       def max_font_size = @options[:max_font_size]
       def align = @options.fetch(:align, :left)
@@ -150,10 +154,10 @@ module Stationery
       def validate_style
         raise ArgumentError, "align: is :left, :center or :right, not #{align.inspect}" unless ALIGNMENTS.key?(align)
 
-        points(:font_size, " or :auto") unless auto_size?
+        points(:font_size, ", :auto or :fit") unless sized?
         BOUNDS.each do |key|
           next unless @options.key?(key)
-          raise ArgumentError, "#{key}: needs font_size: :auto" unless auto_size?
+          raise ArgumentError, "#{key}: needs font_size: :auto or :fit" unless sized?
 
           points(key)
         end

data/lib/stationery/html/tree_builder/blocks.rb

@@ -16,14 +16,14 @@ module Stationery
           dl dt dd center details summary form fieldset
         ].freeze
         HEADINGS = %w[h1 h2 h3 h4 h5 h6].freeze
-        MARKS = {
+        MARKS = Stationery.shareable(
           "strong" => { bold: true }, "b" => { bold: true },
           "em" => { italic: true }, "i" => { italic: true },
           "u" => { underline: true }, "ins" => { underline: true },
           "s" => { strike: true }, "del" => { strike: true }, "strike" => { strike: true },
           "code" => { code: true }, "kbd" => { code: true }, "samp" => { code: true }, "tt" => { code: true },
           "sub" => { script: :sub }, "sup" => { script: :sup }
-        }.freeze
+        )
         ALIGN = /\A\s*(left|center|right|justify)\s*\z/i
         # What makes a container a block of its own instead of flattening into its parent.
         BOXED = %i[background padding padding_top padding_right padding_bottom padding_left margin margin_top

data/lib/stationery/html/tree_builder.rb

@@ -20,13 +20,13 @@ module Stationery
       HEADINGS = %w[h1 h2 h3 h4 h5 h6].freeze
       SECTIONS = %w[thead tbody tfoot].freeze
       BLOCKS = (CLOSES_P + SECTIONS + %w[tr td th caption]).freeze
-      IMPLIED = {
+      IMPLIED = Stationery.shareable(
         "li" => [%w[li], %w[ul ol]],
         "dt" => [%w[dt dd], %w[dl]], "dd" => [%w[dt dd], %w[dl]],
         "td" => [%w[td th], %w[tr table]], "th" => [%w[td th], %w[tr table]],
         "tr" => [%w[tr], %w[table]],
         "thead" => [SECTIONS, %w[table]], "tbody" => [SECTIONS, %w[table]], "tfoot" => [SECTIONS, %w[table]]
-      }.freeze
+      )
 
       # `css` is the Css::Report unsupported styles are told to.
       def self.parse(tokens, nesting = Rich::Nesting.new, css: nil)

data/lib/stationery/hyphenation.rb

@@ -8,7 +8,7 @@ module Stationery
   #   Stationery::Hyphenation.hyphenate("Silbentrennung", "de") # => ["Sil", "ben", "tren", "nung"]
   #   Stationery::Hyphenation.points("hyphenation", "en")       # => [2, 6]
   module Hyphenation
-    PATTERNS = File.expand_path("hyphenation/patterns", __dir__)
+    PATTERNS = File.expand_path("hyphenation/patterns", __dir__).freeze
 
     # Language tags accepted by `hyphenate:`, mapped to a bundled pattern set.
     LANGUAGES = {
@@ -19,9 +19,7 @@ module Stationery
 
     # Letters kept intact at either end of a word (the pattern sets' own
     # typesetting minimums).
-    MINIMUMS = { "en-us" => [2, 3], "de-1996" => [2, 2], "sv" => [2, 2] }.freeze
-
-    LOCK = Mutex.new
+    MINIMUMS = Stationery.shareable({ "en-us" => [2, 3], "de-1996" => [2, 2], "sv" => [2, 2] })
 
     # One pattern set: the patterns keyed by their letters, the longest
     # pattern's length and the exception list.
@@ -108,10 +106,10 @@ module Stationery
       end
     end
 
+    # The Patterns of a `hyphenate:` value, loaded once per Ractor.
     def patterns(language)
       tag = tag(language)
-      @sets ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
-      LOCK.synchronize { @sets[tag] ||= Patterns.new(tag) }
+      Store.fetch(:stationery_hyphenation) { Memo.new }.fetch(tag) { Patterns.new(tag) }
     end
 
     # Indexes where `word` may be broken (before word[index]); an empty

data/lib/stationery/images/cache.rb

@@ -4,28 +4,23 @@ require "digest/md5"
 
 module Stationery
   module Images
-    # Process-wide cache of decoded images keyed by content digest, so a logo
-    # drawn on every invoice is parsed once. Decoded images are immutable after
-    # construction apart from memoized derived data, which is deterministic.
+    # The decoded images of one Ractor (see Store), the SIZE most recently
+    # used, keyed by content digest, so a logo drawn on every invoice is
+    # parsed once. Decoded images are immutable after construction apart
+    # from memoized derived data, which each image guards with its own lock.
     module Cache
       SIZE = 16
-      @cache = {}
-      @mutex = Mutex.new
 
       class << self
         def fetch(data)
-          key = Digest::MD5.digest(data)
-          @mutex.synchronize do
-            image = @cache.delete(key) || yield
-            @cache[key] = image
-            @cache.shift while @cache.size > SIZE
-            image
-          end
+          lru.fetch(Digest::MD5.digest(data)) { |held| held || yield }
         end
 
-        def clear
-          @mutex.synchronize { @cache.clear }
-        end
+        def clear = lru.clear
+
+        private
+
+        def lru = Store.fetch(:stationery_images) { LRU.new(SIZE) }
       end
     end
   end

data/lib/stationery/images/images.rb

@@ -3,8 +3,8 @@
 module Stationery
   # JPEG, PNG and lossless WebP images, embedded as image XObjects.
   module Images
-    PNG_SIGNATURE = "\x89PNG\r\n\x1A\n".b
-    JPEG_SIGNATURE = "\xFF\xD8".b
+    PNG_SIGNATURE = "\x89PNG\r\n\x1A\n".b.freeze
+    JPEG_SIGNATURE = "\xFF\xD8".b.freeze
     WEBP_SIGNATURE = /\ARIFF.{4}WEBP/mn
     UNSUPPORTED = { "GIF8" => "GIF", "II*\0" => "TIFF", "MM\0*" => "TIFF", "BM" => "BMP" }.freeze
 

data/lib/stationery/images/jpeg/bit_reader.rb

@@ -12,7 +12,7 @@ module Stationery
         # The bits still unread when the window is refilled (never more than
         # 16), kept below the next four bytes: the window stays a Fixnum.
         KEEP = 0xFFFF
-        PAD = "\0\0\0\0".b
+        PAD = "\0\0\0\0".b.freeze
 
         def initialize
           start("".b)

data/lib/stationery/images/jpeg/scan.rb

@@ -16,7 +16,7 @@ module Stationery
         # restart marker or a fill byte.
         MARKER = /\xFF[^\x00\xD0-\xD7\xFF]/n
         RESTART = /\xFF[\xD0-\xD7]/n
-        STUFFED = "\xFF\x00".b
+        STUFFED = "\xFF\x00".b.freeze
         ZIGZAG = Decoder::ZIGZAG
 
         def initialize(decoder, components, restart, progressive:)

data/lib/stationery/images/jpeg.rb

@@ -36,6 +36,7 @@ module Stationery
       end
 
       def initialize(data)
+        @lock = Mutex.new
         @data = data
         read_frame_header
         raise UnsupportedImage, "invalid JPEG image" unless @width
@@ -67,15 +68,17 @@ module Stationery
       # With `at_least:` [width, height] in pixels, decoded at the smallest
       # of a half, a quarter or an eighth of its size that is still that
       # large (libjpeg's scaled IDCT: far less work for a photo drawn
-      # small), else at full size. Each scale is decoded once and kept; the
-      # rows are built on every call.
+      # small), else at full size. Each scale is decoded once and kept, under
+      # the image's lock, as the threads of a Ractor share it through the
+      # image cache; the rows are built on every call.
       def pixels(at_least: nil)
         reason = unsupported
         raise UnsupportedImage, reason if reason
 
         scale = (at_least && SCALES.find { |s| large_enough?(s, *at_least) }) || 1
-        @decoded ||= {}
-        samples, channels = @decoded[scale] ||= Colors.call(Decoder.new(@data, scale).call)
+        samples, channels = @lock.synchronize do
+          (@decoded ||= {})[scale] ||= Colors.call(Decoder.new(@data, scale).call)
+        end
         width = (@width + scale - 1) / scale
         height = (@height + scale - 1) / scale
         stride = width * channels

data/lib/stationery/images/png.rb

@@ -17,6 +17,7 @@ module Stationery
       attr_reader :width, :height
 
       def initialize(data)
+        @lock = Mutex.new
         @idat = String.new(encoding: Encoding::BINARY)
         read_chunks(data)
         raise UnsupportedImage, "invalid PNG image" unless @width && CHANNELS.key?(@color_type)
@@ -26,10 +27,10 @@ module Stationery
       def inspect = "#<#{self.class} #{@width}x#{@height}>"
 
       # This image scaled down to `width` pixels (a Resampled), memoised per
-      # width; the same instance is shared through the image cache.
+      # width under the image's lock: the same instance is shared by the
+      # threads of a Ractor through the image cache.
       def resample(width)
-        @resampled ||= {}
-        @resampled[width] ||= Resampled.new(pixels, width)
+        @lock.synchronize { (@resampled ||= {})[width] ||= Resampled.new(pixels, width) }
       end
 
       def build(writer)

data/lib/stationery/images/webp/prefix_code.rb

@@ -17,7 +17,7 @@ module Stationery
         # The order the lengths of the code-length code are stored in.
         LENGTH_ORDER = [17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15].freeze
         # Extra bits and base of the repeat codes 16, 17 and 18.
-        REPEATS = [[2, 3], [3, 3], [7, 11]].freeze
+        REPEATS = Stationery.shareable([[2, 3], [3, 3], [7, 11]])
 
         module_function
 

data/lib/stationery/images/webp.rb

@@ -19,6 +19,7 @@ module Stationery
       attr_reader :width, :height
 
       def initialize(data)
+        @lock = Mutex.new
         container = Container.new(data)
         lossless = Lossless.new(container.bitstream)
         @width = lossless.width
@@ -33,10 +34,10 @@ module Stationery
       def inspect = "#<#{self.class} #{@width}x#{@height}>"
 
       # This image scaled down to `width` pixels (a Resampled), memoised per
-      # width; the same instance is shared through the image cache.
+      # width under the image's lock: the same instance is shared by the
+      # threads of a Ractor through the image cache.
       def resample(width)
-        @resampled ||= {}
-        @resampled[width] ||= Resampled.new(pixels, width)
+        @lock.synchronize { (@resampled ||= {})[width] ||= Resampled.new(pixels, width) }
       end
 
       def build(writer)

data/lib/stationery/instrumentation.rb

@@ -13,13 +13,33 @@ module Stationery
       end
     end
 
+    # Frozen, so a render in any Ractor can use it.
+    NULL = Null.new.freeze
+
+    # None set: the default below is asked for on every read and never
+    # written, so a non-main Ractor can read it.
+    @instrumenter = nil
+
     class << self
-      # Any object answering `instrument(name, payload) { |payload| }`; set
-      # once at boot, so a plain module attribute is enough.
+      # Any object answering `instrument(name, payload) { |payload| }`; nil
+      # gives the default back. A render inside a non-main Ractor can reach
+      # only a shareable one: a module (ActiveSupport::Notifications) or a
+      # frozen object.
+      # Set at boot, on the main Ractor, so a plain module attribute is enough.
       attr_writer :instrumenter # rubocop:disable ThreadSafety/ClassAndModuleAttributes
 
-      def instrumenter
-        @instrumenter ||= defined?(::ActiveSupport::Notifications) ? ::ActiveSupport::Notifications : Null.new # rubocop:disable ThreadSafety/ClassInstanceVariable
+      # The one set, else ActiveSupport::Notifications when it is loaded,
+      # else NULL.
+      # rubocop:disable-next ThreadSafety/ClassInstanceVariable -- only read here; written at boot on the main Ractor
+      def instrumenter = @instrumenter || default
+
+      def default = defined?(::ActiveSupport::Notifications) ? ::ActiveSupport::Notifications : NULL
+
+      # Keeps the instrumenter in use, so one loaded after boot is not picked
+      # up (Stationery.finalize!).
+      def finalize!
+        # rubocop:disable-next ThreadSafety/ClassInstanceVariable -- written at boot on the main Ractor, before any render
+        @instrumenter = instrumenter
       end
 
       def instrument(name, payload = {}, &)

data/lib/stationery/layout/box.rb

@@ -19,8 +19,8 @@ module Stationery
     class Box < Node
       include Wrapping
 
-      BORDER = { width: 1, color: "#000000", sides: %i[top right bottom left] }.freeze
-      SHADOW = { offset: [0, 4], blur: 8, color: "#000000", opacity: 0.15 }.freeze
+      BORDER = Stationery.shareable({ width: 1, color: "#000000", sides: %i[top right bottom left] })
+      SHADOW = Stationery.shareable({ offset: [0, 4], blur: 8, color: "#000000", opacity: 0.15 })
       SHADOW_LAYERS = 8
 
       attr_reader :content, :width_spec

data/lib/stationery/layout/table/cell.rb

@@ -9,8 +9,6 @@ module Stationery
         SIDES = %i[top right bottom left].freeze
         TEXT_OPTIONS = { size: :size, color: :color, weight: :weight, style: :style, font: :family,
                          letter_spacing: :letter_spacing }.freeze
-        BOXES = {} # rubocop:disable Style/MutableConstant
-
         attr_reader :content, :options, :colspan, :rowspan, :tag, :row_tag
 
         # `options` is shared with the other cells of a table, which is why a
@@ -47,11 +45,12 @@ module Stationery
           @natural_width = @min_width = @heights = nil
         end
 
-        # A padding of one number is a box every cell with that number shares:
-        # a long table holds one Array of it, not one per cell.
+        # A padding of one number is a box every cell with that number shares
+        # (one per Ractor, see Store): a long table holds one Array of it, not
+        # one per cell.
         def padding
           @padding ||= if (value = @options[:padding]).is_a?(Numeric)
-                         BOXES[value] ||= Geometry.box(value).freeze
+                         Store.fetch(:stationery_cell_paddings) { Memo.new }.fetch(value) { Geometry.box(value).freeze }
                        else
                          Geometry.box(value)
                        end

data/lib/stationery/layout/table.rb

@@ -23,8 +23,8 @@ module Stationery
       # How far over a limit the rows measured so far must be before the rest
       # is left unmeasured: more than any rounding in their sum.
       SLACK = 0.001
-      DEFAULT_CELL = { padding: 5, borders: %i[top right bottom left], border_width: 0.5,
-                       border_color: "#000000" }.freeze
+      DEFAULT_CELL = Stationery.shareable({ padding: 5, borders: %i[top right bottom left], border_width: 0.5,
+                                            border_color: "#000000" })
 
       # `tag` is the Table element its fragments share; a `continued` fragment
       # repeats header rows already read on an earlier page.

data/lib/stationery/layout/table_of_contents/entry.rb

@@ -8,7 +8,7 @@ module Stationery
       # row links to the entry's anchor once that anchor has painted. Tagged,
       # it is a TOCI holding the title as a Link and the number as a Reference.
       class Entry < Node
-        LEADERS = { dots: { dash: [0, 3], cap: :round, width: 1 }, line: { width: 0.5 } }.freeze
+        LEADERS = Stationery.shareable({ dots: { dash: [0, 3], cap: :round, width: 1 }, line: { width: 0.5 } })
 
         def initialize(entry, context:, options:, slot:)
           super()