Mostly Obvious.

Completing my own Ruby community triathlon

2026-06-02T10:00:00Z

Completing my own Ruby community triathlon

I just returned from a wonderful weekend in Vienna, where the initial edition of RubyConf Austria took place. I got back physically exhausted and a bit sleep-deprived, but also quite rich. Rich in experiences, friendships, inspiration and curiosity. Also literally Ruby-rich, snagging the treasure chest with partner-in-crime-of-twelve-years in the Treasure Hunt.

Ruby community conferences embody the soul of their makers. The tireless folk who do their best to bring us all together against all odds. The dreamers who never settle. The inviting hosts who make you feel at home anywhere. The ones dangerously skipping permissions and the ones keeping the kitchen tidy. The ones that are always around. All making it look like running this stuff is just easy.

Likewise, it is the soul of the folks coming. Speakers passionate about the ideas they spread. Curious listeners hooked on taking them further. But also strangers who don't feel like ones. Having an early-morning run or late-night exploration around the city. Nerding out on stained-glass or train schedules around the world. Respecting local food traditions. Or not. Boring anyone around with properties of technical fabrics and making their own outdoor gear. Entertaining with subtleties of each other's languages, pronunciation and customs. Bringing the same guest book over and over again. Keeping Ruby weird!

Vienna's RubyConf soul was exceptionally beautiful. Likewise, the initial RubyCon in Rimini had this unbeatable vibe and theme. Last but not least — it felt amazing to observe the renaissance of wroclove.rb after putting personal effort into it over so many years. They all had something very special and unique. Feeling grateful for the chance to be in all these places among friends in a difficult time and excited for the future of the Ruby community.

Since I already have your attention, I'd love to invite you all to Wrocław, 23–25 April 2027. We're celebrating 15 years of wroclove.rb. A tiny conference that grew out of a meetup, where we dared to make things differently and stayed for the long run. Hope to see you there!

I'm no longer RailsEventStore maintainer

2026-04-13T21:00:00Z

I'm no longer RailsEventStore maintainer

TL;DR RES is a strategic OSS product at arkency and I'm no longer with them.

RailsEventStore started around 2014 as an in-house event store developed to solve particular problems at one of the arkency clients. What initially only helped reliably synchronizing financial data with Salesforce, later became a central backbone for integrating company departments, powered cross-cutting workflows and radically simplified operations of the customer support. And we felt it was so good, it would have been a shame not to share it with the world. So, with the client's permission, it was extracted. Just like Rails once was.

RES was designed to work with legacy applications first in mind. Not the idealistic greenfield or hobby projects. It was meant to be introduced to mature projects with minimal changes. To start small, in the middle. On existing infrastructure. At the same time it was a useful educational tool when exposing people to DDD/CQRS/ES trinity. Such glue needed to be strong, versatile and predictable. That's how we ended up supporting three SQL engines: MySQL, PostgreSQL and Sqlite. Also avoiding breaking changes, frequently and intentionally. Finally aiming for 100% mutation coverage to avoid embarrassing mistakes once the systems running RES started accumulating gigabytes of valuable facts. Fun fact — when you don't introduce bugs, you may not be aware of anyone using your tool.

I have bandwidth for contract work right now. If there's a Rails problem on your board that keeps getting deprioritized, that's exactly what I'm here for.

I've been involved in the development of RailsEventStore since its beginning. It was a long and exciting journey that lasted over a decade. I'm grateful for having a chance to meet and learn from so many people who shared similar interests and contributed to its growth. And surely I've contributed my part too — whether in 3107 commits, shipping dozens of releases with carefully crafted changelogs, organizing several focused coding sprints for fellow event-store enthusiasts, keeping up-to-date with other developments in the event store space, patiently helping folks on Discord, Discussions, Issues and finally being a leader and shaping the RES vision.

Over the time, RES became somewhat popular and recognized. And started bringing quality consulting leads. As an internal project, it could only get attention when there was a break from client work, resulting in short bursts of activity lacking the continuity needed to escape local minima. On one hand it was never enough traction to have a luxury of focusing solely on it. On the other hand, not too many external contributions to keep it lively. Keeping radical backwards compatibility with an increasing number of features reduced maneuverability. Relying on 100% mutation coverage set the bar high for new contributors. The rough edges kept being rough edges. Yet experimenting with new implementation on the side was seen internally as dangerous to the product and confusing to clients.

My biggest personal regret was the inability to move core discussions to public Discord out of the convenient but internal and closed Slack channel. And now I'm on the other side. My professional relationship with arkency ended after 15 years. RES remains their strategic OSS product. And it is time for me to move on.

You may still find me hanging around on Discord, helping folks on Discussions and occasionally writing about the RES internals and design decisions. I'm no longer leading, maintaining and releasing Rails Event Store but I'm definitely not leaving the event-driven space.

Dynamic Consistency Boundary in RailsEventStore

2026-04-10T20:00:00Z

Last year I had the pleasure of rambling about Dynamic Consistency Boundary at the DRUG Ruby User Group in Wrocław, followed by a guest appearance on the Better Software Design podcast. The interview was quite a new experience for me and I enjoyed it a lot — kudos go to Mariusz for being such a great host. At the end of the episode I shared a sentiment that RailsEventStore would support DCB soon, perhaps in its next release.

I was being quite aggressive about the timeline, but it wasn't completely baseless. The underlying storage model and query capabilities already positioned RailsEventStore to meet two thirds of the DCB specification. These included querying events, filtered by their type and by a set of tags and tagging events freely at the moment they were appended or later.

RailsEventStore existed long before the discovery of DCB. But our approach to event streams was a bit different from the one criticized in the Kill Aggregate series. Events in RES can belong to multiple streams at the same time. They can be added and removed from streams later on. That supported refactoring of the aggregate boundaries and allowed multiple partitions of events at the same time, each for the particular reader. In that sense, a stream name acted just like a tag would in a DCB specification.

I have bandwidth for contract work right now. If there's a Rails problem on your board that keeps getting deprioritized, that's exactly what I'm here for.

The elephant in the room, and the missing part, was modifying the append method to accept AppendCondition. Without it, the DCB examples ported directly to RES had a significant flaw. For various reasons, this remained unaddressed until now.

