GitHubivarvong

ply

main
ply6 git calls73 ms28 KiB4 cachedprotocol v2
211 lines16 KiBRaw
1// Structural edges: depth, width, modes, odd names, odd refs, REF_DELTA packs, large blobs, exact limits.
2import { test, beforeAll as before, afterAll as after } from 'vitest';
3import assert from 'node:assert/strict';
4import { join } from 'node:path';
5import { mkdirSync, writeFileSync, symlinkSync } from 'node:fs';
6import { git, gitBuf, tmpRoot, makeBareRepo, startGitServer, commitFiles, fsckProblems, initRepo } from './server.js';
7import { editFile } from '../src/edit.js';
8import { GitHttp } from '../src/client.js';
9import { Tracer, arrayExporter, flattenLine } from '../src/otel.js';
10import { withLimits } from '../src/limits.js';
11import { TYPE_NAME } from '../src/objects.js';
12import { unwrapAsync, unwrap } from './unwrap.js';
14let root, cleanup, srv, n = 0;
15before(async () => { ({ root, cleanup } = tmpRoot()); srv = await startGitServer(root); });
16after(async () => { await srv.close(); cleanup(); });
17const A = { name: 'e', email: 'e@x' };
18const repo = () => { const name = `e${n++}`; const bare = makeBareRepo(root, name); const work = join(root, `w${name}`); mkdirSync(work); initRepo(work); return { name, bare, work, url: `${srv.url}/${name}.git` }; };
19const edit = (r, p, extra = {}, opts = {}) => unwrapAsync(editFile(r.url, { path: p, find: 'MARK', replace: 'OK', author: A, message: 'e', ...extra }, { tracer: new Tracer(), ...opts }));
21test('path depth 100 (limit 128): one tree fetch per level, push = commit + 100 tree deltas + blob delta', async () => {
22 const r = repo();
23 const path = Array.from({ length: 99 }, (_, i) => `d${i}`).join('/') + '/f.txt';
24 commitFiles(r.work, r.bare, { [path]: 'MARK' }, 's');
25 const ex = arrayExporter();
26 const res = await unwrapAsync(editFile(r.url, { path, find: 'MARK', replace: 'OK', author: A, message: 'e' }, { tracer: new Tracer({ exporter: ex }) }));
27 assert.equal(gitBuf(r.bare, ['cat-file', 'blob', `main:${path}`]).toString(), 'OK');
28 const spans = ex.lines.flatMap(flattenLine);
29 assert.equal(spans.filter(s => s.name === 'git.edit.tree').length, 100);
30 assert.equal(spans.find(s => s.name === 'git.receive-pack').attrs['git.push.pack.objects'], 102);
31 assert.ok(res.pushBytes < 102 * 80 + 400, `push ${res.pushBytes}`);
32 await assert.rejects(unwrapAsync(editFile(r.url, { path: 'x/'.repeat(129) + 'f', find: 'a', replace: 'b', author: A, message: 'e' }, { tracer: new Tracer() })), e => e.code === 'bad_request');
33});
35test('wide tree: 20k siblings (tree ≈ 700 KB, multi-pkt, multi-block zlib) and maxTreeEntries enforcement', async () => {
36 const r = repo();
37 const files = { 'wide/target.txt': 'MARK' };
38 for (let i = 0; i < 20000; i++) files[`wide/f${String(i).padStart(5, '0')}.txt`] = '';
39 commitFiles(r.work, r.bare, files, 's');
40 const ex = arrayExporter();
41 await unwrapAsync(editFile(r.url, { path: 'wide/target.txt', find: 'MARK', replace: 'OK', author: A, message: 'e' }, { tracer: new Tracer({ exporter: ex }) }));
42 assert.equal(gitBuf(r.bare, ['cat-file', 'blob', 'main:wide/target.txt']).toString(), 'OK');
43 const t = ex.lines.flatMap(flattenLine).find(s => s.name === 'git.edit.tree' && s.attrs['git.edit.tree.depth'] === 1);
44 assert.equal(t.attrs['git.edit.tree.entries'], 20001);
45 assert.ok(t.attrs['git.edit.tree.bytes'] > 600000);
46 const f = ex.lines.flatMap(flattenLine).filter(s => s.name === 'git.upload-pack fetch')[2];
47 assert.ok(f.attrs['git.pack.inflated.bytes'] > 600000, 'tree inflated > 600KB');
48 assert.ok(f.attrs['git.pack.inflate.blocks'] > 1, 'multi-block zlib');
49 assert.ok(f.attrs['git.pack.compressed.bytes'] < f.attrs['git.pack.inflated.bytes'] / 5, 'near-identical names compress hard; the pack is small on the wire');
50 await assert.rejects(edit(r, 'wide/target.txt', { find: 'OK' }, { limits: withLimits({ maxTreeEntries: 1000 }) }), e => e.code === 'limit_exceeded');
51 assert.equal(gitBuf(r.bare, ['cat-file', 'blob', 'main:wide/target.txt']).toString(), 'OK');
52});
54test('modes: symlink and submodule along the path are refused; executable preserved; names with every odd byte', async () => {
55 const r = repo();
56 commitFiles(r.work, r.bare, { 'x/real.txt': 'MARK', 'x/exec.sh': { mode: '100755', data: 'MARK' } }, 's');
57 symlinkSync('real.txt', join(r.work, 'x/link'));
58 git(r.work, ['add', '-A']);
59 git(r.work, ['update-index', '--add', '--cacheinfo', '160000,' + git(r.bare, ['rev-parse', 'main']).trim() + ',x/sub']); // gitlink with no worktree dir: must come after add -A
60 git(r.work, ['-c', 'user.name=s', '-c', 'user.email=s@x', 'commit', '-q', '-m', 'modes']); git(r.work, ['push', '-q', r.bare, 'HEAD:refs/heads/main']);
61 await assert.rejects(edit(r, 'x/link'), e => e.code === 'not_found' && /not a regular file/.test(e.message));
62 await assert.rejects(edit(r, 'x/sub/anything'), e => e.code === 'not_found');
63 await assert.rejects(edit(r, 'x/sub'), e => e.code === 'not_found');
64 await assert.rejects(edit(r, 'x/real.txt/deeper'), e => e.code === 'not_found');
65 await edit(r, 'x/exec.sh');
66 assert.equal(git(r.bare, ['ls-tree', 'main', 'x/exec.sh']).split(' ')[0], '100755');
67 assert.equal(git(r.bare, ['ls-tree', 'main', 'x/link']).split(' ')[0], '120000');
68 assert.equal(git(r.bare, ['ls-tree', 'main', 'x/sub']).split(' ')[0], '160000');
69 // names: bytes 1..255 except '/' and NUL, spaces, leading dash, 255-byte name
70 const r2 = repo();
71 const odd = [' lead', 'trail ', '-dash', '--', 'tab\tname', 'quote"name', "squote'", 'back\\slash', 'uni-日本語', 'emoji-🚀-x', 'a'.repeat(255), Array.from({ length: 200 }, (_, i) => String.fromCharCode(33 + (i % 90))).join('').replace(/\//g, '_')];
72 const files = {}; for (const nm of odd) files[`odd/${nm}`] = 'MARK';
73 commitFiles(r2.work, r2.bare, files, 's');
74 for (const nm of odd) { await edit(r2, `odd/${nm}`); assert.equal(gitBuf(r2.bare, ['cat-file', 'blob', `main:odd/${nm}`]).toString(), 'OK', nm); }
75 assert.deepEqual(fsckProblems(r2.bare, { dangling: true }), []);
76});
78test('refs: missing ref, non-main branch, unborn HEAD repo, ref pointing at a tag', async () => {
79 const r = repo();
80 await assert.rejects(edit(r, 'a', { ref: 'refs/heads/main' }), e => e.code === 'not_found' || e.code === 'remote_error');
81 commitFiles(r.work, r.bare, { 'a': 'MARK' }, 's');
82 git(r.work, ['push', '-q', r.bare, 'HEAD:refs/heads/feature/x-y']);
83 await edit(r, 'a', { ref: 'refs/heads/feature/x-y' });
84 assert.equal(gitBuf(r.bare, ['cat-file', 'blob', 'refs/heads/feature/x-y:a']).toString(), 'OK');
85 assert.equal(gitBuf(r.bare, ['cat-file', 'blob', 'main:a']).toString(), 'MARK', 'main untouched');
86 await assert.rejects(edit(r, 'a', { ref: 'refs/heads/nope' }), e => e.code === 'not_found');
87 git(r.work, ['tag', '-a', 'v1', '-m', 'v1']); git(r.work, ['push', '-q', r.bare, 'refs/tags/v1']);
88 await assert.rejects(edit(r, 'a', { ref: 'refs/tags/v1' }), e => e.code === 'pack_corrupt' || e.code === 'not_found');
89 assert.equal(git(r.bare, ['rev-parse', 'refs/tags/v1']).trim(), git(r.work, ['rev-parse', 'v1']).trim(), 'tag untouched');
90});
92test('REF_DELTA packs (server without ofs-delta) resolve identically; thin-pack fetch with have resolves against external base', async () => {
93 const r = repo();
94 let text = 'line\n'.repeat(500);
95 const c1 = commitFiles(r.work, r.bare, { 'd/a.txt': text, 'd/b.txt': text + 'b', 'd/c.txt': text + 'c' }, 'one');
96 const c2 = commitFiles(r.work, r.bare, { 'd/a.txt': text + 'changed\n' }, 'two');
97 const c = unwrap(GitHttp.create(r.url, { tracer: new Tracer() }));
98 const ofs = await unwrapAsync(c.fetchPack({ wants: [c2], filter: 'blob:none', deepen: 2, ofsDelta: true }));
99 const ref = await unwrapAsync(c.fetchPack({ wants: [c2], filter: 'blob:none', deepen: 2, ofsDelta: false }));
100 assert.equal(ref.parsed.stats.ofsDelta, 0);
101 assert.deepEqual([...ref.objects.keys()].sort(), [...ofs.objects.keys()].sort());
102 for (const [oid, o] of ref.objects) assert.deepEqual([...o.data], [...ofs.objects.get(oid).data]);
103 // thin: have c1, want c2's blob a.txt → server may send it as a delta against c1's a.txt, which we supply externally
104 const blobOld = git(r.bare, ['rev-parse', `${c1}:d/a.txt`]).trim(), blobNew = git(r.bare, ['rev-parse', `${c2}:d/a.txt`]).trim();
105 const base = gitBuf(r.bare, ['cat-file', 'blob', blobOld]);
106 const thin = await unwrapAsync(c.fetchPack({ wants: [c2], haves: [c1], thinPack: true, deepen: 1 }, { external: oid => (oid === blobOld ? { type: 3, data: new Uint8Array(base) } : undefined) }));
107 assert.ok(thin.objects.has(blobNew));
108 assert.ok(Buffer.from(thin.objects.get(blobNew).data).equals(gitBuf(r.bare, ['cat-file', 'blob', blobNew])));
109});
111test('large blob (24 MB): max single allocation stays at one inflate chunk; push is a few hundred bytes', async () => {
112 const r = repo();
113 const big = Buffer.alloc(24 << 20); for (let i = 0; i < big.length; i += 4096) big.write(`line ${i}\n`, i);
114 big.write('MARK', 12 << 20);
115 commitFiles(r.work, r.bare, { 'big.bin': big }, 's');
116 const ex = arrayExporter();
117 const t0 = performance.now();
118 const res = await unwrapAsync(editFile(r.url, { path: 'big.bin', find: 'MARK', replace: 'OK', author: A, message: 'e' }, { tracer: new Tracer({ exporter: ex }) }));
119 const ms = performance.now() - t0;
120 const root = ex.lines.flatMap(flattenLine).find(s => s.name === 'git.edit');
121 assert.ok(root.attrs['mem.alloc.max_single'] <= 65536, `max single alloc ${root.attrs['mem.alloc.max_single']}`);
122 // delta copy ops cover at most 64 KiB each (git delta format): 24 MiB → 384 ops ≈ 3 KB raw, ~1 KB zlib'd. That is the floor for a 24 MB base.
123 assert.ok(res.pushBytes < 1500, `push ${res.pushBytes}`);
124 assert.ok(res.pushBytes > 500, 'copy-op cost is real and visible');
125 const got = gitBuf(r.bare, ['cat-file', 'blob', 'main:big.bin']);
126 const off = 12 << 20;
127 assert.equal(got.length, big.length - 2);
128 assert.equal(got.subarray(off, off + 2).toString(), 'OK');
129 assert.ok(got.subarray(0, off).equals(big.subarray(0, off)), 'prefix intact');
130 assert.ok(got.subarray(off + 2).equals(big.subarray(off + 4)), 'suffix intact');
131 console.log(` 24MB edit in ${ms | 0}ms, push ${res.pushBytes}B, max alloc ${root.attrs['mem.alloc.max_single']}`);
132});
134test('find at exact chunk boundaries of a 16384-aligned stream and a find longer than one chunk', async () => {
135 const r = repo();
136 const files = {};
137 const cases = [];
138 for (const [i, off] of [16383, 16384, 16385, 32768 - 1, 65536, 65536 * 3 - 2].entries()) {
139 const buf = Buffer.alloc(300000, 46); buf.write('MARK', off); files[`b${i}`] = buf; cases.push([`b${i}`, off, 'MARK']);
140 }
141 const longFind = 'L'.repeat(40000); const lb = Buffer.alloc(200000, 46); lb.write(longFind, 70000); files.long = lb; cases.push(['long', 70000, longFind]);
142 commitFiles(r.work, r.bare, files, 's');
143 for (const [p, off, find] of cases) {
144 const res = await unwrapAsync(editFile(r.url, { path: p, find, replace: 'OK', author: A, message: 'e' }, { tracer: new Tracer() }));
145 assert.equal(res.matchOffset, off, p);
146 const got = gitBuf(r.bare, ['cat-file', 'blob', `main:${p}`]);
147 assert.equal(got.subarray(off, off + 2).toString(), 'OK'); assert.equal(got.length, files[p].length - find.length + 2);
148 }
149});
151test('whole-file replace, replace with empty on 1-byte file, and empty find rejected', async () => {
152 const r = repo();
153 commitFiles(r.work, r.bare, { 'w': 'MARK', 'one': 'M' }, 's');
154 await unwrapAsync(editFile(r.url, { path: 'w', find: 'MARK', replace: 'completely new content\n', author: A, message: 'e' }, { tracer: new Tracer() }));
155 assert.equal(gitBuf(r.bare, ['cat-file', 'blob', 'main:w']).toString(), 'completely new content\n');
156 await unwrapAsync(editFile(r.url, { path: 'one', find: 'M', replace: '', author: A, message: 'e' }, { tracer: new Tracer() }));
157 assert.equal(gitBuf(r.bare, ['cat-file', 'blob', 'main:one']).length, 0);
158 assert.equal(git(r.bare, ['rev-parse', 'main:one']).trim(), 'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391');
159 await assert.rejects(unwrapAsync(editFile(r.url, { path: 'one', find: '', replace: 'x', author: A, message: 'e' }, { tracer: new Tracer() })), e => e.code === 'bad_request');
160 await assert.rejects(unwrapAsync(editFile(r.url, { path: 'one', find: 'x', replace: 'y', author: A, message: 'e' }, { tracer: new Tracer() })), e => e.code === 'match_count');
161});
163test('empty blob: find on a 0-byte file is match_count (0 matches), never a push; edit the empty→nonempty neighbour works', async () => {
164 const r = repo();
165 commitFiles(r.work, r.bare, { 'empty.txt': '', 'one.txt': 'M' }, 's');
166 const head = git(r.bare, ['rev-parse', 'main']).trim();
167 await assert.rejects(unwrapAsync(editFile(r.url, { path: 'empty.txt', find: 'x', replace: 'y', author: A, message: 'e' }, { tracer: new Tracer() })), e => e.code === 'match_count' && e.matches === 0);
168 assert.equal(git(r.bare, ['rev-parse', 'main']).trim(), head, 'ref untouched');
169 // the blob fetch for an empty object is a 1-object pack whose zlib stream inflates to nothing: the scanner must still finish cleanly
170 await assert.rejects(unwrapAsync(editFile(r.url, { path: 'empty.txt', find: 'longer than the file', replace: '', author: A, message: 'e' }, { tracer: new Tracer() })), e => e.code === 'match_count');
171 await unwrapAsync(editFile(r.url, { path: 'one.txt', find: 'M', replace: '', author: A, message: 'e' }, { tracer: new Tracer() }));
172 assert.equal(gitBuf(r.bare, ['cat-file', 'blob', 'main:one.txt']).length, 0);
173 await assert.rejects(unwrapAsync(editFile(r.url, { path: 'one.txt', find: 'M', replace: 'back', author: A, message: 'e' }, { tracer: new Tracer() })), e => e.code === 'match_count');
174});
176test('a one-byte find over 128 KiB of that byte (#13): match_count with the full count in linear time, never a push', { timeout: 60_000 }, async () => {
177 const r = repo();
178 commitFiles(r.work, r.bare, { 'run.txt': 'a'.repeat(128 << 10) }, 's');
179 const head = git(r.bare, ['rev-parse', 'main']).trim();
180 // O(n) calibration in this process: the same edit over 16 KiB of hits, so the ratio cancels a slow machine, and CPU
181 // time, not wall clock, so parallel load on the box does not count. Linear is at most 8x (measured 4.6-5.5x, also beside
182 // 3 fuzzers); the old scan, which kept every offset in a fresh array per hit, measured 71-78x (~20 s). Spans keep 16.
183 const small = repo();
184 commitFiles(small.work, small.bare, { 'run.txt': 'a'.repeat(16 << 10) }, 's');
185 const cpuMs = async f => { const t = process.cpuUsage(); const v = await f(); const d = process.cpuUsage(t); return { v, ms: (d.user + d.system) / 1000 }; };
186 const run = (u, ex = arrayExporter()) => cpuMs(() => unwrapAsync(editFile(u, { path: 'run.txt', find: 'a', replace: 'b', author: A, message: 'e' }, { tracer: new Tracer({ exporter: ex }) })).then(() => null, e => e));
187 await run(small.url); // warm-up, discarded
188 const base = [(await run(small.url)).ms, (await run(small.url)).ms, (await run(small.url)).ms].sort((a, b) => a - b)[1];
189 const ex = arrayExporter();
190 const { v: err, ms } = await run(r.url, ex);
191 assert.ok(ms < 24 * base, `128 KiB of hits cost ${ms.toFixed(0)} ms CPU, ${(ms / base).toFixed(1)}x 16 KiB (${base.toFixed(0)} ms); linear is <= 8x`);
192 assert.equal(err?.code, 'match_count', err?.message);
193 assert.equal(err.matches, 128 << 10);
194 assert.equal(err.message, `expected exactly one match, found ${128 << 10}`);
195 const blob = ex.lines.flatMap(flattenLine).find(s => s.name === 'git.edit.blob');
196 assert.equal(blob.attrs['git.edit.blob.scan.matches'], 128 << 10);
197 assert.deepEqual(blob.attrs['git.edit.blob.scan.match_offsets'], Array.from({ length: 16 }, (_, i) => i));
198 assert.equal(git(r.bare, ['rev-parse', 'main']).trim(), head, 'ref untouched');
199});
201test('strictHead: a moved ref is cas_conflict before any push and is not retried; a current head lands', async () => {
202 const r = repo();
203 const h0 = commitFiles(r.work, r.bare, { 'f.txt': 'MARK\n' }, 's');
204 const h1 = commitFiles(r.work, r.bare, { 'g.txt': 'other\n' }, 'moved');
205 let pushes = 0; const counting = (u, i) => { if (String(u).endsWith('git-receive-pack')) pushes++; return fetch(u, i); };
206 await assert.rejects(edit(r, 'f.txt', {}, { head: h0, strictHead: true, fetchImpl: counting }), e => e.code === 'cas_conflict' && e.actual === h1 && e.expected === h0);
207 assert.equal(pushes, 0); assert.equal(git(r.bare, ['rev-parse', 'main']).trim(), h1);
208 const ok = await edit(r, 'f.txt', {}, { head: h1, strictHead: true, fetchImpl: counting });
209 assert.equal(ok.hint, 'used'); assert.equal(ok.oldCommit, h1); assert.equal(pushes, 1);
210 await assert.rejects(edit(r, 'f.txt', {}, { strictHead: true }), e => e.code === 'bad_request');
211});
Diagnostics6 git calls · 73 ms
CallStatusSizeTime073 ms
discover200191 B2 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=191
git.server.agent=git/github-9922ec520325-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=191
git.pkt.payload.max=36
ls-refs20012 KiB · hit2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=11990
git.response.cache=HIT
git.response.duration_ms=2
git.protocol.version=2
git.pkt.frames=152
git.pkt.data=151
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=11990
git.pkt.payload.max=122
git.ls_refs.count=151
git.ls_refs.head=refs/heads/main
fetchtree:0 · deepen 102004.2 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=4347
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=19912563f540228593df0c489082e5e2508e21e4
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4347
git.pkt.payload.max=4247
git.sideband.band1.bytes=4247
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=10
git.pack.bytes=4247
git.pack.ofs_delta=0
git.pack.ref_delta=0
git.pack.chain.max=0
git.pack.trailer=a6caf8e129bea82c9bae4cbc7c130c9205add400
git.pack.full=10
Open pack map
fetchtree:0200919 B · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=919
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=800d30ba8923860bfc460ca884b7f9ba22083588
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=919
git.pkt.payload.max=892
git.sideband.band1.bytes=892
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=892
git.pack.trailer=5323b9266eea5ded637285d1c5320699f12be76e
Open pack map
fetchtree:02005.6 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=65
git.response.bytes=5724
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=58fabb6768b3f737ee9cd8bac647bdc27405fb4d
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=5724
git.pkt.payload.max=5697
git.sideband.band1.bytes=5697
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=5697
git.pack.trailer=be7e0453974a5fe832f9065a33bb7e3434c10e9b
Open pack map
fetch2004.9 KiB65 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=5040
git.response.cache=MISS
git.response.duration_ms=65
git.fetch.wants=aa9b581ea078ed94c60206a5124e5c0ddfc72de6
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=5040
git.pkt.payload.max=5013
git.sideband.band1.bytes=5013
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://github.com/ivarvong/ply
Ref
refs/heads/main
Commit
19912563f540228593df0c489082e5e2508e21e4
cf-ray
a5e15f6c8b57725b
Request
3a2d51eb…
Protocol
v2 · sha1
Agent
git/github-9922ec520325-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format