@@ -55,12 +55,31 @@
  """
  @spec diff(list(), list()) :: [edit()]
  def diff(a, b) when is_list(a) and is_list(b) do
    if a == b do
      Enum.map(a, &{:eq, &1})
    else
      {prefix_eqs, a_mid, b_mid} = strip_list_prefix(a, b, [])
      {suffix_eqs, a_mid, b_mid} = strip_list_suffix(a_mid, b_mid, [])
      middle_edits =
        cond do
          a_mid == [] and b_mid == [] ->
            []
          a_mid == [] ->
            Enum.map(b_mid, &{:ins, &1})
          b_mid == [] ->
            Enum.map(a_mid, &{:del, &1})
    a_vec = List.to_tuple(a)
    b_vec = List.to_tuple(b)
          true ->
            a_vec = List.to_tuple(a_mid)
            b_vec = List.to_tuple(b_mid)
            diff_range(a_vec, b_vec, 0, tuple_size(a_vec), 0, tuple_size(b_vec))
        end
    n = tuple_size(a_vec)
    m = tuple_size(b_vec)
      prefix_eqs ++ middle_edits ++ suffix_eqs
    end
    diff_range(a_vec, b_vec, 0, n, 0, m)
  end
  @doc """
@@ -79,40 +98,81 @@
    if lines_a == lines_b do
      Enum.map(lines_a, &{:eq, &1})
    else
      {map_a, count_a} =
        Enum.reduce(lines_a, {%{}, 0}, fn line, {map, count} ->
          case map do
            %{^line => _id} -> {map, count}
            _ -> {Map.put(map, line, count), count + 1}
          end
        end)
      {prefix_eqs, lines_a_mid, lines_b_mid} = strip_list_prefix(lines_a, lines_b, [])
      {suffix_eqs, lines_a_mid, lines_b_mid} = strip_list_suffix(lines_a_mid, lines_b_mid, [])
      {full_map, total_unique} =
        Enum.reduce(lines_b, {map_a, count_a}, fn line, {map, count} ->
          case map do
            %{^line => _id} -> {map, count}
            _ -> {Map.put(map, line, count), count + 1}
      middle_edits =
        cond do
          lines_a_mid == [] and lines_b_mid == [] ->
            []
          end
        end)
      id_to_line = :erlang.make_tuple(total_unique, nil)
          lines_a_mid == [] ->
            Enum.map(lines_b_mid, &{:ins, &1})
      id_to_line =
          lines_b_mid == [] ->
            Enum.map(lines_a_mid, &{:del, &1})
        Enum.reduce(full_map, id_to_line, fn {line, id}, tup ->
          :erlang.setelement(id + 1, tup, line)
        end)
          true ->
      ints_a = Enum.map(lines_a, &Map.fetch!(full_map, &1))
      ints_b = Enum.map(lines_b, &Map.fetch!(full_map, &1))
            {map_a, count_a} =
              Enum.reduce(lines_a_mid, {%{}, 0}, fn line, {map, count} ->
                case map do
                  %{^line => _id} -> {map, count}
                  _ -> {Map.put(map, line, count), count + 1}
                end
              end)
            {full_map, total_unique} =
              Enum.reduce(lines_b_mid, {map_a, count_a}, fn line, {map, count} ->
                case map do
                  %{^line => _id} -> {map, count}
                  _ -> {Map.put(map, line, count), count + 1}
                end
              end)
            id_to_line = :erlang.make_tuple(total_unique, nil)
            id_to_line =
              Enum.reduce(full_map, id_to_line, fn {line, id}, tup ->
                :erlang.setelement(id + 1, tup, line)
              end)
            ints_a = Enum.map(lines_a_mid, &Map.fetch!(full_map, &1))
            ints_b = Enum.map(lines_b_mid, &Map.fetch!(full_map, &1))
      edits = diff(ints_a, ints_b)
            edits = diff(ints_a, ints_b)
      Enum.map(edits, fn
        {:eq, id} -> {:eq, elem(id_to_line, id)}
        {:ins, id} -> {:ins, elem(id_to_line, id)}
        {:del, id} -> {:del, elem(id_to_line, id)}
      end)
            Enum.map(edits, fn
              {:eq, id} -> {:eq, elem(id_to_line, id)}
              {:ins, id} -> {:ins, elem(id_to_line, id)}
              {:del, id} -> {:del, elem(id_to_line, id)}
            end)
        end
      prefix_eqs ++ middle_edits ++ suffix_eqs
    end
  end
  defp strip_list_prefix([h | t1], [h | t2], acc) do
    strip_list_prefix(t1, t2, [{:eq, h} | acc])
  end
  defp strip_list_prefix(l1, l2, acc) do
    {Enum.reverse(acc), l1, l2}
  end
  defp strip_list_suffix(l1, l2, acc) do
    r1 = Enum.reverse(l1)
    r2 = Enum.reverse(l2)
    {suffix_eqs, rem_r1, rem_r2} = do_strip_list_suffix(r1, r2, acc)
    {suffix_eqs, Enum.reverse(rem_r1), Enum.reverse(rem_r2)}
  end
  defp do_strip_list_suffix([h | t1], [h | t2], acc) do
    do_strip_list_suffix(t1, t2, [{:eq, h} | acc])
  end
  defp do_strip_list_suffix(l1, l2, acc) do
    {acc, l1, l2}
  end
  # ── Recursive driver ──────────────────────────────────────────────────