Technically, changing the append to support DCB meant remodelling Concurrency Control away from streams. That is, replacing validation constraints on a SQL index with running a query. And all that without a race condition. Usually this involves some form of linearizing writes that share overlapping AppendCondition. The more granular locking, the better performance as the unrelated writes could happen in parallel. Locks can be explicit, just as Orisun implements them. Or more subtle and implicit — in the form of SERIALIZABLE isolation.

This is how Postgres behaves in this isolation level:

To guarantee true serializability PostgreSQL uses predicate locking, which means that it keeps locks which allow it to determine when a write would have had an impact on the result of a previous read from a concurrent transaction, had it run first. In PostgreSQL these locks do not cause any blocking and therefore can not play any part in causing a deadlock. They are used to identify and flag dependencies among concurrent Serializable transactions which in certain combinations can lead to serialization anomalies.

Putting it all together, a single-file implementation and verification, with no change to the storage:

require "bundler/inline"

gemfile do
  source "https://rubygems.org"

  gem "rails_event_store"
  gem "pg"
  gem "minitest",
      require: "minitest/autorun"
  gem "rails", require: false
end

# ActiveRecord::Base.logger = Logger.new(STDOUT)
# DATA_TYPE="jsonb"
# DATABASE_URL="postgres://localhost/rails_event_store_active_record"

::ActiveRecord::Base.establish_connection
::ActiveRecord::Schema.define do
  drop_table(
    :event_store_events_in_streams,
    if_exists: true
  )
  drop_table(
    :event_store_events,
    if_exists: true
  )

  create_table(
    :event_store_events,
    id: :bigserial,
    force: false
  ) do |t|
    t.references :event,
                 null: false,
                 type: :uuid,
                 index: {
                   unique: true
                 }
    t.string :event_type,
             null: false,
             index: true
    t.jsonb :metadata
    t.jsonb :data, null: false
    t.datetime :created_at,
               null: false,
               type: :timestamp,
               precision: 6,
               index: true
    t.datetime :valid_at,
               null: true,
               type: :timestamp,
               precision: 6,
               index: true
  end

  create_table(
    :event_store_events_in_streams,
    id: :bigserial,
    force: false
  ) do |t|
    t.string :stream, null: false
    t.integer :position, null: true
    t.references :event,
                 null: false,
                 type: :uuid,
                 index: true,
                 foreign_key: {
                   to_table:
                     :event_store_events,
                   primary_key:
                     :event_id
                 }
    t.datetime :created_at,
               null: false,
               type: :timestamp,
               precision: 6,
               index: true

    t.index %i[stream position],
            unique: true
    t.index %i[stream event_id],
            unique: true
  end
end

module RubyEventStore
  class DCBClient < ::RailsEventStore::JSONClient
    def append(
      events,
      append_query,
      tags: []
    )
      @repository.append(
        transform(
          enrich_events_metadata(events)
        ),
        append_query,
        tags
      )
      self
    end
  end

  class Specification
    def after(position)
      Specification.new(
        reader,
        result.dup do |r|
          r.after = position
        end
      )
    end

    def of_tags(tags)
      Specification.new(
        reader,
        result.dup do |r|
          r.stream =
            Data
              .define(:name) do
                def global? = false
              end
              .new(name: tags)
        end
      )
    end

    def exists? = reader.exists?(result)
  end

  class SpecificationReader
    def exists?(specification_result)
      repository.exists?(
        specification_result
      )
    end
  end

  class SpecificationResult
    def initialize(
      direction: :forward,
      start: nil,
      stop: nil,
      older_than: nil,
      older_than_or_equal: nil,
      newer_than: nil,
      newer_than_or_equal: nil,
      time_sort_by: nil,
      count: nil,
      stream: Stream.new(GLOBAL_STREAM),
      read_as: :all,
      batch_size: Specification::DEFAULT_BATCH_SIZE,
      with_ids: nil,
      with_types: nil,
      after: nil
    )
      @attributes =
        Struct.new(
          :direction,
          :start,
          :stop,
          :older_than,
          :older_than_or_equal,
          :newer_than,
          :newer_than_or_equal,
          :time_sort_by,
          :count,
          :stream,
          :read_as,
          :batch_size,
          :with_ids,
          :with_types,
          :after
        ).new(
          direction,
          start,
          stop,
          older_than,
          older_than_or_equal,
          newer_than,
          newer_than_or_equal,
          time_sort_by,
          count,
          stream,
          read_as,
          batch_size,
          with_ids,
          with_types,
          after
        )
      freeze
    end

    def after = @attributes.after
  end

  class DCBEventRepository < ActiveRecord::EventRepository
    def append(
      records,
      append_query,
      tags
    )
      return if records.empty?

      event_klass.transaction(
        isolation: :serializable
      ) do
        if append_query.call.exists?
          raise
        end

        event_klass.insert_all!(
          records.map do |record|
            insert_hash(
              record,
              record.serialize(
                @serializer
              )
            )
          end
        )
        stream_klass.insert_all!(
          records
            .map do |record|
              tags.map do |tag|
                {
                  stream: tag,
                  event_id:
                    record.event_id,
                  created_at:
                    Time.now.utc
                }
              end
            end
            .flatten
        )
      end
      self
    rescue ::ActiveRecord::RecordNotUnique,
           ::ActiveRecord::SerializationFailure => e
      raise_error(e)
    end

    def exists?(spec) =
      repo_reader.read_scope(
        spec
      ).exists?

    def initialize(...)
      super

      repo_reader.define_singleton_method(
        :read_scope
      ) do |spec|
        scope = super(spec)

        if spec.after
          scope =
            scope.where(
              [
                %_"#{@event_klass.table_name}"."id" > ?_,
                spec.after
              ]
            )
        end

        unless spec.stream.global?
          scope.unscope(where: :stream)

          Array(
            spec.stream.name
          ).each do |tag|
            scope =
              scope.and(
                scope.where(stream: tag)
              )
          end
        end

        scope
      end
    end
  end
end

TopUpCredits = Data.define(:amount)
CreditsToppedUp =
  Class.new(RailsEventStore::Event)

UseCredits = Data.define(:amount)
CreditsUsed =
  Class.new(RailsEventStore::Event)

class Account
  class << self
    def initial_state = 0

    def evolve(balance, event)
      case event
      when CreditsToppedUp
        balance +
          event.data.fetch(:amount)
      when CreditsUsed
        balance -
          event.data.fetch(:amount)
      end
    end

    def decide(balance, command)
      case command
      when TopUpCredits
        [
          CreditsToppedUp.new(
            data: {
              amount: command.amount
            }
          )
        ]
      when UseCredits
        if command.amount > balance
          raise
        end
        [
          CreditsUsed.new(
            data: {
              amount: command.amount
            }
          )
        ]
      end
    end
  end
