@@ -355,7 +355,7 @@
    workdir = Path.join(System.tmp_dir!(), "pin-bump-#{System.unique_integer([:positive])}")
    url = "https://x-token:#{token}@#{server}/#{@anvil_repo}.git"
    case git(["clone", "--depth", "50", url, workdir], ".") do
    case git(["clone", url, workdir], ".") do
      {:ok, _} -> {:ok, workdir}
      {:error, reason} -> {:error, "could not clone #{@anvil_repo}: #{reason}"}
    end

@@ -102,7 +102,7 @@
  end
  @doc """
  Stream a packfile from an arbitrary `Enumerable.t/0` of object
  Stream a packfile from an arbitrary `t:Enumerable.t/0` of object
  entries with a known `count` (REQ-GIT-080).
  Pack format requires the object count in the 12-byte header — which
@@ -111,7 +111,7 @@
  a pre-computed count.
  Behaves exactly like `generate_stream/3` (same byte output, same
  hashing), but the caller may pass a `Stream.t/0` so the entries are
  hashing), but the caller may pass a `Stream` so the entries are
  pulled lazily and never fully materialized in memory. The walker
  uses this to avoid holding all ~10k pack entries simultaneously for
  a large clone.

@@ -406,12 +406,17 @@
  end
  defp handle_command_data(line, rest, acc, caps) do
    case parse_command_line(line) do
    # Shallow clients send "shallow <oid>" lines before ref commands per git protocol
    if String.starts_with?(line, "shallow ") do
      parse_command_lines(rest, acc, caps)
    else
      case parse_command_line(line) do
        {:ok, cmd, line_caps} ->
          caps = caps || line_caps
          parse_command_lines(rest, [cmd | acc], caps)
      {:ok, cmd, line_caps} ->
        caps = caps || line_caps
        parse_command_lines(rest, [cmd | acc], caps)
      {:error, _} = err ->
        err
        {:error, _} = err ->
          err
      end
    end
  end

@@ -357,6 +357,41 @@
        stop.()
      end
    end
    @tag :tmp_dir
    test "push from a shallow clone (depth 1) over HTTP", %{tmp_dir: tmp_dir} do
      repo = make_linear_repo("shallow-push", 5)
      {port, stop} = GitDaemon.start_http_smart(repo)
      remote_url = "http://127.0.0.1:#{port}/repo.git"
      try do
        shallow_client = Path.join(tmp_dir, "shallow-client")
        # 1. Clone with depth 1
        {out1, code1} =
          GitDaemon.git_at(nil, ["clone", "--depth", "1", remote_url, shallow_client])
        assert code1 == 0, "shallow clone failed:\n#{out1}"
        GitDaemon.git!(shallow_client, ["config", "user.name", "Shallow User"])
        GitDaemon.git!(shallow_client, ["config", "user.email", "shallow@test.com"])
        # 2. Add commit and push back
        File.write!(Path.join(shallow_client, "shallow-file.txt"), "shallow content\n")
        GitDaemon.git!(shallow_client, ["add", "shallow-file.txt"])
        GitDaemon.git!(shallow_client, ["commit", "-m", "shallow commit"])
        {out2, code2} = GitDaemon.git_at(shallow_client, ["push", remote_url, "main"])
        assert code2 == 0, "push from shallow clone failed:\n#{out2}"
        # 3. Verify server ref updated
        {:ok, new_sha} = Ref.get(repo, "refs/heads/main")
        {log_out, 0} = GitDaemon.git_at(shallow_client, ["rev-parse", "HEAD"])
        assert String.trim(log_out) == new_sha
      after
        stop.()
      end
    end
  end
  describe "direct HTTP POST (no git client)" do

@@ -283,6 +283,53 @@
      # Verify ref was deleted
      assert {:error, _} = Ref.get(repo, "refs/heads/feature")
    end
    test "handles push with shallow lines before command lines" do
      repo = RepoHelper.memory_repo()
      ExGitObjectstore.init(repo)
      blob = Blob.from_content("hello\n")
      {:ok, blob_sha} = Object.write(repo, blob)
      tree = Tree.new([%{mode: "100644", name: "file.txt", sha: blob_sha}])
      {:ok, tree_sha} = Object.write(repo, tree)
      commit = %Commit{
        tree: tree_sha,
        parents: [],
        author: "Test <t@t.com> 1000000000 +0000",
        committer: "Test <t@t.com> 1000000000 +0000",
        message: "init\n"
      }
      {:ok, commit_sha} = Object.write(repo, commit)
      {_advert, state} = ReceivePack.init(repo)
      zero = String.duplicate("0", 40)
      shallow_sha = String.duplicate("a", 40)
      commands =
        PktLine.encode("shallow #{shallow_sha}") <>
          PktLine.encode("#{zero} #{commit_sha} refs/heads/main\0report-status") <>
          PktLine.flush()
      objects = [
        {:blob, "hello\n", blob_sha},
        {:tree, Tree.encode_content(tree), tree_sha},
        {:commit, Commit.encode_content(commit), commit_sha}
      ]
      {pack_data, _} = Writer.generate(objects)
      {_response, state} = ReceivePack.feed(state, commands)
      {response, state} = ReceivePack.feed(state, pack_data)
      {final_resp, state} = ReceivePack.flush(state)
      all_resp = response <> final_resp
      assert ReceivePack.done?(state)
      assert all_resp =~ "unpack ok"
      assert all_resp =~ "ok refs/heads/main"
    end
  end
  describe "split data handling" do