diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 05d6155..493112e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -66,15 +66,23 @@ jobs:
             ~/.cache/gamba-tools
             ~/.cache/apt-archives
           key: gamba-${{ runner.os }}-${{ hashFiles('corpus/manifest.yml', '.github/workflows/ci.yml') }}
+          # A change to this file starts from the previous cache: without its packages, the fallback below has none.
+          restore-keys: gamba-${{ runner.os }}-
       # 2026-11-04: Azure's Ubuntu mirror stalls for minutes on libmupdf (34 MB), which cancelled whole jobs: the
       # packages come from the cache, and a stalled attempt is cut after 90 seconds and resumed.
+      # 2026-11-11: the mirror stopped answering apt-get update for hours: the cached packages are then installed
+      # as they are.
       - name: Install the PDF tools
         timeout-minutes: 6
         run: |
           mkdir -p ~/.cache/apt-archives/partial
           for attempt in 1 2 3; do
-            sudo timeout 90 apt-get update && sudo timeout 90 apt-get install --yes \
-              -o Dir::Cache::Archives="$HOME/.cache/apt-archives" mupdf-tools poppler-utils qpdf && break
+            if sudo timeout 90 apt-get update; then
+              sudo timeout 90 apt-get install --yes \
+                -o Dir::Cache::Archives="$HOME/.cache/apt-archives" mupdf-tools poppler-utils qpdf && break
+            else
+              sudo dpkg --install ~/.cache/apt-archives/*.deb && break
+            fi
             test "$attempt" -lt 3 || exit 1
           done
           sudo chown -R "$USER" ~/.cache/apt-archives
diff --git a/README.md b/README.md
index 5923587..d81cad1 100644
--- a/README.md
+++ b/README.md
@@ -44,6 +44,22 @@ version of the API Gamba reproduces, for code that checks it. Gamba's own versio
 
 Anything that would change how a page looks compared with Prawn is off until you ask for it.
 
+An API of its own, next to Prawn's. The block receives the document instead of running inside it, options are
+keywords, and a mistyped one raises instead of being ignored:
+
+```ruby
+document = Gamba.document(page_size: "A4", lang: "en") do |document|
+  document.style :title, size: 18, weight: :bold
+  document.text "Invoice INV-2026-0001", style: :title
+  document.draw InvoiceLines.new(invoice) # any object with call(document)
+end
+document.write("invoice.pdf")
+```
+
+Code written for Prawn adopts it one block at a time, `gamba { |document| document.text "Total", style: :title }`,
+and `document.prawn` gives a native document all of Prawn's API. Text, styles and components are there today;
+layout comes next ([the plan](https://github.com/levups/gamba/issues/69)).
+
 Ligatures and kerning from OpenType fonts, per font:
 
 ```ruby
diff --git a/docs/guide.html b/docs/guide.html
index dcc33df..06aaf9b 100644
--- a/docs/guide.html
+++ b/docs/guide.html
@@ -33,10 +33,11 @@
   <main id="main">
     <header>
       <h1 class="page-title">Guide</h1>
-      <p class="lede">Gamba answers to Prawn’s API: installing it is swapping gems. This page covers what it brings on top.</p>
+      <p class="lede">Gamba answers to Prawn’s API: installing it is swapping gems. This page covers what it brings on top, and its own API, which existing code adopts one block at a time.</p>
       <ul class="toc">
         <li><a href="#installation">Installation</a></li>
         <li><a href="#usage">Drop-in usage</a></li>
+        <li><a href="#native">Gamba’s own API</a></li>
         <li><a href="#tables">Tables</a></li>
         <li><a href="#svg">SVG</a></li>
         <li><a href="#fonts">Fonts</a></li>
@@ -75,6 +76,33 @@ <h2 id="usage-title">Drop-in usage</h2>
       </div>
     </section>
 
+    <section id="native" aria-labelledby="native-title">
+      <h2 id="native-title">Gamba’s own API</h2>
+      <div class="prose">
+        <p><code>Gamba.document</code> writes a document without Prawn’s conventions. The block receives the document instead of running inside it, so your own methods and instance variables stay in reach. Options are keywords, and a mistyped one raises an <code>ArgumentError</code> that lists the accepted ones, where Prawn ignores it.</p>
+<pre><code class="language-ruby"><span class="nb">require</span> <span class="s2">"gamba"</span>
+
+<span class="n">document</span> <span class="o">=</span> <span class="no">Gamba</span><span class="p">.</span><span class="nf">document</span><span class="p">(</span><span class="ss">page_size: </span><span class="s2">"A4"</span><span class="p">,</span> <span class="ss">margin: </span><span class="mi">36</span><span class="p">,</span> <span class="ss">lang: </span><span class="s2">"en"</span><span class="p">)</span> <span class="k">do</span> <span class="o">|</span><span class="n">document</span><span class="o">|</span>
+  <span class="n">document</span><span class="p">.</span><span class="nf">register_font</span> <span class="s2">"Inter"</span><span class="p">,</span> <span class="ss">normal: </span><span class="s2">"Inter.ttf"</span><span class="p">,</span> <span class="ss">bold: </span><span class="s2">"Inter-Bold.ttf"</span>
+  <span class="n">document</span><span class="p">.</span><span class="nf">style</span> <span class="ss">:default</span><span class="p">,</span> <span class="ss">font: </span><span class="s2">"Inter"</span><span class="p">,</span> <span class="ss">size: </span><span class="mi">10</span>
+  <span class="n">document</span><span class="p">.</span><span class="nf">style</span> <span class="ss">:title</span><span class="p">,</span> <span class="ss">size: </span><span class="mi">18</span><span class="p">,</span> <span class="ss">weight: :bold</span>
+
+  <span class="n">document</span><span class="p">.</span><span class="nf">text</span> <span class="s2">"Invoice INV-2026-0001"</span><span class="p">,</span> <span class="ss">style: :title</span>
+  <span class="n">document</span><span class="p">.</span><span class="nf">text</span> <span class="s2">"Due on 1 December 2026"</span><span class="p">,</span> <span class="ss">color: </span><span class="s2">"666666"</span>
+  <span class="n">document</span><span class="p">.</span><span class="nf">draw</span> <span class="no">InvoiceLines</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="n">invoice</span><span class="p">)</span>
+<span class="k">end</span>
+<span class="n">document</span><span class="p">.</span><span class="nf">write</span><span class="p">(</span><span class="s2">"invoice.pdf"</span><span class="p">)</span> <span class="c1"># or an IO; document.to_s gives the bytes</span></code></pre>
+        <p>A style names text attributes (<code>font</code>, <code>size</code>, <code>weight</code>, <code>italic</code>, <code>color</code>, <code>align</code>, <code>leading</code>); the <code>:default</code> style applies to every text, and what a call passes wins over its style. <code>draw</code> takes any object that answers <code>call(document)</code>, so a document is made of small classes you can test one by one. Fonts registered here use their ligatures and kerning: there is no Prawn page to match. Pass <code>features: []</code> to <code>register_font</code> to turn them off.</p>
+        <p>You don’t have to rewrite anything to start. In code written for Prawn, <code>gamba</code> opens a native block at the cursor, and leaves the cursor below what it drew:</p>
+<pre><code class="language-ruby"><span class="no">Prawn</span><span class="o">::</span><span class="no">Document</span><span class="p">.</span><span class="nf">generate</span><span class="p">(</span><span class="s2">"report.pdf"</span><span class="p">)</span> <span class="k">do</span>
+  <span class="n">text</span> <span class="s2">"Existing code, unchanged"</span>
+  <span class="n">gamba</span> <span class="p">{</span> <span class="o">|</span><span class="n">document</span><span class="o">|</span> <span class="n">document</span><span class="p">.</span><span class="nf">text</span> <span class="s2">"A first native block"</span><span class="p">,</span> <span class="ss">size: </span><span class="mi">18</span><span class="p">,</span> <span class="ss">weight: :bold</span> <span class="p">}</span>
+  <span class="n">text</span> <span class="s2">"More existing code"</span>
+<span class="k">end</span></code></pre>
+        <p>The other way round, <code>document.prawn</code> is the <code>Prawn::Document</code> underneath, with all of Prawn’s API: tables, images, SVG and graphics go through it until the native API covers them. This API is guarded like Prawn’s: <code>test/contract/gamba.yml</code> lists every public method with its signature.</p>
+      </div>
+    </section>
+
     <section id="tables" aria-labelledby="tables-title">
       <h2 id="tables-title">Tables</h2>
       <div class="prose">
diff --git a/lib/gamba.rb b/lib/gamba.rb
index c3da300..588f38d 100644
--- a/lib/gamba.rb
+++ b/lib/gamba.rb
@@ -98,6 +98,15 @@ class Font
 
 module Gamba
   autoload :Combine, ::File.expand_path("gamba/combine", __dir__)
+  autoload :Document, ::File.expand_path("gamba/native/document", __dir__)
+
+  # A document written with Gamba's own API: Gamba.document(page_size: "A4") { |document| document.text "Hello" }.
+  # See Gamba::Document::OPTIONS for the options; Prawn's API stays reachable through Gamba::Document#prawn.
+  def self.document(**options)
+    document = Document.new(**options)
+    yield document if block_given?
+    document
+  end
 
   # The pages of other PDF files, one after the other in a new one:
   # Gamba.combine([label, label], page_size: [288, 432]). See Gamba::Combine#initialize for the options.
@@ -108,7 +117,7 @@ def self.combine(sources, page_size: nil, orientation: nil)
   # Loads what Gamba otherwise loads on first use, SVG support included: call it before a server forks its
   # workers, so they share that memory instead of each loading its own copy.
   def self.eager_load!
-    [TrueType::File, TrueType::Subset, Prawn::Fonts::TTF, Combine, PDF::Core::Reader]
+    [TrueType::File, TrueType::Subset, Prawn::Fonts::TTF, Combine, PDF::Core::Reader, Document]
     require "prawn-svg"
   end
 end
diff --git a/lib/gamba/document.rb b/lib/gamba/document.rb
index 54a40e5..1bf3b5b 100644
--- a/lib/gamba/document.rb
+++ b/lib/gamba/document.rb
@@ -17,7 +17,7 @@ class Document
 
     VALID_OPTIONS = %i[
       page_size page_layout margin left_margin right_margin top_margin bottom_margin skip_page_creation compress
-      background info text_formatter print_scaling pdf_a
+      background info text_formatter print_scaling pdf_a lang
     ].freeze
 
     attr_accessor :margin_box, :page_number, :text_formatter
@@ -161,6 +161,13 @@ def render_file(filename)
       File.binwrite(filename, render)
     end
 
+    # Gamba's own API on this document, from the cursor where it stands: gamba { |document| document.text "…" }.
+    def gamba
+      @gamba ||= Gamba::Document.new(self)
+      yield @gamba if block_given?
+      @gamba
+    end
+
     def bounds
       @bounding_box
     end
diff --git a/lib/gamba/document/internals.rb b/lib/gamba/document/internals.rb
index 73723f4..2f1065c 100644
--- a/lib/gamba/document/internals.rb
+++ b/lib/gamba/document/internals.rb
@@ -227,6 +227,7 @@ def initialize_internals(options)
         @pages_reference = ref!(Type: :Pages, Count: 0, Kids: [])
         @root.data[:Pages] = @pages_reference
         @root.data[:ViewerPreferences] = {PrintScaling: :None} if options[:print_scaling] == :none
+        @root.data[:Lang] = PDF::Core::LiteralString.new(options[:lang]) if options[:lang]
         @version = 1.3
         # One entry per save not yet restored, document-wide.
         @unrestored_graphics_states = []
diff --git a/lib/gamba/native/document.rb b/lib/gamba/native/document.rb
new file mode 100644
index 0000000..913b9c1
--- /dev/null
+++ b/lib/gamba/native/document.rb
@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Gamba
+  # Gamba's own API, over a Prawn::Document that stays reachable through #prawn. Blocks receive this object,
+  # options are keywords, and an unknown one raises instead of being ignored.
+  class Document
+    OPTIONS = %i[
+      page_size page_layout margin left_margin right_margin top_margin bottom_margin background info print_scaling
+      pdf_a lang
+    ].freeze
+    TEXT_ATTRIBUTES = %i[font size weight italic color align leading].freeze
+    FONT_STYLES = %i[normal bold italic bold_italic].freeze
+    # No Prawn page to match here, so fonts that have ligatures and GPOS kerning use them.
+    DEFAULT_FONT_FEATURES = %i[liga kern].freeze
+    DEFAULT_STYLE = :default
+
+    attr_reader :prawn
+
+    def initialize(prawn = nil, **options)
+      @styles = {}
+      @prawn = prawn || new_prawn_document(options)
+    end
+
+    def register_font(family, normal:, bold: nil, italic: nil, bold_italic: nil, features: DEFAULT_FONT_FEATURES)
+      files = {normal:, bold:, italic:, bold_italic:}.compact
+      prawn.font_families[family] = files.transform_values { |file| {file:, features:} }
+      self
+    end
+
+    # Text attributes under a name: text "…", style: name. The :default style applies to every text.
+    def style(name, **attributes)
+      check_options(attributes, TEXT_ATTRIBUTES)
+      @styles[name] = attributes.freeze
+      self
+    end
+
+    def text(string, style: nil, **attributes)
+      check_options(attributes, TEXT_ATTRIBUTES)
+      attributes = {**@styles.fetch(DEFAULT_STYLE, {}), **named_style(style), **attributes}
+      font = attributes.delete(:font)
+      options = prawn_text_options(attributes)
+      if font
+        prawn.font(font, prawn.font_families.key?(font) ? {} : {features: DEFAULT_FONT_FEATURES}) { prawn.text(string, options) }
+      else
+        prawn.text(string, options)
+      end
+      self
+    end
+
+    # Draws anything that answers call(document): a document is made of small objects, each tested alone.
+    def draw(component)
+      component.call(self)
+      self
+    end
+
+    def to_s
+      prawn.render
+    end
+
+    def write(destination)
+      if destination.respond_to?(:write)
+        destination.write(to_s)
+      else
+        File.binwrite(destination, to_s)
+      end
+      self
+    end
+
+    private
+
+    def new_prawn_document(options)
+      check_options(options, OPTIONS)
+      Prawn::Document.new(options)
+    end
+
+    def named_style(name)
+      return {} unless name
+
+      @styles.fetch(name) do
+        raise ArgumentError, "unknown style #{name.inspect}: defined styles are #{@styles.keys.map(&:inspect).join(", ")}"
+      end
+    end
+
+    def prawn_text_options(attributes)
+      weight = attributes.delete(:weight) || :normal
+      raise ArgumentError, "weight is #{weight.inspect}: accepted weights are :normal, :bold" unless %i[normal bold].include?(weight)
+
+      font_style = FONT_STYLES[((weight == :bold) ? 1 : 0) + (attributes.delete(:italic) ? 2 : 0)]
+      attributes[:style] = font_style unless font_style == :normal
+      attributes.compact
+    end
+
+    def check_options(given, accepted)
+      unknown = given.keys - accepted
+      return if unknown.empty?
+
+      raise ArgumentError, "unknown option#{"s" if unknown.size > 1} #{unknown.map(&:inspect).join(", ")}: " \
+        "accepted options are #{accepted.map(&:inspect).join(", ")}"
+    end
+  end
+end
diff --git a/test/contract/gamba.yml b/test/contract/gamba.yml
new file mode 100644
index 0000000..a8e045d
--- /dev/null
+++ b/test/contract/gamba.yml
@@ -0,0 +1,17 @@
+# Gamba's own public API, as Method#parameters gives it. test/native_contract_test.rb fails when a method listed here
+# changes its signature, and when a public method of these classes is missing from the list: a change here is a
+# decision, breaking when it removes or narrows something.
+Gamba:
+  ".combine": [req sources, key page_size, key orientation]
+  ".document": [keyrest options]
+  ".eager_load!": []
+Gamba::Document:
+  "#draw": [req component]
+  "#prawn": []
+  "#register_font": [req family, keyreq normal, key bold, key italic, key bold_italic, key features]
+  "#style": [req name, keyrest attributes]
+  "#text": [req string, key style, keyrest attributes]
+  "#to_s": []
+  "#write": [req destination]
+Prawn::Document:
+  "#gamba": []
diff --git a/test/native_contract_test.rb b/test/native_contract_test.rb
new file mode 100644
index 0000000..ed7bac8
--- /dev/null
+++ b/test/native_contract_test.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "prawn"
+require "yaml"
+
+# Gamba's own API is guarded like Prawn's: test/contract/gamba.yml lists every public method and its signature.
+class NativeContractTest < Minitest::Test
+  API = YAML.load_file(File.join(__dir__, "contract/gamba.yml"))
+  # Classes whose every public method is in the contract; Prawn::Document only lists what Gamba adds to Prawn's.
+  WHOLLY_LISTED = {"Gamba" => :singleton, "Gamba::Document" => :instance}.freeze
+
+  API.each do |class_name, methods|
+    methods.each do |method_name, parameters|
+      define_method("test_#{class_name}#{method_name}") do
+        assert_equal parameters, signature(class_name, method_name)
+      end
+    end
+  end
+
+  def test_every_public_method_is_in_the_contract
+    WHOLLY_LISTED.each do |class_name, kind|
+      owner = Object.const_get(class_name)
+      public_names = (kind == :singleton) ? owner.singleton_methods(false).map { ".#{_1}" } : owner.public_instance_methods(false).map { "##{_1}" }
+
+      assert_empty public_names - API.fetch(class_name).keys, "list each one in test/contract/gamba.yml"
+    end
+  end
+
+  private
+
+  def signature(class_name, method_name)
+    owner = Object.const_get(class_name)
+    name = method_name.delete_prefix("#").delete_prefix(".").to_sym
+    method = method_name.start_with?(".") ? owner.method(name) : owner.instance_method(name)
+    method.parameters.map { |kind, parameter_name| [kind, parameter_name].compact.join(" ") }
+  end
+end
diff --git a/test/native_document_test.rb b/test/native_document_test.rb
new file mode 100644
index 0000000..f2feb3c
--- /dev/null
+++ b/test/native_document_test.rb
@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "prawn"
+require "open3"
+require "stringio"
+
+# Gamba.document, Gamba's own API over a Prawn document, and Prawn::Document#gamba, which opens it inside Prawn code.
+class NativeDocumentTest < Minitest::Test
+  FONT = File.join(Oracle::ROOT, "corpus/cache/prawn/data/fonts/DejaVuSans.ttf")
+  BOLD_FONT = File.join(Oracle::ROOT, "corpus/cache/prawn/data/fonts/DejaVuSans-Bold.ttf")
+
+  def test_the_block_receives_the_document_and_keeps_its_own_self
+    @greeting = "Hello"
+    document = Gamba.document { |yielded| yielded.text @greeting }
+
+    assert_instance_of Gamba::Document, document
+    assert_equal "Hello", glyphs(document.to_s).map(&:first).join
+  end
+
+  def test_an_unknown_document_option_raises_with_the_accepted_ones
+    error = assert_raises(ArgumentError) { Gamba.document(page_sise: "A4") }
+
+    assert_equal "unknown option :page_sise: accepted options are #{Gamba::Document::OPTIONS.map(&:inspect).join(", ")}", error.message
+  end
+
+  def test_an_unknown_text_attribute_raises_with_the_accepted_ones
+    error = assert_raises(ArgumentError) { Gamba.document.text("Hello", colour: "ff0000", sise: 3) }
+
+    assert_match(/\Aunknown options :colour, :sise: accepted options are :font, :size, :weight, :italic, :color, :align, :leading\z/, error.message)
+  end
+
+  def test_an_unknown_style_attribute_raises_when_the_style_is_defined
+    assert_raises(ArgumentError) { Gamba.document.style(:title, sise: 18) }
+  end
+
+  def test_an_undefined_style_raises_with_the_defined_ones
+    document = Gamba.document
+    document.style :title, size: 18
+    error = assert_raises(ArgumentError) { document.text "Hello", style: :titel }
+
+    assert_equal "unknown style :titel: defined styles are :title", error.message
+  end
+
+  def test_an_unknown_weight_raises
+    assert_raises(ArgumentError) { Gamba.document.text("Hello", weight: :heavy) }
+  end
+
+  def test_a_named_style_sets_what_the_call_leaves_out
+    document = Gamba.document
+    document.style :title, size: 18, weight: :bold
+    document.text "A", style: :title
+    document.text "B", style: :title, size: 9, italic: true
+    document.text "C"
+
+    assert_equal [["A", "Helvetica-Bold", 18.0], ["B", "Helvetica-BoldOblique", 9.0], ["C", "Helvetica", 12.0]], glyphs(document.to_s).map { _1.first(3) }
+  end
+
+  def test_the_default_style_applies_to_every_text
+    document = Gamba.document
+    document.style :default, font: "Courier", size: 10
+    document.style :title, size: 18
+    document.text "A"
+    document.text "B", style: :title
+
+    assert_equal [["A", "Courier", 10.0], ["B", "Courier", 18.0]], glyphs(document.to_s).map { _1.first(3) }
+  end
+
+  def test_a_native_call_draws_what_the_prawn_call_draws
+    native = Gamba.document(margin: 50) { |document| document.text "Hello", size: 18, color: "ff0000", align: :right, weight: :bold }
+    prawn = Prawn::Document.new(margin: 50) { text "Hello", size: 18, color: "ff0000", align: :right, style: :bold }
+
+    assert_equal prawn.render, native.to_s
+  end
+
+  def test_lang_is_written_in_the_catalog
+    assert_includes uncompressed(Gamba.document(lang: "fr-FR").to_s), "/Lang (fr-FR)"
+    assert_includes uncompressed(Prawn::Document.new(lang: "en").render), "/Lang (en)"
+    refute_includes uncompressed(Prawn::Document.new.render), "/Lang"
+  end
+
+  def test_draw_calls_the_component_with_the_document
+    component = ->(document) { document.text "Drawn" }
+    document = Gamba.document
+
+    assert_same document, document.draw(component)
+    assert_equal "Drawn", glyphs(document.to_s).map(&:first).join
+  end
+
+  def test_write_takes_a_path_or_an_io
+    document = Gamba.document { |yielded| yielded.text "Hello" }
+    io = StringIO.new
+    document.write(io)
+
+    Dir.mktmpdir do |directory|
+      path = File.join(directory, "hello.pdf")
+      document.write(path)
+
+      assert_equal io.string.b, File.binread(path)
+    end
+    assert io.string.start_with?("%PDF-")
+  end
+
+  def test_prawn_is_the_document_underneath
+    document = Gamba.document
+    document.prawn.text "From Prawn"
+    document.text "From Gamba"
+
+    assert_equal "From PrawnFrom Gamba", glyphs(document.to_s).map(&:first).join
+  end
+
+  def test_a_gamba_block_in_prawn_code_draws_from_the_cursor_and_leaves_it_below
+    bridged = Prawn::Document.new do
+      text "Before"
+      gamba { |document| document.text "Native", size: 18 }
+      text "After"
+    end
+    plain = Prawn::Document.new do
+      text "Before"
+      text "Native", size: 18
+      text "After"
+    end
+
+    assert_equal plain.render, bridged.render
+  end
+
+  def test_gamba_blocks_of_one_prawn_document_share_their_styles
+    pdf = Prawn::Document.new do
+      gamba { |document| document.style :title, size: 18 }
+      gamba { |document| document.text "A", style: :title }
+    end
+
+    assert_equal [["A", "Helvetica", 18.0]], glyphs(pdf.render).map { _1.first(3) }
+  end
+
+  def test_a_registered_font_uses_its_ligatures_and_kerning_in_every_face
+    skip CORPUS_MISSING_MESSAGE unless File.exist?(FONT)
+    native = Gamba.document do |document|
+      document.register_font "DejaVu", normal: FONT, bold: BOLD_FONT
+      document.style :default, font: "DejaVu"
+      document.text "AVATAR office"
+      document.text "AVATAR office", weight: :bold
+    end
+    prawn = Prawn::Document.new
+    prawn.font_families.update("DejaVu" => {normal: FONT, bold: BOLD_FONT})
+    prawn.font("DejaVu")
+    prawn.text "AVATAR office"
+    prawn.text "AVATAR office", style: :bold
+
+    native_lines = glyphs(native.to_s).slice_when { |previous, following| previous.last != following.last }.to_a
+    prawn_lines = glyphs(prawn.render).slice_when { |previous, following| previous.last != following.last }.to_a
+
+    assert_equal 2, native_lines.size
+    native_lines.zip(prawn_lines).each do |native_line, prawn_line|
+      assert_equal "AVATAR office", native_line.map(&:first).join
+      assert_operator native_line.last[3], :<, prawn_line.last[3], "kerning and the fi ligature bring the last glyph closer"
+    end
+  end
+
+  def test_a_font_given_by_its_file_uses_its_ligatures_and_kerning
+    skip CORPUS_MISSING_MESSAGE unless File.exist?(FONT)
+    native = Gamba.document { |document| document.text "AVATAR office", font: FONT }
+    prawn = Prawn::Document.new { font(FONT) { text "AVATAR office" } }
+
+    assert_operator glyphs(native.to_s).last[3], :<, glyphs(prawn.render).last[3]
+  end
+
+  def test_a_registered_font_can_turn_its_features_off
+    skip CORPUS_MISSING_MESSAGE unless File.exist?(FONT)
+    native = Gamba.document do |document|
+      document.register_font "DejaVu", normal: FONT, features: []
+      document.text "AVATAR office", font: "DejaVu"
+    end
+    prawn = Prawn::Document.new do
+      font_families.update("DejaVu" => {normal: FONT})
+      font("DejaVu") { text "AVATAR office" }
+    end
+
+    assert_equal glyphs(prawn.render), glyphs(native.to_s)
+  end
+
+  private
+
+  def uncompressed(pdf)
+    Tempfile.create(["native", ".pdf"]) do |file|
+      file.binmode
+      file.write(pdf)
+      file.flush
+      Open3.capture2("qpdf", "--qdf", "--object-streams=disable", file.path, "-").first
+    end
+  end
+
+  def glyphs(pdf)
+    Tempfile.create(["native", ".pdf"]) do |file|
+      file.binmode
+      file.write(pdf)
+      file.flush
+      Oracle.text_layout(file.path).flat_map(&:glyphs)
+    end
+  end
+end