end

class Repository
  def initialize(event_store)
    @event_store = event_store
  end

  def with_state(
    event_types,
    tags,
    decider
  )
    state, last_event_id =
      load(event_types, tags, decider)
    position =
      @event_store.global_position(
        last_event_id
      ) + 1 if last_event_id

    @event_store.append(
      (yield state),
      -> do
        @event_store
          .read
          .of_tags(tags)
          .of_type(event_types)
          .after(position)
      end,
      tags: tags
    )
  end

  def load(event_types, tags, decider)
    events =
      @event_store
        .read
        .of_tags(tags)
        .of_type(event_types)
        .to_a

    [
      events.reduce(
        decider.initial_state
      ) do |state, event|
        decider.evolve(state, event)
      end,
      events.last&.event_id
    ]
  end
end

class Scenario
  def initialize(event_store)
    @repository =
      Repository.new(event_store)
    @id = SecureRandom.uuid
  end

  def top_up_credits(amount)
    @repository.with_state(
      [CreditsToppedUp, CreditsUsed],
      ["account:#{@id}"],
      Account
    ) do |state|
      Account.decide(
        state,
        TopUpCredits.new(amount: amount)
      )
    end
  end

  def use_credits(amount)
    @repository.with_state(
      [CreditsToppedUp, CreditsUsed],
      ["account:#{@id}"],
      Account
    ) do |state|
      Account.decide(
        state,
        UseCredits.new(amount: amount)
      )
    end
  end

  def balance =
    @repository.load(
      [CreditsToppedUp, CreditsUsed],
      ["account:#{@id}"],
      Account
    ).first
end

module RubyEventStore
  class DCBTest < Minitest::Test
    def test_happy
      account = mk_scenario
      account.top_up_credits(100)
      account.use_credits(90)

      assert_equal 10, account.balance
    end

    def test_invariant
      account = mk_scenario
      assert_raises do
        account.use_credits(100)
      end

      assert_equal 0, account.balance
    end

    def test_stress
      account = mk_scenario
      account.top_up_credits(100)

      barrier =
        Concurrent::CyclicBarrier.new(
          count =
            ::ActiveRecord::Base
              .connection
              .pool
              .size
        )
      count
        .times
        .map do
          Thread.new do
            barrier.wait
            begin
              account.use_credits(100)
            rescue RuntimeError,
                   WrongExpectedEventVersion
            end
          end
        end
        .map(&:join)

      assert_equal 0, account.balance
    end

    def mk_event_store =
      DCBClient.new(
        repository:
          DCBEventRepository.new(
            serializer: JSON
          )
      )

    def mk_scenario =
      Scenario.new(mk_event_store)
  end
end

require "bundler/inline"

gemfile do
  source "https://rubygems.org"

  gem "rails_event_store"
  gem "pg"
  gem "minitest", require: "minitest/autorun"
  gem "rails", require: false
end

# ActiveRecord::Base.logger = Logger.new(STDOUT)
# DATA_TYPE="jsonb"
# DATABASE_URL="postgres://localhost/rails_event_store_active_record"

::ActiveRecord::Base.establish_connection
::ActiveRecord::Schema.define do
  drop_table(:event_store_events_in_streams, if_exists: true)
  drop_table(:event_store_events, if_exists: true)

  create_table(:event_store_events, id: :bigserial, force: false) do |t|
    t.references :event, null: false, type: :uuid, index: { unique: true }
    t.string :event_type, null: false, index: true
    t.jsonb :metadata
    t.jsonb :data, null: false
    t.datetime :created_at,
               null: false,
               type: :timestamp,
               precision: 6,
               index: true
    t.datetime :valid_at,
               null: true,
               type: :timestamp,
               precision: 6,
               index: true
  end

  create_table(
    :event_store_events_in_streams,
    id: :bigserial,
    force: false
  ) do |t|
    t.string :stream, null: false
    t.integer :position, null: true
    t.references :event,
                 null: false,
                 type: :uuid,
                 index: true,
                 foreign_key: {
                   to_table: :event_store_events,
                   primary_key: :event_id
                 }
    t.datetime :created_at,
               null: false,
               type: :timestamp,
               precision: 6,
               index: true

    t.index %i[stream position], unique: true
    t.index %i[stream event_id], unique: true
  end
end

module RubyEventStore
  class DCBClient < ::RailsEventStore::JSONClient
    def append(events, append_query, tags: [])
      @repository.append(
        transform(enrich_events_metadata(events)),
        append_query,
        tags
      )
      self
    end
  end

  class Specification
    def after(position)
      Specification.new(reader, result.dup { |r| r.after = position })
    end

    def of_tags(tags)
      Specification.new(
        reader,
        result.dup do |r|
          r.stream = Data.define(:name) { def global? = false }.new(name: tags)
        end
      )
    end

    def exists? = reader.exists?(result)
  end

  class SpecificationReader
    def exists?(specification_result)
      repository.exists?(specification_result)
    end
  end

  class SpecificationResult
    def initialize(
      direction: :forward,
      start: nil,
      stop: nil,
      older_than: nil,
      older_than_or_equal: nil,
      newer_than: nil,
      newer_than_or_equal: nil,
      time_sort_by: nil,
      count: nil,
      stream: Stream.new(GLOBAL_STREAM),
      read_as: :all,
      batch_size: Specification::DEFAULT_BATCH_SIZE,
      with_ids: nil,
      with_types: nil,
      after: nil
    )
      @attributes =
        Struct.new(
          :direction,
          :start,
          :stop,
          :older_than,
          :older_than_or_equal,
          :newer_than,
          :newer_than_or_equal,
          :time_sort_by,
          :count,
          :stream,
          :read_as,
          :batch_size,
          :with_ids,
          :with_types,
          :after
        ).new(
          direction,
          start,
          stop,
          older_than,
          older_than_or_equal,
          newer_than,
          newer_than_or_equal,
          time_sort_by,
          count,
          stream,
          read_as,
          batch_size,
          with_ids,
          with_types,
          after
        )
      freeze
    end

    def after = @attributes.after
  end

  class DCBEventRepository < ActiveRecord::EventRepository
    def append(records, append_query, tags)
      return if records.empty?

      event_klass.transaction(isolation: :serializable) do
        raise if append_query.call.exists?

        event_klass.insert_all!(
          records.map do |record|
            insert_hash(record, record.serialize(@serializer))
          end
        )
        stream_klass.insert_all!(
          records
            .map do |record|
              tags.map do |tag|
                {
                  stream: tag,
                  event_id: record.event_id,
                  created_at: Time.now.utc
                }
              end
            end
            .flatten
        )
      end
      self
    rescue ::ActiveRecord::RecordNotUnique,
           ::ActiveRecord::SerializationFailure => e
      raise_error(e)
    end

    def exists?(spec) = repo_reader.read_scope(spec).exists?

    def initialize(...)
      super

      repo_reader.define_singleton_method(:read_scope) do |spec|
        scope = super(spec)

        if spec.after
          scope =
            scope.where([%_"#{@event_klass.table_name}"."id" > ?_, spec.after])
        end

        unless spec.stream.global?
          scope.unscope(where: :stream)

          Array(spec.stream.name).each do |tag|
            scope = scope.and(scope.where(stream: tag))
          end
        end

        scope
      end
    end
  end
