stationery 0.12.3 → 0.13.0

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,7 +14,7 @@ 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"

data/lib/stationery/forms/field.rb

@@ -20,10 +20,10 @@ module Stationery
       # 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

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()

data/lib/stationery/lru.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Stationery
+  # The `size` most recently used entries of a cache, for the threads of one
+  # Ractor (the image and font caches keep one per Ractor in Store). Every
+  # read and write holds the cache's own Mutex, and so does building a
+  # value, so a value is built once however many threads ask for it.
+  class LRU
+    def initialize(size)
+      @size = size
+      @entries = {}
+      @lock = Mutex.new
+    end
+
+    # The value for `key`, made the most recently used: what the block
+    # answers when given the value held for it (nil when there is none), so
+    # a caller keeps a value or replaces a stale one. Past `size` entries
+    # the least recently used goes. A block that raises stores nothing.
+    def fetch(key)
+      @lock.synchronize do
+        value = yield @entries.delete(key)
+        @entries[key] = value
+        @entries.shift while @entries.size > @size
+        value
+      end
+    end
+
+    def size = @lock.synchronize { @entries.size }
+    def clear = @lock.synchronize { @entries.clear }
+  end
+end

data/lib/stationery/memo.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Stationery
+  # Values built once per key, for the threads of one Ractor (the parsed
+  # colours and the hyphenation patterns keep one per Ractor in Store).
+  # Every read and write holds the memo's own Mutex, and so does building a
+  # value. With `limit:` the memo starts over once it holds that many.
+  class Memo
+    def initialize(limit: nil)
+      @limit = limit
+      @values = {}
+      @lock = Mutex.new
+    end
+
+    # The value for `key`, built by the block the first time. A block that
+    # raises stores nothing and leaves what is held as it was. A Hash keeps
+    # a frozen copy of a String key, so a String changed after it was used
+    # does not change what is held.
+    def fetch(key)
+      @lock.synchronize do
+        @values.fetch(key) do
+          value = yield
+          @values.clear if @limit && @values.size >= @limit
+          @values[key] = value
+        end
+      end
+    end
+
+    def key?(key) = @lock.synchronize { @values.key?(key) }
+    def size = @lock.synchronize { @values.size }
+    def clear = @lock.synchronize { @values.clear }
+  end
+end

data/lib/stationery/monochrome.rb

@@ -15,8 +15,8 @@ module Stationery
   module Monochrome
     DITHERS = %i[floyd_steinberg ordered threshold].freeze
     DEFAULTS = { dpi: 203, snap: false, threshold: 0.5, dither: :floyd_steinberg }.freeze
-    ACCEPTED = { dpi: "a number above 0", snap: "true or false", threshold: "a number from 0 to 1",
-                 dither: DITHERS.map(&:inspect).join(", ").sub(/, (?=[^,]*\z)/, " or ") }.freeze
+    ACCEPTED = Stationery.shareable({ dpi: "a number above 0", snap: "true or false", threshold: "a number from 0 to 1",
+                                      dither: DITHERS.map(&:inspect).join(", ").sub(/, (?=[^,]*\z)/, " or ") })
 
     # What a monochrome render is asked for. `dot` is the size of one of the
     # printer's dots in points.

data/lib/stationery/page.rb

@@ -22,13 +22,13 @@ module Stationery
     # Portrait, in points. Envelopes (dl, c5, c6) are written the ISO way,
     # short edge first: `layout: :landscape` is the side the address is on.
     # Label stock is width by height as its name has it.
-    SIZES = {
+    SIZES = Stationery.shareable(
       a3: [841.89, 1190.55], a4: [595.28, 841.89], a5: [419.53, 595.28], a6: [297.64, 419.53], a7: [209.76, 297.64],
       b5: [498.9, 708.66], letter: [612, 792], legal: [612, 1008], tabloid: [792, 1224],
       dl: [311.81, 623.62], c5: [459.21, 649.13], c6: [323.15, 459.21],
       label_4x6: [288, 432], label_4x3: [288, 216], label_4x2: [288, 144],
       label_100x150: [283.46, 425.2], label_100x50: [283.46, 141.73]
-    }.freeze
+    )
 
     attr_reader :size, :margin, :reserve, :content, :annotations, :anchors, :template_anchors, :slots,
                 :resource_names, :body, :background

