thuban 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f141979f71fdcf5cb0cc8b6678e084569285d9d3ee9f21bf2e584dbeb98a9139
-  data.tar.gz: 9fbdf6deec48a31479b5d2b12f564beeaac8cde969d9f50a68f476d89011e59d
+  metadata.gz: e52056d963a0a6c8bb0ef6efa4b99a5a3dcae5e77f098dda27fd3b3805a4e224
+  data.tar.gz: 8beb8fdd5713ea96004344de2bc6973a09ead85772596de17d76988cd0064589
 SHA512:
-  metadata.gz: b98d9e65ebe84062f9960c19557a871a80344bcbdd9c9bbb77ae9ffe8e30579464249be003a6f26831b76d63436fc4641dd741678eeb24f15b2f668706dc8512
-  data.tar.gz: 4f8eb7a9e0214dcd4e34ce1f08bb8d771c87ad86b428ac5ebe14a26a1bf86502bb6cea8b39d25c14cc475a44e2fdc3d3683d6129e53111599694339fcf03333b
+  metadata.gz: 8014b9b58cdc918c361461ef5100adbdd02243a710587857e0bf9fa7d9c4c23eacfdd04c0bbb96fb251172b2d432754fa35ae363ac13e664562efe360c5b60f1
+  data.tar.gz: efcf26c58b99c870914943fddec1a1b347eb0b40ab29b1074e65fb4074f64f3aae5d464b15a71f78ac2ed3e0a8eeedde4832c2bc32ae2e208df77a60bd5d7758

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.3.0 - 2026-09-15
+
+- Add loose object, tree, and commit writing
+- Add index mutation with v2/v3/v4 encoding and raw optional-extension preservation
+- Add locked loose and packed ref updates with reflogs and optimistic old-OID checks
+- Add index-to-tree commit creation and amend support
+- Add merge-base, reset, and three-way cherry-pick and revert operations
+- Add Git-compatible stash push, list, and three-way pop operations
+- Add delta-free PACK v2 writing with progress and checksum reporting
+
 ## 0.2.0 - 2026-09-14
 
 - Add `Thuban::IgnoreMatcher.load` with Git-compatible ignore source precedence

data/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">Thuban</h1>
 
 <p align="center">
-  <strong>A pure Ruby reader for local Git repositories</strong>
+  <strong>A pure Ruby implementation for local Git repositories</strong>
 </p>
 
 <p align="center">
@@ -22,15 +22,18 @@
 
 ---
 
-Thuban is a pure Ruby Git repository reader for objects, packs, index,
-status, blame, and guarded checkout. It works directly with local repository
-data without invoking the Git executable.
+Thuban is a pure Ruby Git implementation for reading and writing local
+repositories. It works directly with repository data without invoking the Git
+executable.
 
 ## Features
 
 - Reads loose objects and packfiles, including deltified objects
 - Resolves refs, branches, commits, trees, and blobs
 - Reads the index and reports staged, worktree, and untracked changes
+- Writes loose objects, index entries, refs, reflogs, trees, and commits
+- Finds merge bases and performs reset, cherry-pick, revert, and stash operations
+- Writes interoperable delta-free Git packfiles to any writable IO
 - Tracks line history across commits and renames with blame
 - Writes files atomically and checks out branches with collision guards
 - Supports linked worktrees and packed refs
@@ -116,6 +119,82 @@ repo.checkout("feature")
 file atomically. `Repository#checkout` requires a clean tracked worktree and
 aborts on untracked or ignored collisions.
 