end

TopUpCredits = Data.define(:amount)
CreditsToppedUp = Class.new(RailsEventStore::Event)

UseCredits = Data.define(:amount)
CreditsUsed = Class.new(RailsEventStore::Event)

class Account
  class << self
    def initial_state = 0

    def evolve(balance, event)
      case event
      when CreditsToppedUp
        balance + event.data.fetch(:amount)
      when CreditsUsed
        balance - event.data.fetch(:amount)
      end
    end

    def decide(balance, command)
      case command
      when TopUpCredits
        [CreditsToppedUp.new(data: { amount: command.amount })]
      when UseCredits
        raise if command.amount > balance
        [CreditsUsed.new(data: { amount: command.amount })]
      end
    end
  end
end

class Repository
  def initialize(event_store)
    @event_store = event_store
  end

  def with_state(event_types, tags, decider)
    state, last_event_id = load(event_types, tags, decider)
    position = @event_store.global_position(last_event_id) + 1 if last_event_id

    @event_store.append(
      (yield state),
      -> do
        @event_store.read.of_tags(tags).of_type(event_types).after(position)
      end,
      tags: tags
    )
  end

  def load(event_types, tags, decider)
    events = @event_store.read.of_tags(tags).of_type(event_types).to_a

    [
      events.reduce(decider.initial_state) do |state, event|
        decider.evolve(state, event)
      end,
      events.last&.event_id
    ]
  end
end

class Scenario
  def initialize(event_store)
    @repository = Repository.new(event_store)
    @id = SecureRandom.uuid
  end

  def top_up_credits(amount)
    @repository.with_state(
      [CreditsToppedUp, CreditsUsed],
      ["account:#{@id}"],
      Account
    ) { |state| Account.decide(state, TopUpCredits.new(amount: amount)) }
  end

  def use_credits(amount)
    @repository.with_state(
      [CreditsToppedUp, CreditsUsed],
      ["account:#{@id}"],
      Account
    ) { |state| Account.decide(state, UseCredits.new(amount: amount)) }
  end

  def balance =
    @repository.load(
      [CreditsToppedUp, CreditsUsed],
      ["account:#{@id}"],
      Account
    ).first
end

module RubyEventStore
  class DCBTest < Minitest::Test
    def test_happy
      account = mk_scenario
      account.top_up_credits(100)
      account.use_credits(90)

      assert_equal 10, account.balance
    end

    def test_invariant
      account = mk_scenario
      assert_raises { account.use_credits(100) }

      assert_equal 0, account.balance
    end

    def test_stress
      account = mk_scenario
      account.top_up_credits(100)

      barrier =
        Concurrent::CyclicBarrier.new(
          count = ::ActiveRecord::Base.connection.pool.size
        )
      count
        .times
        .map do
          Thread.new do
            barrier.wait
            begin
              account.use_credits(100)
            rescue RuntimeError, WrongExpectedEventVersion
            end
          end
        end
        .map(&:join)

      assert_equal 0, account.balance
    end

    def mk_event_store =
      DCBClient.new(repository: DCBEventRepository.new(serializer: JSON))

    def mk_scenario = Scenario.new(mk_event_store)
  end
end

In this code I've deliberately chosen a few simplifications and omissions:

not caring about MySQL or SQLite that RES also supports
detecting the mixing of tag- and stream-based approaches, which could lead to broken ordering in streams
breaking backwards compatibility of the public Client interface

My intent was to show that supporting Dynamic Consistency Boundary in Rails Event Store is low-hanging fruit, should the maintainers decide to integrate it fully. For the release, introducing new APIs without breaking backward compatibility with a dominant stream-based approach is a must. Lots of existing clients depend on it.

In the long term, it would be ideal to make one implementation (stream-based) a specialization of the other (DCB). Just as Aggregate Roots can be composed of Deciders, I'm quite optimistic that Streams can be re-implemented on top of DCB. Storage-layer compatibility means the APIs can change safely while remaining compatible with existing data. The facade can be polished over time and corner cases can be detected early or with little additional infrastructure.

Whether DCB introduces any performance challenges over the stream-based approach on top of SQL storage engines is a completely different topic for another post.

Encrypted events with JSON underneath in RailsEventStore

2026-04-01T10:00:00Z

One of the most wanted features in RES is the encryption of event payloads — full or partial. This allows storing sensitive information and is often necessary for compliance in particular domains.

With Postgres backing the storage, it is natural to choose JSON/B as the data type for the event payload. It is the default. And a choice that further allows structural searches within event payloads with JSON functions and operators — useful and effective for digging deeper or doing some data science from raw facts.

Unfortunately, encrypted payloads and JSON don't work together out of the box:

JSON text exchanged between systems that are not part of a closed ecosystem MUST be encoded using UTF-8
the ciphertext may contain byte sequences that are invalid in UTF-8

The solution is to encode encrypted parts, or the complete payloads, into a JSON-safe representation: from binary to ASCII chars. Depending on the chosen encoder, the encrypted payload would grow in size:

I have bandwidth for contract work right now. If there's a Rails problem on your board that keeps getting deprioritized, that's exactly what I'm here for.

Format	Alphabet	Overhead
Base85	85 characters	~25%
Base64	64 characters	~33%
Base32	32 characters	~60%
Hex	16 characters	~100%