@@ -107,82 +107,82 @@
    end
  end
  # -- Step 3: topological generation + CCD in a single Kahn's-algorithm
  #    pass over the reverse adjacency (parents → children). --
  # -- Step 3: topological generation + CCD in a single memoized DFS pass. --
  defp compute_generations_and_ccd(raw) do
    shas = Map.keys(raw)
    children_of = build_children_index(raw)
    in_deg = Map.new(shas, fn sha -> {sha, length(raw[sha].parents)} end)
    {entries_map, _memo} =
      Enum.reduce(shas, {%{}, %{}}, fn sha, {acc_entries, memo} ->
        {entry, memo} = compute_entry(sha, raw, memo)
    roots = for {sha, 0} <- in_deg, do: sha
    {gen, ccd} = topo_process(raw, children_of, in_deg, roots, %{}, %{})
    entries =
      Map.new(raw, fn {sha, %{tree: tree, parents: parents, commit_time: ct}} ->
        {Map.put(acc_entries, sha, entry), memo}
        {sha,
         %Entry{
           tree: tree,
           parents: parents,
           generation: Map.fetch!(gen, sha),
           corrected_commit_date: Map.fetch!(ccd, sha),
           commit_time: ct
         }}
      end)
    %Graph{version: 1, shas: Enum.sort(shas), by_sha: entries}
  end
  defp build_children_index(raw) do
    Enum.reduce(raw, %{}, fn {child_sha, %{parents: parents}}, acc ->
      Enum.reduce(parents, acc, fn parent_sha, acc2 ->
        Map.update(acc2, parent_sha, [child_sha], &[child_sha | &1])
      end)
    end)
    %Graph{version: 1, shas: Enum.sort(shas), by_sha: entries_map}
  end
  defp compute_entry(sha, raw, memo) do
    case memo do
      %{^sha => entry} ->
        {entry, memo}
  defp topo_process(_raw, _children_of, _in_deg, [], gen, ccd), do: {gen, ccd}
      _ ->
        case Map.get(raw, sha) do
          nil ->
            # Unreachable or missing parent edge
            entry = %Entry{
              tree: "",
  defp topo_process(raw, children_of, in_deg, [sha | rest], gen, ccd) do
    %{parents: parents, commit_time: ct} = Map.fetch!(raw, sha)
              parents: [],
              generation: 1,
              corrected_commit_date: 0,
              commit_time: 0
            }
    my_gen =
      case parents do
        [] -> 1
            {entry, Map.put(memo, sha, entry)}
        _ -> 1 + Enum.max(Enum.map(parents, &Map.fetch!(gen, &1)))
      end
    my_ccd =
      case parents do
        [] -> ct
        _ -> Enum.max([ct | Enum.map(parents, &Map.fetch!(ccd, &1))])
          %{tree: tree, parents: parents, commit_time: ct} ->
            {parent_entries, memo} =
              Enum.map_reduce(parents, memo, fn p_sha, acc_memo ->
                compute_entry(p_sha, raw, acc_memo)
              end)
      end
            my_gen =
              case parent_entries do
                [] -> 1
    gen = Map.put(gen, sha, my_gen)
                _ -> 1 + Enum.max(Enum.map(parent_entries, & &1.generation))
              end
    ccd = Map.put(ccd, sha, my_ccd)
            my_ccd =
              case parent_entries do
                [] -> ct
    children = Map.get(children_of, sha, [])
                _ -> Enum.max([ct | Enum.map(parent_entries, & &1.corrected_commit_date)])
              end
    {in_deg, newly_ready} =
      Enum.reduce(children, {in_deg, []}, fn child, {deg_acc, ready_acc} ->
        new_deg = Map.fetch!(deg_acc, child) - 1
        deg_acc = Map.put(deg_acc, child, new_deg)
            entry = %Entry{
              tree: tree,
              parents: parents,
              generation: my_gen,
              corrected_commit_date: my_ccd,
              commit_time: ct
            }
        if new_deg == 0 do
          {deg_acc, [child | ready_acc]}
        else
            {entry, Map.put(memo, sha, entry)}
          {deg_acc, ready_acc}
        end
      end)
    end
    topo_process(raw, children_of, in_deg, rest ++ newly_ready, gen, ccd)
  end
  # "Name <email> <timestamp> <tz>" — extract trailing unix timestamp.
  # "Name <email> <timestamp> <tz>" — match the trailing unix timestamp.
  defp parse_timestamp(str) when is_binary(str) do
    case Regex.run(~r/(\d+)\s+[+-]\d{4}$/, str) do
      [_, ts] -> String.to_integer(ts)
      _ -> 0
    case :binary.split(str, " ", [:global]) do
      parts when length(parts) >= 2 ->
        ts_str = Enum.at(parts, -2)
        case Integer.parse(ts_str) do
          {ts, ""} -> ts
          _ -> 0
        end
      _ ->
        0
    end
  end

@@ -44,37 +44,41 @@
  """
  @spec merge_commits(Repo.t(), String.t(), String.t(), keyword()) ::
          {:ok, String.t()} | {:error, term()}
  def merge_commits(%Repo{} = repo, ours_sha, theirs_sha, _opts \\ []) do
    with {:ok, base_sha} <- Walk.merge_base(repo, ours_sha, theirs_sha),
         {:ok, %Commit{tree: base_tree}} <- ObjectResolver.read(repo, base_sha),
         {:ok, %Commit{tree: ours_tree}} <- ObjectResolver.read(repo, ours_sha),
         {:ok, %Commit{tree: theirs_tree}} <- ObjectResolver.read(repo, theirs_sha) do
      merge_trees(repo, base_tree, ours_tree, theirs_tree)
  def merge_commits(%Repo{} = repo, ours_sha, theirs_sha, opts \\ []) do
    if ours_sha == theirs_sha do
      {:ok, ours_sha}
    else
      with {:ok, base_sha} <- Walk.merge_base(repo, ours_sha, theirs_sha),
           {:ok, %Commit{tree: base_tree}} <- ObjectResolver.read(repo, base_sha),
           {:ok, %Commit{tree: ours_tree}} <- ObjectResolver.read(repo, ours_sha),
           {:ok, %Commit{tree: theirs_tree}} <- ObjectResolver.read(repo, theirs_sha) do
        merge_trees(repo, base_tree, ours_tree, theirs_tree, opts)
      end
    end
  end
  @doc """
  Three-way merge of tree objects.
  Walks all three trees in parallel, applying standard three-way merge rules:
  - Entry identical in all three -> keep
  - Changed in ours only -> take ours
  - Changed in theirs only -> take theirs
  - Changed identically in both -> take either
  - Changed differently in both -> conflict (blobs) or recurse (subtrees)
  - Added in one side only -> add
  - Deleted in one side, unchanged in other -> delete
  - Deleted in one side, changed in other -> conflict
  Returns `{:ok, merged_tree_sha}` on clean merge, or
  `{:error, {:conflicts, [conflict()]}}` if there are conflicts.
  """
  @spec merge_trees(Repo.t(), String.t(), String.t(), String.t()) ::
  @spec merge_trees(Repo.t(), String.t(), String.t(), String.t(), keyword()) ::
          {:ok, String.t()} | {:error, term()}
  def merge_trees(repo, base_tree_sha, ours_tree_sha, theirs_tree_sha, opts \\ [])
  def merge_trees(_repo, base_tree_sha, base_tree_sha, theirs_tree_sha, _opts),
    do: {:ok, theirs_tree_sha}
  def merge_trees(_repo, base_tree_sha, ours_tree_sha, base_tree_sha, _opts),
    do: {:ok, ours_tree_sha}
  def merge_trees(%Repo{} = repo, base_tree_sha, ours_tree_sha, theirs_tree_sha) do
  def merge_trees(_repo, _base_tree_sha, same_tree_sha, same_tree_sha, _opts),
    do: {:ok, same_tree_sha}
  def merge_trees(%Repo{} = repo, base_tree_sha, ours_tree_sha, theirs_tree_sha, opts) do
    write? = Keyword.get(opts, :write, true)
    with {:ok, base_tree} <- read_tree(repo, base_tree_sha),
         {:ok, ours_tree} <- read_tree(repo, ours_tree_sha),
         {:ok, theirs_tree} <- read_tree(repo, theirs_tree_sha) do
      merge_tree_entries(repo, base_tree, ours_tree, theirs_tree, "", 0)
      merge_tree_entries(repo, base_tree, ours_tree, theirs_tree, "", 0, write?)
    end
  end
@@ -89,63 +93,148 @@
    end
  end
  defp merge_tree_entries(
         _repo,
         _base_tree,
         _ours_tree,
         _theirs_tree,
         _path_prefix,
         depth,
         _write?
       )
  # Merge tree entries from all three sides
  defp merge_tree_entries(_repo, _base_tree, _ours_tree, _theirs_tree, _path_prefix, depth)
       when depth > @max_tree_depth do
    {:error, :max_tree_depth_exceeded}
  end
  defp merge_tree_entries(repo, base_tree, ours_tree, theirs_tree, path_prefix, depth) do
    base_map = entries_to_map(base_tree.entries)
    ours_map = entries_to_map(ours_tree.entries)
    theirs_map = entries_to_map(theirs_tree.entries)
  defp merge_tree_entries(repo, base_tree, ours_tree, theirs_tree, path_prefix, depth, write?) do
    try do
      {merged_entries, conflicts} =
        do_merge_tree_walk(
          repo,
          base_tree.entries,
          ours_tree.entries,
          theirs_tree.entries,
          path_prefix,
          depth,
          write?,
          [],
          []
        )
      if conflicts == [] do
        if write? do
          tree = Tree.new(Enum.reverse(merged_entries))
          Object.write(repo, tree)
        else
          {:ok, "clean"}
    # Collect all unique entry names across all three trees
    all_names =
      [Map.keys(base_map), Map.keys(ours_map), Map.keys(theirs_map)]
      |> List.flatten()
      |> Enum.uniq()
      |> Enum.sort()
        end
      else
        {:error, {:conflicts, Enum.reverse(conflicts)}}
      end
    catch
      {:error, _} = err -> err
    end
  end
  defp do_merge_tree_walk(
         _repo,
         [],
         [],
         [],
         _prefix,
         _depth,
         _write?,
         entries_acc,
         conflicts_acc
       ) do
    {entries_acc, conflicts_acc}
  end
  defp do_merge_tree_walk(
         repo,
         base_entries,
         ours_entries,
         theirs_entries,
         path_prefix,
         depth,
         write?,
         entries_acc,
    # Process each entry
    {merged_entries, conflicts} =
      Enum.reduce(all_names, {[], []}, fn name, {entries_acc, conflicts_acc} ->
        base_entry = Map.get(base_map, name)
        ours_entry = Map.get(ours_map, name)
         conflicts_acc
       ) do
    min_name = min_entry_name(base_entries, ours_entries, theirs_entries)
        theirs_entry = Map.get(theirs_map, name)
        full_path = join_path(path_prefix, name)
    {base_entry, next_base} = pop_matching_entry(base_entries, min_name)
    {ours_entry, next_ours} = pop_matching_entry(ours_entries, min_name)
        case merge_entry(repo, base_entry, ours_entry, theirs_entry, full_path, depth) do
          {:keep, entry} ->
            {[entry | entries_acc], conflicts_acc}
    {theirs_entry, next_theirs} = pop_matching_entry(theirs_entries, min_name)
    full_path = join_path(path_prefix, min_name)
    case merge_entry(repo, base_entry, ours_entry, theirs_entry, full_path, depth, write?) do
      {:keep, entry} ->
        do_merge_tree_walk(
          repo,
          next_base,
          next_ours,
          :delete ->
            {entries_acc, conflicts_acc}
          next_theirs,
          path_prefix,
          depth,
          write?,
          [entry | entries_acc],
          conflicts_acc
        )
      :delete ->
        do_merge_tree_walk(
          repo,
          next_base,
          next_ours,
          next_theirs,
          {:conflict, conflict} ->
            {entries_acc, [conflict | conflicts_acc]}
          path_prefix,
          depth,
          write?,
          entries_acc,
          conflicts_acc
        )
      {:conflict, conflict} ->
        do_merge_tree_walk(
          repo,
          next_base,
          next_ours,
          next_theirs,
          path_prefix,
          {:error, _} = err ->
            throw(err)
          depth,
          write?,
          entries_acc,
          [conflict | conflicts_acc]
        )
        end
      end)
    if conflicts == [] do
      # Write the merged tree
      tree = Tree.new(Enum.reverse(merged_entries))
      Object.write(repo, tree)
      {:error, _} = err ->
        throw(err)
    else
      {:error, {:conflicts, Enum.reverse(conflicts)}}
    end
  catch
    {:error, _} = err -> err
  end
  defp min_entry_name([b | _], [o | _], [t | _]) do
    min(b.name, min(o.name, t.name))
  end
  defp min_entry_name([b | _], [o | _], []), do: min(b.name, o.name)
  defp min_entry_name([b | _], [], [t | _]), do: min(b.name, t.name)
  defp min_entry_name([], [o | _], [t | _]), do: min(o.name, t.name)
  defp min_entry_name([b | _], [], []), do: b.name
  defp min_entry_name([], [o | _], []), do: o.name
  defp min_entry_name([], [], [t | _]), do: t.name
  defp pop_matching_entry([%{name: name} = entry | rest], name), do: {entry, rest}
  defp pop_matching_entry(entries, _name), do: {nil, entries}
  # Three-way merge logic for a single entry.
  # Delegates to classify_change to determine the merge action, then applies it.
  defp merge_entry(repo, base, ours, theirs, path, depth, write?) do
  defp merge_entry(repo, base, ours, theirs, path, depth) do
    case classify_change(base, ours, theirs) do
      {:keep_or_delete, entry} ->
        keep_or_delete(entry)
      {:keep_or_delete, entry} -> keep_or_delete(entry)
      :both_changed_differently -> resolve_divergent(repo, base, ours, theirs, path, depth)
      :both_changed_differently ->
        resolve_divergent(repo, base, ours, theirs, path, depth, write?)
    end
  end
@@ -159,17 +248,17 @@
    end
  end
  defp resolve_divergent(repo, base, ours, theirs, path, depth) do
  defp resolve_divergent(repo, base, ours, theirs, path, depth, write?) do
    cond do
      both_are_trees?(ours, theirs) and (base == nil or tree_entry?(base)) ->
        merge_subtrees(repo, base, ours, theirs, path, depth, write?)
        merge_subtrees(repo, base, ours, theirs, path, depth)
      # Both sides changed the same regular file. Tree-level equality already
      # ruled out "identical change", so attempt a line-level (diff3) merge
      # before declaring a conflict — non-overlapping edits merge cleanly,
      # matching `git merge-file`.
      mergeable_blobs?(base, ours, theirs) ->
        merge_blobs(repo, base, ours, theirs, path)
        merge_blobs(repo, base, ours, theirs, path, write?)
      true ->
        {:conflict, build_conflict(path, base, ours, theirs)}
@@ -187,13 +276,13 @@
  defp regular_file?(%{mode: mode}), do: mode in ["100644", "100755"]
  defp regular_file?(_), do: false
  defp merge_blobs(repo, base, ours, theirs, path, write?) do
  defp merge_blobs(repo, base, ours, theirs, path) do
    with {:ok, mode} <- merge_mode(base, ours, theirs),
         {:ok, base_content} <- blob_content(repo, base),
         {:ok, ours_content} <- blob_content(repo, ours),
         {:ok, theirs_content} <- blob_content(repo, theirs),
         {:ok, merged} <- Diff3.merge(base_content, ours_content, theirs_content) do
      write_merged_entry(repo, merged, ours.name, mode, write?)
      write_merged_entry(repo, merged, ours.name, mode)
    else
      :conflict -> {:conflict, build_conflict(path, base, ours, theirs)}
      :mode_conflict -> {:conflict, build_conflict(path, base, ours, theirs)}
@@ -201,7 +290,11 @@
    end
  end
  defp write_merged_entry(_repo, _merged, name, mode, false) do
    {:keep, %{mode: mode, name: name, sha: "clean"}}
  end
  defp write_merged_entry(repo, merged, name, mode) do
  defp write_merged_entry(repo, merged, name, mode, true) do
    case Object.write(repo, Blob.from_content(merged)) do
      {:ok, sha} -> {:keep, %{mode: mode, name: name, sha: sha}}
      {:error, _} = err -> err
@@ -242,12 +335,12 @@
    }
  end
  defp merge_subtrees(repo, base, ours, theirs, path, depth) do
  defp merge_subtrees(repo, base, ours, theirs, path, depth, write?) do
    # For recursive subtree merge, we need actual tree objects
    with {:ok, base_sha} <- empty_tree_or_sha(repo, base),
         {:ok, base_tree} <- read_tree(repo, base_sha),
         {:ok, ours_tree} <- read_tree(repo, ours.sha),
         {:ok, theirs_tree} <- read_tree(repo, theirs.sha) do
      case merge_tree_entries(repo, base_tree, ours_tree, theirs_tree, path, depth + 1) do
      case merge_tree_entries(repo, base_tree, ours_tree, theirs_tree, path, depth + 1, write?) do
        {:ok, merged_sha} ->
          {:keep, %{mode: ours.mode, name: ours.name, sha: merged_sha}}
@@ -267,10 +360,6 @@
  end
  defp empty_tree_or_sha(_repo, entry), do: {:ok, entry.sha}
  defp entries_to_map(entries) do
    Map.new(entries, fn entry -> {entry.name, entry} end)
  end
  defp same_entry?(nil, nil), do: true
  defp same_entry?(nil, _), do: false

@@ -65,16 +65,27 @@
  @spec merge(binary(), binary(), binary()) :: {:ok, binary()} | :conflict
  def merge(base, ours, theirs)
      when is_binary(base) and is_binary(ours) and is_binary(theirs) do
    if binary?(base) or binary?(ours) or binary?(theirs) do
      :conflict
    else
      base_lines = split(base)
      ours_lines = split(ours)
      theirs_lines = split(theirs)
    cond do
      base == ours ->
        {:ok, theirs}
      base == theirs ->
        {:ok, ours}
      case merge_lines(base_lines, ours_lines, theirs_lines) do
      ours == theirs ->
        {:ok, ours}
      binary?(base) or binary?(ours) or binary?(theirs) ->
        :conflict
      true ->
        base_lines = split(base)
        ours_lines = split(ours)
        theirs_lines = split(theirs)
        case merge_lines(base_lines, ours_lines, theirs_lines) do
          {:ok, merged} -> {:ok, Enum.join(merged, "\n")}
          :conflict -> :conflict
        end
        {:ok, merged} -> {:ok, Enum.join(merged, "\n")}
        :conflict -> :conflict
      end
    end
  end
@@ -112,13 +123,18 @@
          {:clean, nil} | {:conflict, [region()]} | :binary
  def conflict_regions(base, ours, theirs)
      when is_binary(base) and is_binary(ours) and is_binary(theirs) do
    cond do
      base == ours or base == theirs or ours == theirs ->
        {:clean, nil}
      binary?(base) or binary?(ours) or binary?(theirs) ->
        :binary
      true ->
        regions =
          for {:conflict, region} <- segments(split(base), split(ours), split(theirs)),
              do: region
    if binary?(base) or binary?(ours) or binary?(theirs) do
      :binary
    else
      regions =
        for {:conflict, region} <- segments(split(base), split(ours), split(theirs)),
            do: region
        if regions == [], do: {:clean, nil}, else: {:conflict, regions}
      if regions == [], do: {:clean, nil}, else: {:conflict, regions}
    end
  end
@@ -146,17 +162,28 @@
          {:clean, binary()} | {:conflict, binary()} | :binary
  def merge_markers(base, ours, theirs, opts \\ [])
      when is_binary(base) and is_binary(ours) and is_binary(theirs) do
    if binary?(base) or binary?(ours) or binary?(theirs) do
      :binary
    else
      segs = segments(split(base), split(ours), split(theirs))
      conflicted? = Enum.any?(segs, &match?({:conflict, _}, &1))
    cond do
      base == ours ->
        {:clean, theirs}
      body =
        segs
        |> Enum.flat_map(&render_segment(&1, opts))
        |> Enum.join("\n")
      base == theirs ->
        {:clean, ours}
      ours == theirs ->
        {:clean, ours}
      if conflicted?, do: {:conflict, body}, else: {:clean, body}
      binary?(base) or binary?(ours) or binary?(theirs) ->
        :binary
      true ->
        segs = segments(split(base), split(ours), split(theirs))
        conflicted? = Enum.any?(segs, &match?({:conflict, _}, &1))
        body =
          segs
          |> Enum.flat_map(&render_segment(&1, opts))
          |> Enum.join("\n")
        if conflicted?, do: {:conflict, body}, else: {:clean, body}
    end
  end
@@ -292,15 +319,26 @@
  # Build %{base_index => side_index} for lines unchanged between base and side.
  # Reconstructs positions by replaying the Myers edit script in order.
  defp match_map(base, side) do
    if base == side do
      len = length(base)
    base
    |> Myers.diff(side)
    |> slide_down()
    |> Enum.reduce({0, 0, %{}}, fn
      {:eq, _}, {bi, si, acc} -> {bi + 1, si + 1, Map.put(acc, bi, si)}
      {:del, _}, {bi, si, acc} -> {bi + 1, si, acc}
      {:ins, _}, {bi, si, acc} -> {bi, si + 1, acc}
    end)
    |> elem(2)
      if len == 0 do
        %{}
      else
        0..(len - 1)
        |> Enum.reduce(%{}, fn i, acc -> Map.put(acc, i, i) end)
      end
    else
      base
      |> Myers.diff(side)
      |> slide_down()
      |> Enum.reduce({0, 0, %{}}, fn
        {:eq, _}, {bi, si, acc} -> {bi + 1, si + 1, Map.put(acc, bi, si)}
        {:del, _}, {bi, si, acc} -> {bi + 1, si, acc}
        {:ins, _}, {bi, si, acc} -> {bi, si + 1, acc}
      end)
      |> elem(2)
    end
  end
  # Canonicalize a Myers edit script by sliding each insertion/deletion as far

@@ -52,6 +52,8 @@
  def log(%Repo{} = repo, start_sha, opts \\ []) do
    max_count = Keyword.get(opts, :max_count, :infinity)
    skip = Keyword.get(opts, :skip, 0)
    path = Keyword.get(opts, :path)
    path_components = parse_path_filter(path)
    emit_limit =
      case max_count do
@@ -61,7 +63,7 @@
    case seed_queue(repo, start_sha) do
      {:ok, queue, seen} ->
        {:ok, commits} = walk(repo, queue, seen, [], 0, emit_limit)
        {:ok, commits} = walk(repo, queue, seen, [], 0, emit_limit, path_components, %{})
        {:ok, apply_skip_and_limit(commits, skip, max_count)}
      {:error, _} = err ->
@@ -80,15 +82,20 @@
  ## Options
    * `:max_count` — page size (default: 20)
    * `:path` — filter commits that modified the given file or directory path
  """
  @spec log_page(Repo.t(), String.t(), keyword()) ::
          {:ok, [{String.t(), Commit.t()}], [String.t()]} | {:error, term()}
  def log_page(%Repo{} = repo, start_sha, opts \\ []) do
    max_count = Keyword.get(opts, :max_count, 20)
    path = Keyword.get(opts, :path)
    path_components = parse_path_filter(path)
    case seed_queue(repo, start_sha) do
      {:ok, queue, seen} ->
        {commits, remaining} = walk_page(repo, queue, seen, [], 0, max_count)
        {commits, remaining} =
          walk_page(repo, queue, seen, [], 0, max_count, path_components, %{})
        {:ok, commits, queue_to_cursor(remaining)}
      {:error, _} = err ->
@@ -104,6 +111,7 @@
  ## Options
    * `:max_count` — page size (default: 20)
    * `:path` — filter commits that modified the given file or directory path
  """
  @spec log_continue(Repo.t(), [String.t()], keyword()) ::
          {:ok, [{String.t(), Commit.t()}], [String.t()]} | {:error, term()}
@@ -111,12 +119,19 @@
  def log_continue(%Repo{} = repo, cursor_shas, opts) when is_list(cursor_shas) do
    max_count = Keyword.get(opts, :max_count, 20)
    path = Keyword.get(opts, :path)
    path_components = parse_path_filter(path)
    {:ok, queue, seen} = cursor_to_queue(repo, cursor_shas)
    {commits, remaining} = walk_page(repo, queue, seen, [], 0, max_count)
    {commits, remaining} = walk_page(repo, queue, seen, [], 0, max_count, path_components, %{})
    {:ok, commits, queue_to_cursor(remaining)}
  end
  defp parse_path_filter(nil), do: nil
  defp parse_path_filter(""), do: nil
  defp parse_path_filter("/"), do: nil
  defp parse_path_filter(path) when is_binary(path), do: String.split(path, "/", trim: true)
  defp apply_skip_and_limit(commits, 0, :infinity), do: commits
  defp apply_skip_and_limit(commits, skip, max_count) do
@@ -187,11 +202,12 @@
        ts_a = parse_timestamp(ca.committer)
        ts_b = parse_timestamp(cb.committer)
        queue = [{ts_a, sha_a}, {ts_b, sha_b}]
        queue = [{ts_a, sha_a, ca}, {ts_b, sha_b, cb}]
        queue = Enum.sort_by(queue, &elem(&1, 0), :desc)
        reachable = %{sha_a => :a, sha_b => :b}
        cache = %{sha_a => ca, sha_b => cb}
        merge_base_walk(repo, queue, reachable)
        merge_base_walk(repo, queue, reachable, cache)
      {{:error, _} = err, _} ->
        err
@@ -214,57 +230,197 @@
  # The queue is a descending-sorted list — insert_sorted maintains the
  # invariant, equivalent to git's commit_list_insert_by_date().
  defp walk(_repo, [], _seen, acc, _count, _limit) do
  defp walk(_repo, [], _seen, acc, _count, _limit, _path_comps, _cache) do
    {:ok, Enum.reverse(acc)}
  end
  defp walk(_repo, _queue, _seen, acc, count, limit)
  defp walk(_repo, _queue, _seen, acc, count, limit, _path_comps, _cache)
       when is_integer(limit) and count >= limit do
    {:ok, Enum.reverse(acc)}
  end
  defp walk(repo, [{_ts, sha, commit} | rest], seen, acc, count, limit) do
    {queue, seen} = enqueue_parents(repo, commit.parents, rest, seen)
    walk(repo, queue, seen, [{sha, commit} | acc], count + 1, limit)
  defp walk(repo, [{_ts, sha, commit} | rest], seen, acc, count, limit, nil, cache) do
    {queue, seen, cache} = enqueue_parents(repo, commit.parents, rest, seen, cache)
    walk(repo, queue, seen, [{sha, commit} | acc], count + 1, limit, nil, cache)
  end
  # Like walk/6 but returns {commits, remaining_queue} for cursor pagination.
  defp walk_page(_repo, [], _seen, acc, _count, _limit) do
  defp walk(repo, [{_ts, sha, commit} | rest], seen, acc, count, limit, path_comps, cache) do
    cache = Map.put(cache, sha, commit)
    {changed?, parents_to_follow, cache} = check_path_change(repo, commit, path_comps, cache)
    {queue, seen, cache} = enqueue_parents(repo, parents_to_follow, rest, seen, cache)
    if changed? do
      walk(repo, queue, seen, [{sha, commit} | acc], count + 1, limit, path_comps, cache)
    else
      walk(repo, queue, seen, acc, count, limit, path_comps, cache)
    end
  end
  # Like walk/8 but returns {commits, remaining_queue} for cursor pagination.
  defp walk_page(_repo, [], _seen, acc, _count, _limit, _path_comps, _cache) do
    {Enum.reverse(acc), []}
  end
  defp walk_page(_repo, queue, _seen, acc, count, limit)
  defp walk_page(_repo, queue, _seen, acc, count, limit, _path_comps, _cache)
       when is_integer(limit) and count >= limit do
    {Enum.reverse(acc), queue}
  end
  defp walk_page(repo, [{_ts, sha, commit} | rest], seen, acc, count, limit, nil, cache) do
    {queue, seen, cache} = enqueue_parents(repo, commit.parents, rest, seen, cache)
    walk_page(repo, queue, seen, [{sha, commit} | acc], count + 1, limit, nil, cache)
  end
  defp walk_page(repo, [{_ts, sha, commit} | rest], seen, acc, count, limit, path_comps, cache) do
    cache = Map.put(cache, sha, commit)
    {changed?, parents_to_follow, cache} = check_path_change(repo, commit, path_comps, cache)
    {queue, seen, cache} = enqueue_parents(repo, parents_to_follow, rest, seen, cache)
  defp walk_page(repo, [{_ts, sha, commit} | rest], seen, acc, count, limit) do
    {queue, seen} = enqueue_parents(repo, commit.parents, rest, seen)
    walk_page(repo, queue, seen, [{sha, commit} | acc], count + 1, limit)
    if changed? do
      walk_page(repo, queue, seen, [{sha, commit} | acc], count + 1, limit, path_comps, cache)
    else
      walk_page(repo, queue, seen, acc, count, limit, path_comps, cache)
    end
  end
  defp enqueue_parents(_repo, [], queue, seen), do: {queue, seen}
  defp enqueue_parents(_repo, [], queue, seen, cache), do: {queue, seen, cache}
  defp enqueue_parents(repo, [parent_sha | rest_parents], queue, seen) do
  defp enqueue_parents(repo, [parent_sha | rest_parents], queue, seen, cache) do
    if MapSet.member?(seen, parent_sha) do
      enqueue_parents(repo, rest_parents, queue, seen)
      enqueue_parents(repo, rest_parents, queue, seen, cache)
    else
      {queue, seen} = enqueue_one_parent(repo, parent_sha, queue, seen)
      enqueue_parents(repo, rest_parents, queue, seen)
      {queue, seen, cache} = enqueue_one_parent(repo, parent_sha, queue, seen, cache)
      enqueue_parents(repo, rest_parents, queue, seen, cache)
    end
  end
  defp enqueue_one_parent(repo, sha, queue, seen) do
    case ObjectResolver.read(repo, sha) do
      {:ok, %Commit{} = commit} ->
  defp enqueue_one_parent(repo, sha, queue, seen, cache) do
    case get_cached_commit(repo, sha, cache) do
      {%Commit{} = commit, cache} ->
        ts = parse_timestamp(commit.committer)
        {insert_sorted(queue, {ts, sha, commit}), MapSet.put(seen, sha)}
        {insert_sorted(queue, {ts, sha, commit}), MapSet.put(seen, sha), cache}
      _ ->
        {queue, seen}
        {queue, seen, cache}
    end
  end
  # History simplification with TREESAME check for path filtering
  defp check_path_change(repo, commit, path_comps, cache) do
    case commit.parents do
      [] ->
        {entry, cache} = get_tree_path_entry(repo, commit.tree, path_comps, cache)
        {entry != nil, [], cache}
      [parent_sha] ->
        {parent_commit, cache} = get_cached_commit(repo, parent_sha, cache)
        if parent_commit && commit.tree == parent_commit.tree do
          {false, [parent_sha], cache}
        else
          {my_entry, cache} = get_tree_path_entry(repo, commit.tree, path_comps, cache)
          {p_entry, cache} =
            if parent_commit do
              get_tree_path_entry(repo, parent_commit.tree, path_comps, cache)
            else
              {nil, cache}
            end
          changed? = my_entry != p_entry
          {changed?, [parent_sha], cache}
        end
      parents ->
        {my_entry, cache} = get_tree_path_entry(repo, commit.tree, path_comps, cache)
        {same_parent, cache} =
          Enum.reduce_while(parents, {nil, cache}, fn p_sha, {_found, acc_cache} ->
            {p_commit, acc_cache} = get_cached_commit(repo, p_sha, acc_cache)
            if p_commit && commit.tree == p_commit.tree do
              {:halt, {p_sha, acc_cache}}
            else
              {p_entry, acc_cache} =
                if p_commit do
                  get_tree_path_entry(repo, p_commit.tree, path_comps, acc_cache)
                else
                  {nil, acc_cache}
                end
              if my_entry == p_entry do
                {:halt, {p_sha, acc_cache}}
              else
                {:cont, {nil, acc_cache}}
              end
            end
          end)
        case same_parent do
          nil ->
            {true, parents, cache}
          treesame_p_sha ->
            {false, [treesame_p_sha], cache}
        end
    end
  end
  defp get_tree_path_entry(_repo, nil, _components, cache), do: {nil, cache}
  defp get_tree_path_entry(_repo, _tree_sha, [], cache), do: {nil, cache}
  defp get_tree_path_entry(repo, tree_sha, [comp | rest], cache) do
    key = {:path_entry, tree_sha, [comp | rest]}
    case cache do
      %{^key => entry} ->
        {entry, cache}
      _ ->
        case ObjectResolver.read(repo, tree_sha) do
          {:ok, %ExGitObjectstore.Object.Tree{entries: entries}} ->
            case Enum.find(entries, &(&1.name == comp)) do
              nil ->
                {nil, Map.put(cache, key, nil)}
              %{mode: "40000", sha: sub_sha} ->
                if rest == [] do
                  entry = %{mode: "40000", sha: sub_sha, name: comp}
                  {entry, Map.put(cache, key, entry)}
                else
                  {entry, cache} = get_tree_path_entry(repo, sub_sha, rest, cache)
                  {entry, Map.put(cache, key, entry)}
                end
              leaf_entry when rest == [] ->
                {leaf_entry, Map.put(cache, key, leaf_entry)}
              _ ->
                {nil, Map.put(cache, key, nil)}
            end
          _ ->
            {nil, Map.put(cache, key, nil)}
        end
    end
  end
  defp get_cached_commit(repo, sha, cache) do
    case cache do
      %{^sha => %Commit{} = commit} ->
        {commit, cache}
      _ ->
        case ObjectResolver.read(repo, sha) do
          {:ok, %Commit{} = commit} ->
            {commit, Map.put(cache, sha, commit)}
          _ ->
            {nil, cache}
        end
    end
  end
  @doc """
  Commits reachable from `head_sha` but not from `base_sha` (the `base..head`
  range), in topological order oldest-first — every parent precedes its
@@ -416,50 +572,48 @@
  # -- Merge base walk (priority queue with reachability tracking) --
  defp merge_base_walk(_repo, [], _reachable), do: {:error, :no_merge_base}
  defp merge_base_walk(_repo, [], _reachable, _cache), do: {:error, :no_merge_base}
  defp merge_base_walk(repo, [{_ts, sha} | rest], reachable) do
  defp merge_base_walk(repo, [{_ts, sha, commit} | rest], reachable, cache) do
    case Map.get(reachable, sha) do
      :both ->
        {:ok, sha}
      side ->
        process_merge_base_commit(repo, sha, side, rest, reachable)
    end
  end
  defp process_merge_base_commit(repo, sha, side, rest, reachable) do
    case ObjectResolver.read(repo, sha) do
      {:ok, %Commit{} = commit} ->
        {new_queue, new_reachable} =
        {new_queue, new_reachable, new_cache} =
          Enum.reduce(commit.parents, {rest, reachable, cache}, fn parent, {q, r, c} ->
            enqueue_merge_parent(repo, parent, side, q, r, c)
          Enum.reduce(commit.parents, {rest, reachable}, fn parent, {q, r} ->
            enqueue_merge_parent(repo, parent, side, q, r)
          end)
        merge_base_walk(repo, new_queue, new_reachable)
      {:error, _} = err ->
        err
        merge_base_walk(repo, new_queue, new_reachable, new_cache)
    end
  end
  defp enqueue_merge_parent(repo, parent, side, queue, reachable) do
  defp enqueue_merge_parent(repo, parent, side, queue, reachable, cache) do
    existing = Map.get(reachable, parent)
    new_side = compute_new_side(existing, side)
    reachable = Map.put(reachable, parent, new_side)
    needs_enqueue = existing == nil or (existing != new_side and new_side == :both)
    if needs_enqueue do
      case ObjectResolver.read(repo, parent) do
        {:ok, %Commit{} = pc} ->
      case Map.get(cache, parent) do
        %Commit{} = pc ->
          ts = parse_timestamp(pc.committer)
          queue = insert_sorted(queue, {ts, parent, pc})
          {queue, reachable, cache}
          queue = insert_sorted(queue, {ts, parent})
          {queue, reachable}
        nil ->
          case ObjectResolver.read(repo, parent) do
            {:ok, %Commit{} = pc} ->
              ts = parse_timestamp(pc.committer)
              queue = insert_sorted(queue, {ts, parent, pc})
              {queue, reachable, Map.put(cache, parent, pc)}
        _ ->
            _ ->
              {queue, reachable, cache}
          end
          {queue, reachable}
      end
    else
      {queue, reachable, cache}
      {queue, reachable}
    end
  end

@@ -674,5 +674,68 @@
      assert {:error, :no_merge_base} = Merge.merge_commits(repo, commit_a, commit_b)
    end
    test "same commit merge fast path" do
      repo = RepoHelper.memory_repo()
      blob = write_blob(repo, "same content")
      tree = write_tree(repo, %{"f.txt" => blob})
      commit = write_commit(repo, tree, [], "initial")
      assert {:ok, result} = Merge.merge_commits(repo, commit, commit)
      assert result == commit
    end
    test "speculative merge check with write: false does not write objects to repo" do
      repo = RepoHelper.memory_repo()
      blob_base = write_blob(repo, "line1\nline2\nline3\n")
      tree_base = write_tree(repo, %{"f.txt" => blob_base})
      commit_base = write_commit(repo, tree_base, [], "base")
      # Ours modifies line 1
      blob_ours = write_blob(repo, "line1_modified\nline2\nline3\n")
      tree_ours = write_tree(repo, %{"f.txt" => blob_ours})
      commit_ours = write_commit(repo, tree_ours, [commit_base], "ours")
      # Theirs modifies line 3
      blob_theirs = write_blob(repo, "line1\nline2\nline3_modified\n")
      tree_theirs = write_tree(repo, %{"f.txt" => blob_theirs})
      commit_theirs = write_commit(repo, tree_theirs, [commit_base], "theirs")
      # Speculative check returns clean without writing merged tree to storage
      assert {:ok, "clean"} = Merge.merge_commits(repo, commit_ours, commit_theirs, write: false)
      # When conflicting with write: false, conflict info is accurately returned
      blob_conflict = write_blob(repo, "line1_conflicting\nline2\nline3\n")
      tree_conflict = write_tree(repo, %{"f.txt" => blob_conflict})
      commit_conflict = write_commit(repo, tree_conflict, [commit_base], "conflict")
      assert {:error, {:conflicts, conflicts}} =
               Merge.merge_commits(repo, commit_ours, commit_conflict, write: false)
      assert length(conflicts) == 1
      assert hd(conflicts).path == "f.txt"
    end
    test "identical subtree fast path skips reading unmodified directories" do
      repo = RepoHelper.memory_repo()
      blob_shared = write_blob(repo, "shared")
      sub_tree = write_tree(repo, %{"subfile.txt" => blob_shared})
      blob_ours = write_blob(repo, "ours")
      blob_theirs = write_blob(repo, "theirs")
      base_tree = write_tree(repo, %{"sub" => {:tree, sub_tree}, "root.txt" => blob_shared})
      ours_tree = write_tree(repo, %{"sub" => {:tree, sub_tree}, "root.txt" => blob_ours})
      theirs_tree = write_tree(repo, %{"sub" => {:tree, sub_tree}, "root.txt" => blob_theirs})
      # Both modified root.txt, but sub/ is completely identical across base/ours/theirs
      assert {:error, {:conflicts, [conflict]}} =
               Merge.merge_trees(repo, base_tree, ours_tree, theirs_tree, write: false)
      assert conflict.path == "root.txt"
    end
  end
end

@@ -198,5 +198,26 @@
      assert base == c3,
             "Expected merge base to be c3 (most recent common ancestor), got #{inspect(base)}"
    end
    test "deep chain with early fork finds merge base without traversing full root history" do
      repo = RepoHelper.memory_repo()
      blob = write_blob(repo, "content")
      tree = write_tree(repo, %{"f.txt" => blob})
      # Build 100 root commits
      base_tip =
        Enum.reduce(1..100, nil, fn i, parent ->
          parents = if parent, do: [parent], else: []
          write_commit(repo, tree, parents, 1_700_000_000 + i * 10)
        end)
      # Fork two tips off base_tip
      branch_a = write_commit(repo, tree, [base_tip], 1_700_010_000)
      branch_b = write_commit(repo, tree, [base_tip], 1_700_010_010)
      assert {:ok, base} = Walk.merge_base(repo, branch_a, branch_b)
      assert base == base_tip
    end
  end
end

@@ -1,0 +1,208 @@
# Copyright 2026 Cole Christensen
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
defmodule ExGitObjectstore.Walk.PathLogTest do
  use ExUnit.Case, async: true
  alias ExGitObjectstore.{Object, Walk}
  alias ExGitObjectstore.Object.{Blob, Commit, Tree}
  alias ExGitObjectstore.Test.RepoHelper
  defp init_repo do
    repo = RepoHelper.memory_repo("path-log-test-#{:erlang.unique_integer([:positive])}")
    ExGitObjectstore.init(repo)
    repo
  end
  defp write_blob(repo, content) do
    blob = Blob.from_content(content)
    {:ok, sha} = Object.write(repo, blob)
    sha
  end
  defp write_tree(repo, entries) do
    tree = Tree.new(entries)
    {:ok, sha} = Object.write(repo, tree)
    sha
  end
  defp make_commit(repo, tree_sha, parents, ts, message) do
    ident = "Author <author@example.com> #{ts} +0000"
    commit = %Commit{
      tree: tree_sha,
      parents: parents,
      author: ident,
      committer: ident,
      message: message <> "\n"
    }
    {:ok, sha} = Object.write(repo, commit)
    sha
  end
  describe "Walk.log with path filtering" do
    test "linear history filters commits that did not touch the path" do
      repo = init_repo()
      b1 = write_blob(repo, "v1 file A\n")
      b2 = write_blob(repo, "v1 file B\n")
      t1 =
        write_tree(repo, [
          %{mode: "100644", name: "a.txt", sha: b1},
          %{mode: "100644", name: "b.txt", sha: b2}
        ])
      c1 = make_commit(repo, t1, [], 1000, "init a and b")
      # c2 modifies only b.txt
      b2_v2 = write_blob(repo, "v2 file B\n")
      t2 =
        write_tree(repo, [
          %{mode: "100644", name: "a.txt", sha: b1},
          %{mode: "100644", name: "b.txt", sha: b2_v2}
        ])
      c2 = make_commit(repo, t2, [c1], 2000, "modify b")
      # c3 modifies only a.txt
      b1_v2 = write_blob(repo, "v2 file A\n")
      t3 =
        write_tree(repo, [
          %{mode: "100644", name: "a.txt", sha: b1_v2},
          %{mode: "100644", name: "b.txt", sha: b2_v2}
        ])
      c3 = make_commit(repo, t3, [c2], 3000, "modify a")
      # c4 modifies only b.txt
      b2_v3 = write_blob(repo, "v3 file B\n")
      t4 =
        write_tree(repo, [
          %{mode: "100644", name: "a.txt", sha: b1_v2},
          %{mode: "100644", name: "b.txt", sha: b2_v3}
        ])
      c4 = make_commit(repo, t4, [c3], 4000, "modify b again")
      {:ok, log_a} = Walk.log(repo, c4, path: "a.txt")
      shas_a = Enum.map(log_a, &elem(&1, 0))
      assert shas_a == [c3, c1]
      {:ok, log_b} = Walk.log(repo, c4, path: "b.txt")
      shas_b = Enum.map(log_b, &elem(&1, 0))
      assert shas_b == [c4, c2, c1]
    end
    test "nested directory path filtering" do
      repo = init_repo()
      sub_b = write_blob(repo, "nested content\n")
      sub_t1 = write_tree(repo, [%{mode: "100644", name: "module.ex", sha: sub_b}])
      root_t1 = write_tree(repo, [%{mode: "40000", name: "lib", sha: sub_t1}])
      c1 = make_commit(repo, root_t1, [], 1000, "init lib/module.ex")
      other_b = write_blob(repo, "readme\n")
      root_t2 =
        write_tree(repo, [
          %{mode: "40000", name: "lib", sha: sub_t1},
          %{mode: "100644", name: "README.md", sha: other_b}
        ])
      c2 = make_commit(repo, root_t2, [c1], 2000, "add README")
      sub_b2 = write_blob(repo, "nested content v2\n")
      sub_t3 = write_tree(repo, [%{mode: "100644", name: "module.ex", sha: sub_b2}])
      root_t3 =
        write_tree(repo, [
          %{mode: "40000", name: "lib", sha: sub_t3},
          %{mode: "100644", name: "README.md", sha: other_b}
        ])
      c3 = make_commit(repo, root_t3, [c2], 3000, "modify lib/module.ex")
      {:ok, log_lib} = Walk.log(repo, c3, path: "lib/module.ex")
      shas_lib = Enum.map(log_lib, &elem(&1, 0))
      assert shas_lib == [c3, c1]
    end
    test "merge commits follow TREESAME parent branch" do
      repo = init_repo()
      b_orig = write_blob(repo, "base\n")
      t_base = write_tree(repo, [%{mode: "100644", name: "f.txt", sha: b_orig}])
      c_base = make_commit(repo, t_base, [], 1000, "base")
      # Branch A does not modify f.txt, only adds a.txt
      b_a = write_blob(repo, "branch a\n")
      t_a =
        write_tree(repo, [
          %{mode: "100644", name: "f.txt", sha: b_orig},
          %{mode: "100644", name: "a.txt", sha: b_a}
        ])
      c_a = make_commit(repo, t_a, [c_base], 2000, "branch a add")
      # Branch B modifies f.txt
      b_mod = write_blob(repo, "modified in b\n")
      t_b = write_tree(repo, [%{mode: "100644", name: "f.txt", sha: b_mod}])
      c_b = make_commit(repo, t_b, [c_base], 2500, "branch b mod f")
      # Merge of A and B keeps B's version of f.txt
      t_merge =
        write_tree(repo, [
          %{mode: "100644", name: "f.txt", sha: b_mod},
          %{mode: "100644", name: "a.txt", sha: b_a}
        ])
      c_merge = make_commit(repo, t_merge, [c_a, c_b], 3000, "merge b into a")
      # For f.txt, c_merge is TREESAME to c_b, so c_merge is not emitted and history follows c_b
      {:ok, log_f} = Walk.log(repo, c_merge, path: "f.txt")
      shas_f = Enum.map(log_f, &elem(&1, 0))
      assert shas_f == [c_b, c_base]
    end
    test "pagination with log_page and path filter" do
      repo = init_repo()
      b1 = write_blob(repo, "v1\n")
      t1 = write_tree(repo, [%{mode: "100644", name: "x.txt", sha: b1}])
      c1 = make_commit(repo, t1, [], 1000, "c1")
      b2 = write_blob(repo, "v2\n")
      t2 = write_tree(repo, [%{mode: "100644", name: "x.txt", sha: b2}])
      c2 = make_commit(repo, t2, [c1], 2000, "c2")
      b3 = write_blob(repo, "v3\n")
      t3 = write_tree(repo, [%{mode: "100644", name: "x.txt", sha: b3}])
      c3 = make_commit(repo, t3, [c2], 3000, "c3")
      {:ok, page1, cursor1} = Walk.log_page(repo, c3, path: "x.txt", max_count: 2)
      assert length(page1) == 2
      assert Enum.map(page1, &elem(&1, 0)) == [c3, c2]
      {:ok, page2, _cursor2} = Walk.log_continue(repo, cursor1, path: "x.txt", max_count: 2)
      assert length(page2) == 1
      assert Enum.map(page2, &elem(&1, 0)) == [c1]
    end
  end
end