+### Stage and Commit
+
+Write a blob, add it to the index, then create a commit from the index:
+
+```ruby
+path = "README.md"
+oid = repo.write_blob(File.binread(path))
+index = repo.index
+index.stage(path, oid, 0o100644, stat: File.stat(path))
+index.write
+
+author = Thuban::Signature.new(
+  name: "Example Author",
+  email: "author@example.com",
+  time: Time.now
+)
+commit = repo.commit!(message: "Update README", author: author)
+```
+
+`Index#write` uses Git's `index.lock`, retains optional extensions as raw bytes,
+and invalidates entry-dependent cache extensions after mutation. `unstage`
+removes the stage-zero entry; stage the corresponding HEAD entry to restore a
+tracked path. `conflicts` exposes stage 1/2/3 entries and `resolve` replaces
+them with a stage-zero entry.
+
+Create and update refs with optimistic old-OID checks:
+
+```ruby
+repo.create_branch("topic", repo.head)
+repo.update_ref("refs/heads/topic", commit, old_oid: repo.head, message: "advance")
+repo.reflog("topic") # raw Git reflog records
+```
+
+Ref mutations use `.lock` files and raise `Thuban::RefLockError` when a lock is
+held or the expected old OID no longer matches. Loose updates override packed
+refs, and deletion removes both forms.
+
+### History and Stash
+
+Use the same branch names, tags, or full object IDs accepted by the read API:
+
+```ruby
+base = repo.merge_base("main", "topic")
+repo.reset(base, mode: :mixed) # :soft and :hard are also supported
+picked = repo.cherry_pick("topic")
+repo.revert(picked)
+
+stash = repo.stash_push(message: "before refactor", include_untracked: true)
+repo.stash_list # newest first, as Commit objects
+repo.stash_pop if stash
+```
+
+Cherry-pick and revert require a clean tracked worktree and accept commits with
+at most one parent. They merge non-overlapping text changes and detect remaining
+three-way conflicts before changing files. Stash uses Git's standard commit and
+reflog layout, retains staged state, and can include untracked files.
+Worktree-changing operations reject submodules and untracked collisions rather
+than silently deleting data.
+
+### Write Packfiles
+
+`Pack.write` accepts `[type, data]` object pairs, reports completed objects to an
+optional block, and returns the hexadecimal pack checksum:
+
+```ruby
+objects = object_ids.map { |oid| repo.object(oid) }
+File.open("out.pack", "wb") do |file|
+  checksum = Thuban::Pack.write(file, objects) do |current, total|
+    warn "#{current}/#{total}"
+  end
+end
+```
+
+The emitted PACK v2 stream stores complete compressed objects without delta
+generation. It can be consumed by `git index-pack` and `git verify-pack`.
+
 ### Match Ignored Paths
 
 Load Git's global excludes, `.git/info/exclude`, and nested `.gitignore` files.
@@ -135,9 +214,11 @@ continuations, and command-scoped overrides are not evaluated.
 
 ## Scope
 
-Thuban does not perform network operations such as fetch or push, rewrite
-history, or provide its own diff algorithm. Blame delegates line matching to
-Porrima through the injectable `differ:` argument.
+The current write API covers loose objects, the index, refs, reflogs, commits,
+guarded checkout, local history operations, stash, and delta-free pack output.
+Thuban does not yet perform network operations, merges, pack delta generation,
+or streaming pack ingestion. It does not provide its own diff algorithm; blame
+delegates line matching to Porrima through the injectable `differ:` argument.
 
 Support is limited to the index and pack formats covered by the test suite.
 Submodule checkout and optional Git extensions outside that coverage are not
@@ -151,6 +232,7 @@ bundle exec rake
 ruby tools/check_isolation.rb
 bundle exec rbs -I sig -r porrima validate
 gem build --strict thuban.gemspec