How to combine all that in RES?

Let's start with a failing example, replicating the issue. An in-memory RES instance that serializes event payloads to JSON with encryption mapper hooked in:

require "bundler/inline"
require "json"
require "openssl"
require "base64"

gemfile { gem "ruby_event_store" }

class TicketHolderEmailProvided < RubyEventStore::Event
  def self.encryption_schema =
    {
      email: ->(data) do
        data.fetch(:user_id)
      end
    }
end

class InMemoryEncryptionKeyRepository
  DEFAULT_CIPHER = "aes-256-cbc".freeze

  def initialize
    @keys = {}
  end

  def key_of(
    identifier,
    cipher: DEFAULT_CIPHER
  )
    @keys[[identifier, cipher]]
  end

  def create(
    identifier,
    cipher: DEFAULT_CIPHER
  )
    @keys[
      [identifier, cipher]
    ] = RubyEventStore::Mappers::EncryptionKey.new(
      cipher: cipher,
      key: random_key(cipher)
    )
  end

  def forget(identifier)
    @keys =
      @keys.reject do |(id, _)|
        id.eql?(identifier)
      end
  end

  private

  def random_key(cipher)
    crypto = OpenSSL::Cipher.new(cipher)
    crypto.encrypt
    crypto.random_key
  end
end

key_repository =
  InMemoryEncryptionKeyRepository.new
key_repository.create(user_id = 2137)

res =
  RubyEventStore::Client.new(
    repository:
      RubyEventStore::InMemoryRepository.new(
        serializer: JSON
      ),
    mapper:
      RubyEventStore::Mappers::EncryptionMapper.new(
        key_repository
      )
  )
res.append(
  TicketHolderEmailProvided.new(
    data: {
      email: "kaka@dudu.me",
      user_id: user_id
    }
  )
)

require "bundler/inline"
require "json"
require "openssl"
require "base64"

gemfile { gem "ruby_event_store" }

class TicketHolderEmailProvided < RubyEventStore::Event
  def self.encryption_schema = { email: ->(data) { data.fetch(:user_id) } }
end

class InMemoryEncryptionKeyRepository
  DEFAULT_CIPHER = "aes-256-cbc".freeze

  def initialize
    @keys = {}
  end

  def key_of(identifier, cipher: DEFAULT_CIPHER)
    @keys[[identifier, cipher]]
  end

  def create(identifier, cipher: DEFAULT_CIPHER)
    @keys[[identifier, cipher]] = RubyEventStore::Mappers::EncryptionKey.new(
      cipher: cipher,
      key: random_key(cipher)
    )
  end

  def forget(identifier)
    @keys = @keys.reject { |(id, _)| id.eql?(identifier) }
  end

  private

  def random_key(cipher)
    crypto = OpenSSL::Cipher.new(cipher)
    crypto.encrypt
    crypto.random_key
  end
end

key_repository = InMemoryEncryptionKeyRepository.new
key_repository.create(user_id = 2137)

res =
  RubyEventStore::Client.new(
    repository: RubyEventStore::InMemoryRepository.new(serializer: JSON),
    mapper: RubyEventStore::Mappers::EncryptionMapper.new(key_repository)
  )
res.append(
  TicketHolderEmailProvided.new(
    data: {
      email: "kaka@dudu.me",
      user_id: user_id
    }
  )
)

This predictably fails on invalid byte sequences in UTF-8:

/Users/mostlyobvious/.gem/ruby/4.0.1/gems/json-2.18.1/lib/json/common.rb:956:in 'JSON::Ext::Generator::State.generate': "\xF2" from ASCII-8BIT to UTF-8 (JSON::GeneratorError)
Invalid object: "\xF2\x19\ekX\x93\x81\x03j\xE4\x95\xF1G\xBB\x1A:\a\x91\x18\xFCV\xA9\xA3Qx\xDC/\x0F\x8A#l\x8E"

As a first step to fix it, let's inline the encryption mapper to see what transformations it consists of. Plus the cure for symbol-vs-string madness in PreserveTypes:

RubyEventStore::Client.new(
  repository:
    RubyEventStore::InMemoryRepository.new(
      serializer: JSON
    ),
  mapper:
    Class
      .new(
        RubyEventStore::Mappers::PipelineMapper
      ) do
        def initialize(key_repository)
          super(
            RubyEventStore::Mappers::Pipeline.new(
              RubyEventStore::Mappers::Transformation::Encryption.new(
                key_repository,
                serializer:
                  RubyEventStore::Serializers::YAML,
                forgotten_data:
                  RubyEventStore::Mappers::ForgottenData.new
              ),
              RubyEventStore::Mappers::Transformation::PreserveTypes.new.register(
                Symbol,
                serializer: ->(v) do
                  v.to_s
                end,
                deserializer: ->(v) do
                  v.to_sym
                end
              ),
              RubyEventStore::Mappers::Transformation::SymbolizeMetadataKeys.new
            )
          )
        end
      end
      .new(key_repository)
)

RubyEventStore::Client.new(
  repository: RubyEventStore::InMemoryRepository.new(serializer: JSON),
  mapper:
    Class
      .new(RubyEventStore::Mappers::PipelineMapper) do
        def initialize(key_repository)
          super(
            RubyEventStore::Mappers::Pipeline.new(
              RubyEventStore::Mappers::Transformation::Encryption.new(
                key_repository,
                serializer: RubyEventStore::Serializers::YAML,
                forgotten_data: RubyEventStore::Mappers::ForgottenData.new
              ),
              RubyEventStore::Mappers::Transformation::PreserveTypes.new.register(
                Symbol,
                serializer: ->(v) { v.to_s },
                deserializer: ->(v) { v.to_sym }
              ),
              RubyEventStore::Mappers::Transformation::SymbolizeMetadataKeys.new
            )
          )
        end
      end
      .new(key_repository)
)

With that in place, let's insert a transformation that encodes the encrypted payload into base64. It's the encoder available in the standard library.

The transformation is bi-directional and we need it right after encryption in the list:

to encode ciphertext right before passing to the storage serializer
to decode base64 text into ciphertext just before decryption when loading a deserialized event from storage

For the record, not only the encrypted data fields need encoding. There's also the initialization vector for the cipher that is stored in the metadata in raw bytes:

