Artifactspublic-v0

ply

main
ply4 git calls362 ms44 KiB2 cachedprotocol v2
246 lines21 KiBRaw
1// A Result-returning API never throws or rejects when a caller-supplied operation callback does (README "never a
2// throw"). Each row makes one callback throw or reject and asserts the promise resolves to a Result whose outcome class
3// is the one the protocol dictates, judged by real git on the bare repository:
4// - definite (any code but 'ambiguous'): the callback failed before a receive-pack request existed, so the ref cannot
5// have moved, and git rev-parse says it did not.
6// - 'ambiguous': the callback failed after the receive-pack request was handed to the transport. In the end-to-end
7// row the transport really delivers the push and then throws, and git says the ref DID move: 'ambiguous' (retry:
8// read) is the only honest class there; a definite failure would be a lie.
9// Expected codes are the contract, hand-derived, not ply's output: bad_request (retry 'no') names the caller's failing
10// callback in `what` and carries the thrown value as `cause`.
11import { test, beforeAll, afterAll } from 'vitest';
12import assert from 'node:assert/strict';
13import { chmodSync, mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
14import { join } from 'node:path';
15import { editFile, commitChanges, readCommit, checkoutTree, createTransport, cachingFetch, memoryCache, Tracer } from '../src/index.js';
16import { filesFromDir, pushDir } from '../src/tree-node.js';
17import { operation } from '../src/operation.js';
18import { tmpRoot, makeBareRepo, git, commitFiles, startGitServer } from './server.js';
20let server; let bare; let url; let cleanup; let root;
21const author = { name: 'T', email: 't@example.com' };
22const head = () => git(bare, ['rev-parse', 'refs/heads/main']).trim();
23beforeAll(async () => {
24 const tmp = tmpRoot(); cleanup = tmp.cleanup; root = tmp.root;
25 bare = makeBareRepo(tmp.root, 'r');
26 const work = join(tmp.root, 'work'); mkdirSync(work); git(work, ['init', '-q', '-b', 'main']);
27 commitFiles(work, bare, { 'a.txt': 'one\n' });
28 server = await startGitServer(tmp.root);
29 url = `${server.url}/r.git`;
30});
31afterAll(async () => { await server.close(); cleanup(); });
33// what the callback throws: a fresh value per row (ply may tag a transport's thrown error with a code in place)
34let boom = new Error('boom');
35const edit = (opts, n) => editFile(url, { ref: 'refs/heads/main', path: 'a.txt', find: 'one', replace: `two-${n}`, author, message: 'm' }, opts);
36// a write that does not depend on what earlier rows left in the repository
37const write = (opts, n) => commitChanges(url, { ref: 'refs/heads/main', changes: [{ kind: 'write', path: `f-${n}.txt`, content: `row ${n}\n` }], author, message: 'm' }, opts);
38// a caller's transport: the real one with one method replaced
39const transportWith = replace => { const made = createTransport(url, { tracer: new Tracer() }); assert.equal(made.ok, true); return { ...made.value, ...replace(made.value) }; };
40const dir = () => { const d = mkdtempSync(join(root, 'd-')); writeFileSync(join(d, 'f'), 'x'); return d; };
42// [label, run, expected code (null: any definite code; 'ok': the callback is not on this path), expected `what` (null: not asserted), class]
43const rows = [
44 ['signer.sign rejects (editFile)', n => edit({ signer: { sign: async () => { await null; throw boom; }, publicKey: 'x' } }, n), 'bad_request', 'signer', 'definite'],
45 ['signer.sign throws synchronously (commitChanges)', n => write({ signer: { sign: () => { throw boom; }, publicKey: 'x' } }, n), 'bad_request', 'signer', 'definite'],
46 ['pushDir filter throws', () => pushDir(url, { dir: dir(), ref: 'refs/heads/main', author, message: 'm', filter: () => { throw boom; } }, {}), 'bad_request', 'filter', 'definite'],
47 // A caller's transport, fetchImpl and pack-cache callbacks are named like the signer (README "Your own code failing").
48 // Hand-derived: an upload-pack request only reads, so a frames() failure there is definite (bad_request: the caller's
49 // code); a receive-pack request was handed to the transport when frames() was called for it, so it is ambiguous.
50 ['caller transport: frames throws on upload-pack', n => write({ transport: transportWith(() => ({ frames: () => { throw boom; } })) }, n), 'bad_request', 'transport.frames', 'definite'],
51 ['caller transport: frames rejects on iteration (upload-pack)', n => write({ transport: transportWith(() => ({ frames: () => (async function* () { await null; throw boom; })() })) }, n), 'bad_request', 'transport.frames', 'definite'],
52 ['caller transport: frames throws when called for receive-pack', n => write({ transport: transportWith(real => ({ frames: (service, body, span, hints) => { if (service === 'git-receive-pack') throw boom; return real.frames(service, body, span, hints); } })) }, n), 'ambiguous', 'transport.frames', 'handed-over'],
53 ['caller transport: frames throws after delivering the push', n => write({ transport: transportWith(real => ({
54 // the real request is made and fully read (the push lands), then the caller's code throws
55 frames: (service, body, span, hints) => service !== 'git-receive-pack' ? real.frames(service, body, span, hints) : (async function* () { const all = []; for await (const f of real.frames(service, body, span, hints)) all.push(f); throw boom; })(),
56 })) }, n), 'ambiguous', 'transport.frames', 'landed'],
57 // advertise is consulted only to confirm a refused push; a healthy push never calls it, so its failure changes nothing
58 ['caller transport: advertise rejects', n => write({ transport: transportWith(() => ({ advertise: async () => { await null; throw boom; } })) }, n), 'ok', null, 'ok'],
59 // an advertise() that ply does call: the body asks the caller's transport for the upload-pack advertisement
60 ['caller transport: advertise rejects when called', () => operation('probe', url, { transport: transportWith(() => ({ advertise: async () => { await null; throw boom; } })) }, async ({ t, root: span }) => t.advertise('git-upload-pack', span)), 'bad_request', 'transport.advertise', 'definite'],
61 // A fetch that fails is a network failure (README's error table: `network`), whoever supplied the fetch; a supplied one is named.
62 ['fetchImpl throws synchronously (read)', () => readCommit(url, { ref: 'main' }, { fetchImpl: () => { throw boom; } }), 'network', 'fetchImpl', 'definite'],
63 ['fetchImpl rejects (write)', n => write({ fetchImpl: async () => { await null; throw boom; } }, n), 'network', 'fetchImpl', 'definite'],
64 // the pack cache's callbacks run on upload-pack (read) requests only: definite, the caller's code (bad_request)
65 ['cachingFetch: shouldCache throws (read)', () => readCommit(url, { ref: 'main' }, { fetchImpl: cachingFetch(globalThis.fetch, memoryCache(), { shouldCache: () => { throw boom; } }) }), 'bad_request', 'shouldCache', 'definite'],
66 ['cachingFetch: cache.match throws synchronously (read)', () => readCommit(url, { ref: 'main' }, { fetchImpl: cachingFetch(globalThis.fetch, { ...memoryCache(), match: () => { throw boom; } }) }), 'bad_request', 'cache.match', 'definite'],
67 ['cachingFetch: waitUntil throws (read)', () => readCommit(url, { ref: 'main' }, { fetchImpl: cachingFetch(globalThis.fetch, memoryCache(), { shouldCache: () => true, waitUntil: () => { throw boom; } }) }), 'bad_request', 'waitUntil', 'definite'],
68 // the put of a miss is called inside the fetch that missed, before it answers
69 ['cachingFetch: cache.put throws synchronously (read)', () => readCommit(url, { ref: 'main' }, { fetchImpl: cachingFetch(globalThis.fetch, { ...memoryCache(), put: () => { throw boom; } }) }), 'bad_request', 'cache.put', 'definite'],
70 // under verifyBeforeStore the put is called only after verifyFetchAnswer accepted the answer, after the fetch
71 // answered (README cachingFetch), so a put that throws is counted in stats.putFailed and the read is unaffected;
72 // waitUntil is still called inside the fetch, so one that throws is this read's own named Err
73 ['cachingFetch verifyBeforeStore: cache.put throws synchronously (read)', () => readCommit(url, { ref: 'main' }, { fetchImpl: cachingFetch(globalThis.fetch, { ...memoryCache(), put: () => { throw boom; } }, { verifyBeforeStore: true }) }), 'ok', null, 'ok'],
74 ['cachingFetch verifyBeforeStore: waitUntil throws (read)', () => readCommit(url, { ref: 'main' }, { fetchImpl: cachingFetch(globalThis.fetch, memoryCache(), { verifyBeforeStore: true, waitUntil: () => { throw boom; } }) }), 'bad_request', 'waitUntil', 'definite'],
75 // operation()'s own edge, for any callback not wrapped where it is called: the body stands in for one
76 ['operation(): a foreign throw before any request', () => operation('probe', url, {}, async () => { await null; throw boom; }), 'bad_request', 'callback', 'definite'],
77 ['operation(): a foreign throw after an upload-pack request only', () => operation('probe', url, {}, async ({ t, root: span }) => { await null; t.frames('git-upload-pack', new Uint8Array(0), span, {}); throw boom; }), 'bad_request', 'callback', 'definite'],
78 // hand-derived: the body gave a receive-pack request to the transport, so ply cannot say the ref did not move
79 ['operation(): a foreign throw after the push request was handed to the transport', () => operation('probe', url, {}, async ({ t, root: span }) => { await null; t.frames('git-receive-pack', new Uint8Array(0), span, {}); throw boom; }), 'ambiguous', 'callback', 'handed-over'],
80];
82rows.forEach(([label, run, code, what, cls], n) => {
83 test(`${label}: ${code === 'ok' ? 'unaffected' : `a coded Err (${code === null ? 'definite' : code})`}, never a throw`, async () => {
84 const before = head();
85 boom = new Error(`boom ${n}`);
86 let r;
87 try { r = await run(n); } catch (e) { assert.fail(`the Result API threw/rejected: ${String(e)}`); }
88 if (cls === 'ok') { assert.equal(r.ok, true); assert.equal(head(), r.value.oid, 'git: the ref is at the commit reported'); return; }
89 assert.equal(r.ok, false, 'a failing callback cannot be ok');
90 if (code === null) assert.notEqual(r.error.code, 'ambiguous', 'nothing was pushed: a definite failure'); else assert.equal(r.error.code, code);
91 if (what !== null) {
92 assert.equal(r.error.what, what, 'the Err names the callback');
93 assert.equal(r.error.cause, boom, 'the Err carries the very value the callback threw as its cause');
94 assert.notEqual(r.error, boom, "the Err is ply's own object, not the caller's thrown value");
95 // a fresh Error has no own enumerable keys (the language): ply wrote none on the caller's object
96 assert.deepEqual(Object.keys(boom), [], "ply wrote nothing on the caller's thrown Error");
97 }
98 if (cls === 'landed') assert.notEqual(head(), before, 'this row delivers the push before throwing: git says the ref moved, so only ambiguous is honest');
99 else assert.equal(head(), before, 'git says the ref did not move');
100 });
101});
103// The cache's delete is called only on a bust (the transport's one refetch after a poisoned hit, `x-ply-cache: bust`),
104// so the fetch is called here as the transport calls it. A fetch reports a failure by rejecting: the rejection is the
105// named Err, which the transport returns as it is (the cache.match row above shows that path end to end).
106test("cachingFetch: cache.delete throws synchronously on a bust: the fetch rejects with bad_request naming 'cache.delete'", async () => {
107 const thrown = new Error('boom delete');
108 const f = cachingFetch(globalThis.fetch, { ...memoryCache(), delete: () => { throw thrown; } }, { shouldCache: () => true });
109 const e = await f(`${url}/git-upload-pack`, { method: 'POST', headers: { 'x-ply-cache': 'bust' }, body: new Uint8Array(4) }).then(() => assert.fail('the fetch resolved'), x => x);
110 assert.deepEqual([e.code, e.what], ['bad_request', 'cache.delete']);
111 assert.equal(e.cause, thrown, 'the Err carries the very value the callback threw as its cause');
112 assert.notEqual(e, thrown, "the Err is ply's own object, not the caller's thrown value");
113 assert.deepEqual(Object.keys(thrown), [], "ply wrote nothing on the caller's thrown Error");
114});
116// operation() hands the body a view of the caller's transport (it records the push hand-over), and ply hands each
117// sub-exchange a further view (withParent(t, span)). A caller's frames() runs as a method of the view it was called on,
118// so `this.parent` is that exchange's span. Expected names are the spans a checkout opens, by the README's span table
119// and as on main: the root git.checkout (the tree listing) and git.checkout.blobs (the blob fetch).
120test("a caller transport's frames() is called on the exchange's view: this.parent is that exchange's span", async () => {
121 const made = createTransport(url, { tracer: new Tracer() }); assert.equal(made.ok, true);
122 const real = made.value; const parents = new Set();
123 const transport = { ...real, frames(service, body, span, hints) { parents.add(this.parent.name); return real.frames(service, body, span, hints); } };
124 const r = await checkoutTree(url, { ref: 'main' }, { transport });
125 assert.equal(r.ok, true);
126 for await (const f of r.value.files) void f;
127 assert.deepEqual([...parents].sort(), ['git.checkout', 'git.checkout.blobs']);
128});
130// The file system's own failures are not throws either (README: never a throw). The expected `cause.code` is node:fs's
131// errno name for the condition set up here (a path that does not exist: ENOENT; a file with no read permission:
132// EACCES), not anything ply computes. Definite: the walk precedes any request, and the bare repository's ref is unmoved.
133const fsRows = [
134 ['a missing directory', () => join(root, 'no-such-dir'), 'ENOENT'],
135 ['an unreadable file', () => { const d = dir(); chmodSync(join(d, 'f'), 0o000); return d; }, 'EACCES'],
136];
137for (const [label, makeDir, errno] of fsRows) {
138 test(`pushDir and filesFromDir on ${label}: a coded Err (bad_request, what 'dir') carrying node:fs's ${errno}, never a throw`, async ctx => {
139 // root reads any file: the unreadable row cannot be set up there
140 if (errno === 'EACCES' && process.getuid?.() === 0) { ctx.skip(); return; }
141 const before = head();
142 const d = makeDir();
143 for (const run of [() => pushDir(url, { dir: d, ref: 'refs/heads/main', author, message: 'm' }, {}), () => filesFromDir(d)]) {
144 let r;
145 try { r = await run(); } catch (e) { assert.fail(`the Result API threw/rejected: ${String(e)}`); }
146 assert.equal(r.ok, false);
147 assert.equal(r.error.code, 'bad_request');
148 assert.equal(r.error.what, 'dir', 'the Err names the directory walk');
149 assert.equal(r.error.cause.code, errno, "the cause is node:fs's own error");
150 }
151 assert.equal(head(), before, 'the ref did not move');
152 });
155// Describing a thrown value never throws, whatever the value. Each value below has no string form, or cannot be read
156// at all. The oracle is the language, not ply: reading `.message` or calling String() on each one throws (asserted per
157// row, so a row is never vacuous), and the contract above still holds: a coded Err that names the callback, carries
158// the very value as `cause` and has a string message, with the ref where git says it was.
159const hostile = {
160 'a null-prototype object': () => Object.create(null),
161 'an object whose message getter throws': () => ({ get message() { throw new Error('getter'); } }),
162 'an object whose toString throws': () => ({ toString() { throw new Error('toString'); } }),
163 'a revoked Proxy': () => { const p = Proxy.revocable({}, {}); p.revoke(); return p.proxy; },
164};
165// [where the value is thrown, run(value, n), expected code, expected `what`]: hand-derived as in the rows above
166const sites = [
167 ['operation() before any request', v => operation('probe', url, {}, async () => { await null; throw v; }), 'bad_request', 'callback'],
168 ['operation() after the push request was handed to the transport', v => operation('probe', url, {}, async ({ t, root: span }) => { await null; t.frames('git-receive-pack', new Uint8Array(0), span, {}); throw v; }), 'ambiguous', 'callback'],
169 ['signer.sign (editFile)', (v, n) => edit({ signer: { sign: () => { throw v; }, publicKey: 'x' } }, `hostile-${n}`), 'bad_request', 'signer'],
170 ['the filesFromDir filter', v => filesFromDir(dir(), { filter: () => { throw v; } }), 'bad_request', 'filter'],
171 ["a caller transport's frames() (readCommit)", v => readCommit(url, { ref: 'main' }, { transport: transportWith(() => ({ frames: () => { throw v; } })) }), 'bad_request', 'transport.frames'],
172 ["a caller transport's frames() (commitChanges)", (v, n) => write({ transport: transportWith(() => ({ frames: () => { throw v; } })) }, `hostile-${n}`), 'bad_request', 'transport.frames'],
173 ['fetchImpl (readCommit)', v => readCommit(url, { ref: 'main' }, { fetchImpl: () => { throw v; } }), 'network', 'fetchImpl'],
174 ['a rejecting fetchImpl (commitChanges)', (v, n) => write({ fetchImpl: async () => { await null; throw v; } }, `hostile-${n}`), 'network', 'fetchImpl'],
175];
176Object.entries(hostile).forEach(([name, make], i) => {
177 sites.forEach(([where, run, code, what], j) => {
178 test(`${where} throws ${name}: a coded Err (${code}) naming '${what}', never a throw`, async () => {
179 const before = head();
180 const v = make();
181 assert.throws(() => String(v.message ?? v), 'the language: this value cannot be described by reading its message or by String()');
182 let r;
183 try { r = await run(v, `${i}-${j}`); } catch (e) { assert.fail(`the Result API threw/rejected: ${e instanceof Error ? e.message : 'a value with no string form'}`); }
184 assert.equal(r.ok, false, 'a failing callback cannot be ok');
185 assert.equal(r.error.code, code);
186 assert.equal(r.error.what, what, 'the Err names the callback');
187 assert.ok(r.error.cause === v, 'the Err carries the very value the callback threw as its cause');
188 assert.equal(typeof r.error.message, 'string');
189 assert.equal(head(), before, 'git says the ref did not move');
190 });
191 });
192});
194// The same for the directory itself: filesFromDir's Err describes `dir`, and a `dir` that is not a string may have no
195// string form either. node:fs refuses it with a TypeError of its own, and README's row for node:fs failures applies:
196// bad_request, what: 'dir', node's error as the cause.
197for (const [name, make] of [['a Symbol', () => Symbol('d')], ...Object.entries(hostile).filter(([n]) => n !== 'an object whose message getter throws')]) {
198 test(`filesFromDir and pushDir with ${name} as dir: bad_request naming 'dir', never a throw`, async () => {
199 const before = head();
200 for (const run of [d => filesFromDir(d), d => pushDir(url, { dir: d, ref: 'refs/heads/main', author, message: 'm' }, {})]) {
201 const d = make();
202 assert.throws(() => `${d}`, 'the language: this value has no string form');
203 let r;
204 try { r = await run(d); } catch (e) { assert.fail(`the Result API threw/rejected: ${e instanceof Error ? e.message : 'a value with no string form'}`); }
205 assert.equal(r.ok, false);
206 assert.equal(r.error.code, 'bad_request');
207 assert.equal(r.error.what, 'dir');
208 // node's ERR_INVALID_ARG_TYPE, or for the revoked Proxy the engine's own refusal to read it: a TypeError either way
209 assert.ok(r.error.cause instanceof TypeError, "the cause is node's refusal of the argument, not something ply made");
210 }
211 assert.equal(head(), before, 'git says the ref did not move');
212 });
215// A put or waitUntil that throws when called ends the fetch with the named Err, and the answer is abandoned first
216// (src/packcache.ts): the origin's body is cancelled before the rejection, and nothing of it stays stored. The origin
217// here is a stream that records its own cancel(); the order of events is the oracle (the WHATWG Streams standard:
218// cancelling a reader calls the underlying source's cancel), not anything ply reports. The origin sends one chunk and
219// then holds the stream open, so only a cancel can end it.
220for (const [what, cacheOf, optionsOf] of [
221 ['cache.put', thrown => ({ ...memoryCache(), put: () => { throw thrown; } }), () => ({})],
222 ['waitUntil', () => memoryCache(), thrown => ({ waitUntil: () => { throw thrown; } })],
223]) {
224 test(`cachingFetch: ${what} throws synchronously: the origin is cancelled before the fetch rejects with bad_request naming '${what}', and nothing stays stored`, async () => {
225 const thrown = new Error(`boom ${what}`);
226 const events = [];
227 const origin = async () => {
228 await null;
229 const body = new ReadableStream({
230 start(ctl) { ctl.enqueue(new Uint8Array([0x30, 0x30, 0x30, 0x38, 0x4e, 0x41, 0x4b, 0x0a])); },
231 pull() { return new Promise(() => null); },
232 cancel() { events.push('origin cancelled'); },
233 });
234 return new Response(body, { status: 200, headers: { 'content-type': 'application/x-git-upload-pack-result' } });
235 };
236 const cache = cacheOf(thrown);
237 const f = cachingFetch(origin, cache, { shouldCache: () => true, ...optionsOf(thrown) });
238 const e = await f(`${url}/git-upload-pack`, { method: 'POST', body: new Uint8Array(4) }).then(() => assert.fail('the fetch resolved'), x => { events.push('rejected'); return x; });
239 assert.deepEqual([e.code, e.what], ['bad_request', what]);
240 assert.equal(e.cause, thrown, 'the Err carries the very value the callback threw as its cause');
241 assert.deepEqual(events, ['origin cancelled', 'rejected'], "the origin's body is cancelled before the fetch rejects");
242 // let a store that was started (the waitUntil row) settle and clean up
243 for (let i = 0; i < 20; i++) await new Promise(r => setImmediate(r));
244 assert.equal(cache.entries.size, 0, 'nothing of the abandoned answer stays stored');
245 });
Diagnostics4 git calls · 362 ms
CallStatusSizeTime0362 ms
discover200152 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=152
git.server.agent=gitty/1.0
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch object-format
git.server.fetch=shallow filter sideband-all
git.protocol.version=2
git.pkt.frames=8
git.pkt.data=6
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=152
git.pkt.payload.max=34
ls-refs200145 B · hit5 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=145
git.response.cache=HIT
git.response.duration_ms=2
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=145
git.pkt.payload.max=76
git.ls_refs.count=2
git.ls_refs.head=refs/heads/main
fetchblob:none · deepen 1020038 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=38434
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=blob:none
git.fetch.filter.requested=tree:0
git.fetch.filter.fallback=blob:none
git.fetch.filter.learned=false
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=6
git.pkt.data=4
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=38434
git.pkt.payload.max=38339
git.sideband.band1.bytes=38338
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=63
git.pack.bytes=38338
git.pack.ofs_delta=0
git.pack.ref_delta=8
git.pack.chain.max=8
git.pack.trailer=0bc36ab7adf82d3109177f11f1ea93f1ce071f77
git.pack.full=55
Open pack map
fetch2006.1 KiB355 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=355
git.response.bytes=6244
git.response.cache=MISS
git.response.duration_ms=355
git.fetch.wants=f367b16be08dce6734d922d03717e1cf77227137
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=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=6244
git.pkt.payload.max=6223
git.sideband.band1.bytes=6222
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://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/ply.git
Ref
refs/heads/main
Commit
19912563f540228593df0c489082e5e2508e21e4
cf-ray
a5e22ed1c921a594
Request
bd826805…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format