+ruby bench/pack_write.rb --assert
 ```
 
 ## Contributing

data/lib/thuban/commit_writer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Thuban
+  class Repository
+    def write_tree_from_index
+      current = index
+      raise ArgumentError, "cannot write a tree with unresolved conflicts" unless current.conflicts.empty?
+
+      write_tree_from_entries(current.entries)
+    end
+
+    def commit!(message:, author:, amend: false)
+      previous = head
+      current = previous && commit(previous)
+      raise ArgumentError, "cannot amend an unborn branch" if amend && !current
+
+      parents = amend ? current.parents : previous ? [previous] : []
+      oid = write_commit(tree: write_tree_from_index, parents: parents, author: author, message: message)
+      subject = message.lines.first.to_s.strip
+      action = if amend
+        "commit (amend): #{subject}"
+      elsif previous
+        "commit: #{subject}"
+      else
+        "commit (initial): #{subject}"
+      end
+      update_ref("HEAD", oid, old_oid: previous, message: action)
+      oid
+    end
+
+    private
+
+    def write_tree_from_entries(entries)
+      root = {}
+      entries.each do |entry|
+        node = root
+        parts = entry.path.split("/")
+        raise ArgumentError, "index path nesting exceeds limit" if parts.length > 256
+        parts[0...-1].each do |part|
+          raise ArgumentError, "index contains a file/directory collision" if node.key?(part) && !node[part].is_a?(Hash)
+          node = node[part] ||= {}
+        end
+        raise ArgumentError, "index contains duplicate or colliding paths" if node.key?(parts.last)
+        node[parts.last] = entry
+      end
+      write_index_tree(root)
+    end
+
+    def write_index_tree(node)
+      entries = node.map do |name, value|
+        if value.is_a?(Hash)
+          TreeEntry.new(path: name, oid: write_index_tree(value), mode: 0o040000)
+        else
+          TreeEntry.new(path: name, oid: value.oid, mode: value.mode)
+        end
+      end
+      write_tree(entries)
+    end
+  end
+end

data/lib/thuban/history_writer.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+module Thuban
+  class Repository
+    def merge_base(a, b)
+      left = require_commit(a).oid
+      right = require_commit(b).oid
+      ancestors = {}
+      walk_commits(left) { |oid| ancestors[oid] = true }
+      common = []
+      walk_commits(right) { |oid| common << oid if ancestors[oid] }
+      common_set = common.to_h { |oid| [oid, true] }
+      inferior = {}
+      common.each do |oid|
+        require_commit(oid).parents.each { |parent| inferior[parent] = true if common_set[parent] }
+      end
+      common.find { |oid| !inferior[oid] }
+    end
+
+    def reset(oid, mode: :mixed)
+      raise ArgumentError, "invalid reset mode" unless %i[soft mixed hard].include?(mode)
+
+      target = require_commit(oid)
+      target_tree = tree(target.oid)
+      previous = head
+      RefStore.new(self).update("HEAD", target.oid, old_oid: previous, message: "reset: moving to #{oid}") do
+        case mode
+        when :mixed then replace_index(target_tree)
+        when :hard then replace_repository_state(target_tree, target_tree)
+        end
+      end
+    end
+
+    def cherry_pick(oid)
+      source = require_commit(oid)
+      raise ArgumentError, "cannot cherry-pick a merge commit" if source.parents.length > 1
+
+      base = source.parents.empty? ? {} : tree(source.parents.first)
+      apply_commit_change(source, base, tree(source.oid), author: signature_from(source.author), message: source.message,
+        action: "cherry-pick")
+    end
+
+    def revert(oid)
+      source = require_commit(oid)
+      raise ArgumentError, "cannot revert a merge commit" if source.parents.length > 1
+
+      base = source.parents.empty? ? {} : tree(source.parents.first)
+      subject = source.message.lines.first.to_s.chomp
+      message = "Revert \"#{subject}\"\n\nThis reverts commit #{source.oid}.\n"
+      apply_commit_change(source, tree(source.oid), base, author: operation_signature, message: message, action: "revert")
+    end
+
+    private
+
+    def require_commit(reference)
+      commit(reference) || raise(ArgumentError, "unknown commit: #{reference}")
+    end
+
+    def walk_commits(start)
+      queue = [start]
+      seen = {}
+      cursor = 0
+      while cursor < queue.length
+        oid = queue[cursor]
+        cursor += 1
+        next if seen[oid]
+
+        seen[oid] = true
+        yield oid
+        queue.concat(require_commit(oid).parents)
+      end
+    end
+
+    def apply_commit_change(source, base, incoming, author:, message:, action:)
+      ensure_clean_tracked_state!
+      current_oid = head
+      raise ArgumentError, "cannot apply a commit on an unborn branch" unless current_oid
+
+      current = tree(current_oid)
+      result = apply_tree_change(base, incoming, current, action)
+      raise ArgumentError, "#{action} is empty" if same_tree?(current, result)
+
+      tree_oid = write_tree_from_entries(result.values)
+      commit_oid = write_commit(tree: tree_oid, parents: [current_oid], author: author,
+        committer: operation_signature, message: message)
+      RefStore.new(self).update("HEAD", commit_oid, old_oid: current_oid,
+        message: "#{action}: #{source.message.lines.first.to_s.strip}") do
+        replace_repository_state(result, result)
+      end
+    end
+
+    def apply_tree_change(base, incoming, current, action)
+      result = current.dup
+      conflicts = []
+      (base.keys | incoming.keys).each do |path|
+        original = base[path]
+        ours = current[path]
+        theirs = incoming[path]
+        if same_tree_entry?(ours, original)
+          theirs ? result[path] = theirs : result.delete(path)
+        elsif !same_tree_entry?(ours, theirs) && !same_tree_entry?(original, theirs)
+          merged = merge_tree_entry(original, ours, theirs)
+          merged ? result[path] = merged : conflicts << path
+        end
+      end
+      raise ArgumentError, "#{action} conflicts: #{conflicts.sort.join(', ')}" unless conflicts.empty?
+      result
+    end
+
+    def same_tree?(left, right)
+      left.keys.sort == right.keys.sort && left.all? { |path, entry| same_tree_entry?(entry, right[path]) }
+    end
+
+    def same_tree_entry?(left, right)
+      return left.nil? && right.nil? unless left && right
+
+      left.oid == right.oid && left.mode == right.mode
+    end
+
+    def merge_tree_entry(base, ours, theirs)
+      entries = [base, ours, theirs]
+      return unless entries.all? && entries.all? { |entry| [0o100644, 0o100755].include?(entry.mode) }
+
+      mode = if ours.mode == base.mode then theirs.mode
+      elsif theirs.mode == base.mode || ours.mode == theirs.mode then ours.mode end
+      return unless mode
+
+      contents = entries.map do |entry|
+        type, content = odb.read(entry.oid)
+        raise CorruptObject, "tree entry is not a blob" unless type == "blob"
+
+        content
+      end
+      return if contents.any? { |content| content.include?("\0") }
+
+      merged = Porrima::Merge.three_way(base: contents[0], ours: contents[1], theirs: contents[2])
+      return unless merged.clean?
+
+      TreeEntry.new(path: ours.path, oid: write_blob(merged.sections.join), mode: mode)
+    end
+
+    def ensure_clean_tracked_state!
+      raise ArgumentError, "worktree/index must be clean" if status.any? { |entry| entry.index != "?" }
+    end
+
+    def replace_repository_state(worktree_tree, index_tree, remove_paths: [])
+      raise ArgumentError, "bare repository has no worktree" unless root
+      current_index = index
+      current = current_index.entries.to_h { |entry| [entry.path, entry] }
+      tracked = head ? tree(head).merge(current) : current
+      raise ArgumentError, "submodule updates require separate worktree handling" if
+        (tracked.values + worktree_tree.values + index_tree.values).any? { |entry| entry.mode == 0o160000 }
+
+      removed = (tracked.keys - worktree_tree.keys) | remove_paths
+      check_worktree_collisions(worktree_tree, tracked, removed)
+      contents = worktree_tree.to_h { |path, entry| [path, odb.read(entry.oid).last] }
+      affected = (tracked.keys | worktree_tree.keys | remove_paths)
+      backups = affected.to_h { |path| [path, worktree_backup(path)] }
+      index_path = File.join(git_dir, "index")
+      index_backup = File.file?(index_path) ? [File.binread(index_path), File.stat(index_path).mode & 0o777] : nil
+      lock_path = index_path + ".lock"
+      begin
+        lock = File.open(lock_path, File::WRONLY | File::CREAT | File::EXCL | File::BINARY, 0o644)
+      rescue Errno::EEXIST
+        raise IOError, "Git index is locked: #{lock_path}"
+      end
+      owns_lock = true
+      begin
+        write_worktree_tree(worktree_tree, contents, removed)
+        extensions = current_index.extensions.reject { |extension| Index::ENTRY_DEPENDENT_EXTENSIONS.include?(extension.byteslice(0, 4)) }
+        lock.write(Index.encode(index_entries(index_tree), extensions: extensions, version: current_index.version))
+        lock.flush
+        lock.fsync
+        lock.close
+        File.rename(lock_path, index_path)
+        owns_lock = false
+      rescue StandardError
+        restore_worktree(backups, affected)
+        raise
+      ensure
+        lock&.close unless lock&.closed?
+        File.unlink(lock_path) if owns_lock && File.exist?(lock_path)
+      end
+      -> { restore_repository_state(backups, affected, index_path, index_backup) }
+    end
+
+    def write_worktree_tree(target, contents, removed)
+      removed.sort_by { |path| -path.count("/") }.each do |path|
+        absolute = worktree_path(path)
+        File.unlink(absolute) if File.file?(absolute) || File.symlink?(absolute)
+      end
+      prune_empty_directories(removed)
+      target.sort.each do |path, entry|
+        absolute = worktree_path(path)
+        Dir.rmdir(absolute) if File.directory?(absolute) && !File.symlink?(absolute)
+        FileUtils.mkdir_p(File.dirname(absolute))
+        File.unlink(absolute) if File.file?(absolute) || File.symlink?(absolute)
+        if entry.mode == 0o120000
+          File.symlink(contents.fetch(path), absolute)
+        else
+          atomic_write(absolute, contents.fetch(path), entry.mode & 0o777)
+        end
+      end
+    end
+
+    def worktree_backup(path)
+      absolute = worktree_path(path)
+      return [:symlink, File.readlink(absolute).b] if File.symlink?(absolute)
+      return [:file, File.binread(absolute), File.stat(absolute).mode & 0o777] if File.file?(absolute)
+
+      nil
+    end
+
+    def restore_worktree(backups, affected)
+      affected.sort_by { |path| -path.count("/") }.each do |path|
+        absolute = worktree_path(path)
+        File.unlink(absolute) if File.file?(absolute) || File.symlink?(absolute)
+      end
+      prune_empty_directories(affected)
+      backups.each do |path, backup|
+        next unless backup
+
+        absolute = worktree_path(path)
+        Dir.rmdir(absolute) if File.directory?(absolute) && !File.symlink?(absolute)
+        FileUtils.mkdir_p(File.dirname(absolute))
+        if backup[0] == :symlink
+          File.symlink(backup[1], absolute)
+        else
+          atomic_write(absolute, backup[1], backup[2])
+        end
+      end
+    end
+
+    def restore_repository_state(backups, affected, index_path, index_backup)
+      restore_worktree(backups, affected)
+      if index_backup
+        atomic_write(index_path, *index_backup)
+      elsif File.file?(index_path) || File.symlink?(index_path)
+        File.unlink(index_path)
+      end
+    end
+
+    def check_worktree_collisions(target, current, removed)
+      target.each_key do |path|
+        absolute = worktree_path(path, replacing: removed)
+        unless current.key?(path)
+          if File.directory?(absolute) && !File.symlink?(absolute)
+            Find.find(absolute) do |entry|
+              next if File.directory?(entry) && !File.symlink?(entry)
+              relative = entry.delete_prefix(root + File::SEPARATOR)
+              raise ArgumentError, "untracked worktree collision: #{path}" unless removed.include?(relative)
+            end
+          elsif (File.exist?(absolute) || File.symlink?(absolute)) && !removed.include?(path)
+            raise ArgumentError, "untracked worktree collision: #{path}"
+          end
+        end
+        parent = File.dirname(absolute)
+        until parent == root
+          relative = parent.delete_prefix(root + File::SEPARATOR)
+          if (File.file?(parent) || File.symlink?(parent)) && !removed.include?(relative)
+            raise ArgumentError, "untracked worktree collision: #{relative}"
+          end
+          parent = File.dirname(parent)
+        end
+      end
+    end
+
+    def replace_index(target)
+      current = index
+      backup = File.file?(current.path) ? [File.binread(current.path), File.stat(current.path).mode & 0o777] : nil
+      current.entries.replace(index_entries(target))
+      current.extensions.reject! { |extension| Index::ENTRY_DEPENDENT_EXTENSIONS.include?(extension.byteslice(0, 4)) }
+      current.write
+      -> do
+        if backup
+          atomic_write(current.path, *backup)
+        elsif File.file?(current.path) || File.symlink?(current.path)
+          File.unlink(current.path)
+        end
+      end
+    end
+
+    def index_entries(target)
+      target.sort.map do |path, entry|
+        stat = matching_worktree_stat(path, entry)
+        Index::Entry.new(path: path, oid: entry.oid, mode: entry.mode, size: stat&.size.to_i,
+          mtime: stat&.mtime.to_i, mtime_nsec: stat&.mtime&.nsec.to_i,
+          ctime: stat&.ctime.to_i, ctime_nsec: stat&.ctime&.nsec.to_i,
+          dev: stat&.dev.to_i, ino: stat&.ino.to_i, uid: stat&.uid.to_i, gid: stat&.gid.to_i,
+          stage: 0, flags: 0, extended_flags: 0)
+      end
+    end
+
+    def matching_worktree_stat(path, entry)
+      absolute = worktree_path(path)
+      stat = File.lstat(absolute)
+      mode = stat.symlink? ? 0o120000 : stat.file? ? 0o100000 | ((stat.mode & 0o100).positive? ? 0o755 : 0o644) : 0
+      return unless mode == entry.mode
+
+      content = stat.symlink? ? File.readlink(absolute).b : File.binread(absolute)
+      stat if ObjectDatabase.hash("blob", content) == entry.oid
+    rescue Errno::ENOENT, Errno::ENOTDIR
+      nil
+    end
+
+    def signature_from(value)
+      match = value.to_s.match(/\A(.+) <([^<>]+)> (-?\d+) ([+-]\d{4})\z/)
+      raise CorruptObject, "invalid commit signature" unless match
+
+      Signature.new(name: match[1], email: match[2], time: Integer(match[3]), offset: match[4])
+    end
+
+    def operation_signature
+      RefStore.new(self).send(:reflog_signature)
+    end
+  end
+end

data/lib/thuban/index.rb

@@ -7,11 +7,12 @@ module Thuban
     Entry = Struct.new(:path, :oid, :mode, :size, :mtime, :mtime_nsec, :ctime, :ctime_nsec,
       :dev, :ino, :uid, :gid, :stage, :flags, :extended_flags, keyword_init: true)
     include Enumerable
-    attr_reader :entries, :version, :path
+    attr_reader :entries, :extensions, :version, :path
 
     def initialize(path)
       @path = path
       @entries = []
+      @extensions = []
       @version = 2
       parse(File.binread(path)) if File.file?(path)
     end
@@ -19,18 +20,55 @@ module Thuban
     def each(&block) = entries.each(&block)
     def [](path) = entries.find { |entry| entry.path == path && entry.stage.zero? }
 
-    def self.encode(entries)
-      bytes = +"DIRC".b << [2, entries.length].pack("N2")
+    def self.encode(entries, extensions: [], version: 2)
+      raise ArgumentError, "unsupported Git index version #{version}" unless [2, 3, 4].include?(version)
+      bytes = +"DIRC".b << [version, entries.length].pack("N2")
+      previous = "".b
       entries.sort_by { |entry| [entry.path.b, entry.stage || 0] }.each do |entry|
         name = entry.path.b
+        raise ArgumentError, "unsafe index path" if name.empty? || name.include?("\0") || name.start_with?("/") || name.split("/").any? { |part| ["", "..", ".git"].include?(part) }
+        stage = entry.stage || 0
+        raise ArgumentError, "invalid index stage" unless (0..3).cover?(stage)
         fields = %i[ctime ctime_nsec mtime mtime_nsec dev ino mode uid gid size].map { |field| entry.public_send(field).to_i & 0xffffffff }
-        record = fields.pack("N10") + [entry.oid].pack("H*") + [[name.bytesize, 0xfff].min | ((entry.stage || 0) << 12)].pack("n") + name + "\0"
-        record << "\0" * ((8 - record.bytesize % 8) % 8)
+        raise ArgumentError, "expected a full SHA-1 object id" unless /\A[0-9a-f]{40}\z/.match?(entry.oid.to_s)
+        extended = entry.extended_flags.to_i
+        has_extended = (entry.flags.to_i & 0x4000).positive? || !extended.zero?
+        raise ArgumentError, "extended flags require index version 3 or 4" if has_extended && version == 2
+        flags = (entry.flags.to_i & 0x8000) | [name.bytesize, 0xfff].min | (stage << 12)
+        flags |= 0x4000 if has_extended
+        record = fields.pack("N10") + [entry.oid].pack("H*") + [flags].pack("n")
+        record << [extended].pack("n") if has_extended
+        if version == 4
+          common = 0
+          limit = [previous.bytesize, name.bytesize].min
+          common += 1 while common < limit && previous.getbyte(common) == name.getbyte(common)
+          record << encode_varint(previous.bytesize - common) << name.byteslice(common..) << "\0"
+        else
+          record << name << "\0"
+          record << "\0" * ((8 - record.bytesize % 8) % 8)
+        end
         bytes << record
+        previous = name
+      end
+      extensions.each do |extension|
+        raise ArgumentError, "invalid index extension" unless extension.is_a?(String) && extension.bytesize >= 8
+        size = extension.byteslice(4, 4).unpack1("N")
+        raise ArgumentError, "invalid index extension" unless extension.bytesize == size + 8 && extension.byteslice(0, 1).match?(/[A-Z]/)
+        bytes << extension.b
       end
-      bytes + Digest::SHA1.digest(bytes)
+      bytes << Digest::SHA1.digest(bytes)
     end
 
+    def self.encode_varint(value)
+      bytes = [value & 0x7f]
+      while (value >>= 7).positive?
+        value -= 1
+        bytes << (0x80 | (value & 0x7f))
+      end
+      bytes.reverse.pack("C*")
+    end
+    private_class_method :encode_varint
+
     private
 
     def parse(bytes)
@@ -79,6 +117,7 @@ module Thuban
           flags: flags, extended_flags: extended, stage: (flags >> 12) & 3)
       end
       while offset < bytes.bytesize - 20
+        start = offset
         raise CorruptObject, "truncated index extension" if offset + 8 > bytes.bytesize - 20
         signature = bytes[offset, 4]
         size = bytes[offset + 4, 4].unpack1("N")
@@ -86,6 +125,7 @@ module Thuban
         raise CorruptObject, "unsupported mandatory index extension #{signature}" if signature[0].match?(/[a-z]/)
         offset += 8 + size
         raise CorruptObject, "truncated index extension payload" if offset > bytes.bytesize - 20
+        extensions << bytes.byteslice(start, 8 + size).dup.freeze
       end
     end
   end