#<RubyEventStore::Record:0x0000000124a17730
 @data={email: "\x16\xE8v\xD6\xA1Y\xE1\xED\xF0\xC2#\xBE\xEF\xAF\xAC%\xE6\xB5[o\xF2k\b\x97\xAC\xD4\x8Bj\xD9p\xCA?", user_id: 2137},
 @event_id="4a21667a-20a5-4be3-93be-b69025d2fcdf",
 @event_type="TicketHolderEmailProvided",
 @metadata=
  {correlation_id: "594128fa-c8bc-44b8-b13e-8f8d21ce6825",
   encryption: {email: {cipher: "aes-256-cbc", iv: "R.c\xD1F\x86\x87\x9B\x00\x95\xE7O\x10$\x8B\xF7", identifier: 2137}}},
 @serialized_records={},
 @timestamp=2026-04-01 10:55:01.380733 UTC,
 @valid_at=2026-04-01 10:55:01.380733 UTC>

Here's the transformation to encode binary in its entirety. The record containing event data and metadata is processed according to the encryption schema, which describes what fields are expected to be a ciphertext. Each of these fields has an additional description in the metadata that needs to be taken care of too. On dump there's encoding. On load we're decoding.

RubyEventStore::Client.new(
  repository:
    RubyEventStore::InMemoryRepository.new(
      serializer: JSON
    ),
  mapper:
    Class
      .new(
        RubyEventStore::Mappers::PipelineMapper
      ) do
        def initialize(key_repository)
          super(
            RubyEventStore::Mappers::Pipeline.new(
              RubyEventStore::Mappers::Transformation::Encryption.new(
                key_repository,
                serializer:
                  RubyEventStore::Serializers::YAML,
                forgotten_data:
                  RubyEventStore::Mappers::ForgottenData.new
              ),
              Class
                .new do
                  def dump(record)
                    RubyEventStore::Record.new(
                      event_id:
                        record.event_id,
                      event_type:
                        record.event_type,
                      data:
                        process_data(
                          deep_dup(
                            record.data
                          ),
                          encryption_schema(
                            Object.const_get(
                              record.event_type
                            )
                          ),
                          Base64.method(
                            :strict_encode64
                          )
                        ),
                      metadata:
                        process_metadata(
                          deep_dup(
                            record.metadata
                          ),
                          encryption_schema(
                            Object.const_get(
                              record.event_type
                            )
                          ),
                          Base64.method(
                            :strict_encode64
                          )
                        ),
                      timestamp:
                        record.timestamp,
                      valid_at:
                        record.valid_at
                    )
                  end

                  def load(record)
                    RubyEventStore::Record.new(
                      event_id:
                        record.event_id,
                      event_type:
                        record.event_type,
                      data:
                        process_data(
                          deep_dup(
                            record.data
                          ),
                          encryption_schema(
                            Object.const_get(
                              record.event_type
                            )
                          ),
                          Base64.method(
                            :strict_decode64
                          )
                        ),
                      metadata:
                        process_metadata(
                          deep_dup(
                            record.metadata
                          ),
                          encryption_schema(
                            Object.const_get(
                              record.event_type
                            )
                          ),
                          Base64.method(
                            :strict_decode64
                          )
                        ),
                      timestamp:
                        record.timestamp,
                      valid_at:
                        record.valid_at
                    )
                  end

                  private

                  def encryption_schema(
                    event_class
                  )
                    if event_class.respond_to?(
                         :encryption_schema
                       )
                      event_class.encryption_schema
                    else
                      {}
                    end
                  end

                  def deep_dup(hash)
                    duplicate = hash.dup
                    duplicate.each do |k, v|
                      duplicate[k] = (
                        if v.instance_of?(
                             Hash
                           )
                          deep_dup(v)
                        else
                          v
                        end
                      )
                    end
                  end

                  def process_data(
                    data,
                    schema,
                    method
                  )
                    schema.reduce(
                      data
                    ) do |acc, (key, _)|
                      acc[
                        key
                      ] = method.call(
                        data[key]
                      ) if data.has_key?(
                        key
                      )
                      acc
                    end
                  end

                  def process_metadata(
                    metadata,
                    schema,
                    method
                  )
                    schema.reduce(
                      metadata
                    ) do |acc, (key, _)|
                      acc[:encryption][
                        key
                      ][
                        :iv
                      ] = method.call(
                        metadata[
                          :encryption
                        ][
                          key
                        ][
                          :iv
                        ]
                      ) if metadata[
                        :encryption
                      ].has_key?(key)
                      acc
                    end
                  end
                end
                .new,
              RubyEventStore::Mappers::Transformation::PreserveTypes.new.register(
                Symbol,
                serializer: ->(v) do
                  v.to_s
                end,
                deserializer: ->(v) do
                  v.to_sym
                end
              ),
              RubyEventStore::Mappers::Transformation::SymbolizeMetadataKeys.new
            )
          )
        end
      end
      .new(key_repository)
)

RubyEventStore::Client.new(
  repository: RubyEventStore::InMemoryRepository.new(serializer: JSON),
  mapper:
    Class
      .new(RubyEventStore::Mappers::PipelineMapper) do
        def initialize(key_repository)
          super(
            RubyEventStore::Mappers::Pipeline.new(
              RubyEventStore::Mappers::Transformation::Encryption.new(
                key_repository,
                serializer: RubyEventStore::Serializers::YAML,
                forgotten_data: RubyEventStore::Mappers::ForgottenData.new
              ),
              Class
                .new do
                  def dump(record)
                    RubyEventStore::Record.new(
                      event_id: record.event_id,
                      event_type: record.event_type,
                      data:
                        process_data(
                          deep_dup(record.data),
                          encryption_schema(
                            Object.const_get(record.event_type)
                          ),
                          Base64.method(:strict_encode64)
                        ),
                      metadata:
                        process_metadata(
                          deep_dup(record.metadata),
                          encryption_schema(
                            Object.const_get(record.event_type)
                          ),
                          Base64.method(:strict_encode64)
                        ),
                      timestamp: record.timestamp,
                      valid_at: record.valid_at
                    )
                  end

                  def load(record)
                    RubyEventStore::Record.new(
                      event_id: record.event_id,
                      event_type: record.event_type,
                      data:
                        process_data(
                          deep_dup(record.data),
                          encryption_schema(
                            Object.const_get(record.event_type)
                          ),
                          Base64.method(:strict_decode64)
                        ),
                      metadata:
                        process_metadata(
                          deep_dup(record.metadata),
                          encryption_schema(
                            Object.const_get(record.event_type)
                          ),
                          Base64.method(:strict_decode64)
                        ),
                      timestamp: record.timestamp,
                      valid_at: record.valid_at
                    )
                  end

                  private

                  def encryption_schema(event_class)
                    if event_class.respond_to?(:encryption_schema)
                      event_class.encryption_schema
                    else
                      {}
                    end
                  end

                  def deep_dup(hash)
                    duplicate = hash.dup
                    duplicate.each do |k, v|
                      duplicate[k] = v.instance_of?(Hash) ? deep_dup(v) : v
                    end
                  end

                  def process_data(data, schema, method)
                    schema.reduce(data) do |acc, (key, _)|
                      acc[key] = method.call(data[key]) if data.has_key?(key)
                      acc
                    end
                  end

                  def process_metadata(metadata, schema, method)
                    schema.reduce(metadata) do |acc, (key, _)|
                      acc[:encryption][key][:iv] = method.call(
                        metadata[:encryption][key][:iv]
                      ) if metadata[:encryption].has_key?(key)
                      acc
                    end
                  end
                end
                .new,
              RubyEventStore::Mappers::Transformation::PreserveTypes.new.register(
                Symbol,
                serializer: ->(v) { v.to_s },
                deserializer: ->(v) { v.to_sym }
              ),
              RubyEventStore::Mappers::Transformation::SymbolizeMetadataKeys.new
            )
          )
        end
      end
      .new(key_repository)
)