data/lib/stationery/pdf/conformance.rb

@@ -10,20 +10,20 @@ module Stationery
     # conformant raises (ArgumentError for options that contradict the level,
     # ConformanceError for content), so a file is never mislabelled.
     class Conformance
-      LEVELS = {
+      LEVELS = Stationery.shareable(
         pdf_a2b: { standard: :pdf_a, part: 2, conformance: "B", label: "PDF/A-2b" },
         pdf_a3b: { standard: :pdf_a, part: 3, conformance: "B", label: "PDF/A-3b" },
         pdf_ua1: { standard: :pdf_ua, part: 1, label: "PDF/UA-1" }
-      }.freeze
+      )
       PDFA_ID = "http://www.aiim.org/pdfa/ns/id/"
       PDFUA_ID = "http://www.aiim.org/pdfua/ns/id/"
       # PDF/A knows its own schema; PDF/UA's has to be described to it.
-      PDFUA_SCHEMA = {
+      PDFUA_SCHEMA = Stationery.shareable(
         name: "PDF/UA identification schema", uri: PDFUA_ID, prefix: "pdfuaid",
         properties: [{ name: "part", type: "Integer", category: "internal",
                        description: "The part of ISO 14289 the document conforms to" }]
-      }.freeze
-      ICC_PROFILE = File.expand_path("icc/sRGB2014.icc", __dir__)
+      )
+      ICC_PROFILE = File.expand_path("icc/sRGB2014.icc", __dir__).freeze
       OUTPUT_CONDITION = "sRGB IEC61966-2.1"
       PRINT = 4
       CMYK_OPERATOR = /^(?:-?[\d.]+ ){4}[kK]$/
@@ -38,6 +38,10 @@ module Stationery
 
       def self.label(level) = LEVELS.dig(level.to_sym, :label) || level.to_s
 
+      # The bytes of the sRGB profile every PDF/A file embeds, read once per
+      # Ractor (see Store).
+      def self.icc_profile = Store.fetch(:stationery_icc_profile) { File.binread(ICC_PROFILE).freeze }
+
       # The Conformance for `levels` (a Symbol, an Array or nil); nil without
       # any. `missing_glyphs:` is checked even then.
       def self.for(levels, missing_glyphs: :raise)
@@ -107,7 +111,7 @@ module Stationery
       def catalog_entries(writer)
         return {} unless pdf_a?
 
-        profile = writer.add(Stream.new(File.binread(ICC_PROFILE), { N: 3 }))
+        profile = writer.add(Stream.new(Conformance.icc_profile, { N: 3 }))
         { OutputIntents: [{ Type: :OutputIntent, S: :GTS_PDFA1, DestOutputProfile: profile,
                             OutputConditionIdentifier: TextString.new(OUTPUT_CONDITION),
                             Info: TextString.new(OUTPUT_CONDITION) }] }

data/lib/stationery/pdf/encryption/aes.rb

@@ -8,7 +8,7 @@ module Stationery
       # AES as PDF uses it: object data is CBC with a random IV in front and
       # PKCS#5 padding; key material (UE, OE, Perms) is unpadded.
       module AES
-        ZERO_IV = ("\0" * 16).b
+        ZERO_IV = ("\0" * 16).b.freeze
 
         module_function
 

data/lib/stationery/pdf/encryption/standard_security.rb

@@ -13,11 +13,11 @@ module Stationery
       class StandardSecurity
         PERMISSIONS = { print: 3, modify: 4, copy: 5, annotate: 6, fill_forms: 9, extract_accessible: 10,
                         assemble: 11, print_high: 12 }.freeze
-        ALGORITHMS = {
+        ALGORITHMS = Stationery.shareable(
           aes_256: { V: 5, R: 6, Length: 256, CFM: :AESV3, key: 32 },
           aes_128: { V: 4, R: 4, Length: 128, CFM: :AESV2, key: 16 },
           rc4_128: { V: 2, R: 3, Length: 128 }
-        }.freeze
+        )
 
         # Checks and normalizes the options without deriving any keys.
         def self.options(owner_password:, user_password: "", permissions: PERMISSIONS.keys, algorithm: :aes_256)