I don't like how inlining a mapper just to add one transformation made the whole thing awfully verbose and exposed deep namespaces. That's the ugly side of it.

What I wanted to show is that, despite the verbosity, RES is quite malleable when it needs to be adapted to a very specific use case.

I hope this post helps at least one person — Juna, who kindly asked for it on RES Discord and Discussions.

Happy hacking!

Responsive code formatting on web

2026-02-04T10:00:00Z

Responsive Web Design was a hot topic over a decade ago. I'm old enough to remember Nicolas Barrera delivering a talk about it on wroclove.rb. It now feels strange not to design interfaces mobile-first, which is the primary screen for consuming content. And yet, when browsing code samples published online, more often than not we're left with with horizontal scrolls. Or worse, the hidden overflows.

Perhaps programmers prefer consuming programming content on bigger screens. That's me. I read posts with code samples frequently. I'm somewhat active blogger too. Preparing code snippets for publication takes some effort, even for bigger screens. Whether its breaking long lines to make syntactic sense manually or an automated run of code formatter, it is additional work.

Speaking of code formatters, it's unusual nowadays to encounter a project without one. They're convenient tools that parse source code into Abstract Syntax Tree, only to spit it out as text representation once again within a few guiding rules. The main rule being "the width".

I have bandwidth for contract work right now. If there's a Rails problem on your board that keeps getting deprioritized, that's exactly what I'm here for.

One width to rule them all (code editors, Github code diffs).

What if we could make formatters to be a little more helpful, responding to changing screen size? Like if you're on mobile, assume there's only 40 columns of screen available. Split screen on a laptop? Make it 80, for the Vim people who can quit. Everything else — a generous 120 columns. We're still talking Ruby.

Code snippet at 40 columns:

module Processes
  class ReservationProcess
    include Infra::ProcessManager.with_state {
              ProcessState
            }

    subscribes_to(
      Pricing::OfferAccepted,
      Fulfillment::OrderCancelled,
      Fulfillment::OrderConfirmed
    )
  end
end

Code snippet at 80 columns:

module Processes
  class ReservationProcess
    include Infra::ProcessManager.with_state { ProcessState }

    subscribes_to(
      Pricing::OfferAccepted,
      Fulfillment::OrderCancelled,
      Fulfillment::OrderConfirmed
    )
  end
end

Code snipper at 120 columns:

module Processes
  class ReservationProcess
    include Infra::ProcessManager.with_state { ProcessState }

    subscribes_to(Pricing::OfferAccepted, Fulfillment::OrderCancelled, Fulfillment::OrderConfirmed)
  end
end

WebAssembly

Last year I've attended a DRUG meetup where Filip Pacanowski shared his experiments with WebAssembly.

WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable compilation target for programming languages, enabling deployment on the web for client and server applications.

Your web browser has this WASM VM built-in. You could run it standalone on your machine. You can target VMs running on edge computing platforms. It is sandboxed, with quite limited interactions with the interfaces.

That short presentation sparked my interest: what if I could use WASM to format Ruby code, using familiar Ruby code formatter, in the browser? Formatting on the client-side means no work preparing the code for publication earlier. Just a javascript drop-in to progressively enhance the content. Plus I was eager to experiment with WASM myself. Good news — Yuta Saito already ported Ruby VM to WASM.

Packaging Ruby VM for WASM with additional dependencies is pretty straightforward with rbwasm gem:

# Gemfile.wasm
source 'https://rubygems.org'

gem 'js'
gem 'rouge'
gem 'ruby_wasm'
gem 'syntax_tree'

BUNDLE_GEMFILE=Gemfile.wasm bundle exec rbwasm build \
  -o ruby.wasm -build-profile minimal --ruby-version 3.4

Once you have the output binary, here's how you run it in the browser:

<script type="module">
  import { DefaultRubyVM } from "https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.7.1/dist/browser/+esm";
  const response = await fetch("ruby.wasm");
  const module = await WebAssembly.compileStreaming(response);
  const { vm } = await DefaultRubyVM(module);

  const initialSource = document.querySelector("textarea[hidden]")
  const code = document.querySelector("code")

  const format = (breakpoint) => {
    code.innerHTML =
      vm.eval(`
        require "js"
        require "syntax_tree"
        require "rouge"

        max_columns_width =
          case "${breakpoint}"
          when "sm" then 40
          when "md" then 80
          else 120
          end

        Rouge::Formatters::HTML.new.format(
          Rouge::Lexers::Ruby.new.lex(
            SyntaxTree.format(<<~SRC, max_columns_width)
              ${initialSource.value}
            SRC
          )
        )
      `).toString();
  };
</script>

Here's the WASM demo. It reads the lengthy source code from a hidden textarea. Detects screen size changes. When new breakpoint is reached, it outputs formatted and colorized code to the designated container. Width in columns corresponds to the breakpoint. Try resizing the screen and see what happens.

The breakpoint detector:

<script>
  const detectBreakepointChange = (callback) => {
    const widthToBreakpoint = (width) => {
      if      (width < 600)  { return 'sm'; }
      else if (width < 1000) { return 'md'; }
      else                   { return 'lg'; };
    };
    let currentBreakpoint = widthToBreakpoint(window.innerWidth);

    window.addEventListener("resize", () => {
      let breakpoint = widthToBreakpoint(window.innerWidth);

      if (breakpoint != currentBreakpoint) {
        currentBreakpoint = breakpoint;
        callback(breakpoint);
      };
    });
  };
  detectBreakepointChange(format);
</script>

Was the demo smooth? Did you have to wait a bit to get it running? The main problem with client-side formatter running in Ruby VM ported to WebAssembly is the size. Who wants to download 50 MB to read an article? As cool as it initially sounded, this isn't a viable option to adopt.

Hidden DOM elements

When client-side fails, backend to the rescue. Instead of shipping a hefty binary to the browser, let's pre-render the desired breakpoints. Code sample exists as 3 distinct DOM elements and we cycle through them according to current size. The current one is visible, the rest is hidden. We can also rely on CSS media queries, no need for fancy JS breakpoint detector.

The plumbing for nanoc, a static site generator of choice:

hidden_dom_renderer =
  Class.new(Redcarpet::Render::HTML) do
    include Rouge::Plugins::Redcarpet
    prepend(Module.new {
      def block_code(code, language)
        @options.fetch(:widths).map { |width| <<~EOS }.join
          <div data-width="#{width}">
            #{super(SyntaxTree.format(code, width), language)}
          </div>
        EOS
      end
    })
  end

breakpoints = { sm: 40, md: 80, lg: 120 }

compile "/**/hidden_dom.md" do
  filter :erb
  filter :redcarpet,
         options: {
           fenced_code_blocks: true
         },
         renderer: hidden_dom_renderer,
         renderer_options: {
           widths: breakpoints.values
         }
  layout "/hidden_dom.*"
  write item.identifier.without_ext + "/index.html"
end

The media queries:

<style>
  [data-width]       { display: none; }
  [data-width="120"] { display: block; }

  @media (max-width: 999px) {
    [data-width]      { display: none; }
    [data-width="80"] { display: block; }
  }

  @media (max-width: 599px) {
    [data-width]      { display: none; }
    [data-width="40"] { display: block; }
  }
</style>

The hidden DOM demo.

It works. It's simple. And it's boring. Perfect score, would use again.

Is it universally good though or are there some edge cases where it could be problematic? Additional DOM elements for a few code snippets are no harm. Would it be a problem if this was a code diff screen, representing lots of changed files? I can vividly remember Github PR page barely loading on larger pull requests. Would it be smoother with 3 times more DOM elements?

Hotwire and Turbo Frames

I wondered if there's a third code formatting option, that plays well on DOM-heavy pages. If we don't want additional DOM elements on a single document, then let's have multiple documents, each pre-rendered on a backend. When screen size changes and breakpoint activates, we fetch the document that matches current breakpoint and replace code snippets in the DOM tree.

It sounds like a lot of work, but it isn't with Hotwire. There's a Turbo Frames mechanism, that allows predefined parts of a page to be updated on request. If we wrap each code snippet in a <turbo-frame> with unique ID, these snippets will be replaced with matching ones coming from a requested page from the server. Frames can also have src attribute. Its value specifies URL to be loaded when <turbo-frame> tag appears on the page. By manipulating src, we're initiating requests.

Here it is, the final boss. Turbo demo.

Putting it all together, with familiar breakpoint detector:

<script type="module" src="https://cdn.jsdelivr.net/npm/@hotwired/turbo@latest/dist/turbo.es2017-esm.min.js"></script>
<script>
  const format = (breakpoint) =>
    document
      .querySelectorAll("turbo-frame")
      .forEach((el) => { el.src = `/turbo/${breakpoint}/` });

  const detectBreakepointChange = (callback) => {
    const widthToBreakpoint = (width) => {
      if      (width < 600)  { return 'sm'; } 
      else if (width < 1000) { return 'md'; } 
      else                   { return 'lg'; };
    };
    let currentBreakpoint = widthToBreakpoint(window.innerWidth);

    window.addEventListener("resize", () => {
      let breakpoint = widthToBreakpoint(window.innerWidth);

      if (breakpoint != currentBreakpoint) {
        currentBreakpoint = breakpoint;
        callback(breakpoint);
      };
    });
  };
  detectBreakepointChange(format);
</script>

The plumbing for static site generator to generate multiple pages from one source:

turbo_renderer =
  Class.new(Redcarpet::Render::HTML) do
    include Rouge::Plugins::Redcarpet
    prepend(Module.new {
      def block_code(code, language)
        digest = Digest::SHA1.hexdigest(code)
        formatted_code = SyntaxTree.format(code, @options.fetch(:width))

        <<~EOS
          <turbo-frame id="#{digest}">
            #{super(formatted_code, language)}
          </turbo-frame>
        EOS
      end
    })
  end

compile "/**/turbo.md" do
  filter :erb
  filter :redcarpet,
         options: {
           fenced_code_blocks: true
         },
         renderer: turbo_renderer,
         renderer_options: {
           width: breakpoints.values.last
         }
  layout "/turbo.*"
  write item.identifier.without_ext + "/index.html"
end

breakpoints.each do |name, columns|
  compile "/**/turbo.md", rep: name do
    filter :erb
    filter :redcarpet,
           options: {
             fenced_code_blocks: true
           },
           renderer: turbo_renderer,
           renderer_options: {
             width: columns
           }
    layout "/turbo.*"
    write item.identifier.without_ext + "/#{name}/index.html"
  end
end

I know what you're thinking now: each code snippet generates a request to the server. How is this better?

First of all I've used src to make requests out of laziness. It worked good enough for a demo. You can initiate HTTP request for a page with differently sized snippets in other ways. Secondly, the documents cache well in browsers storage. Subsequent GET requests initiated from <turbo-frame> elements to the same resource wouldn't even reach the network.

It requires a JS dependency and a breakpoint detection mechanism. In return — no extra DOM elements. Ideal when this matters the most.

And the winner is...

In the end each of the proposed solutions has its strong points that make it more suitable to particular problem than others. I'm comfortable with pre-rendering on the backend and not looking for a universal drop-in. I'll be sticking with the hidden DOM elements for its lack of any external dependencies and being delightfully boring.