main
1// The space of merge-base outcomes, enumerated (#41, #42). Each dimension is a tagged union; the test walks their full
2// product deterministically and judges every cell against git (`git merge-base --all`, `git merge-tree --write-tree`,
3// `git rebase`), never against a model of what ply should do.
4//
5// Position: where the best base(s) sit relative to mergeBase's first window (depth 8; a tip is depth 1). k counts
6// the commits strictly above the base on a side, the tip included:
7// above k = 3 / 3 the base is inside the window
8// at k = 8 / 8 the base is exactly at the cut: named by both sides' children, never fetched (#41)
9// below k = 11 / 11 the base is past the first window (found at 16)
10// skew k = 8 / 2 at the cut on one side, inside on the other
11// Multiplicity: how many best bases git finds, and whether a cut could fake a second one:
12// one a single base B
13// two a true criss-cross: X, Y; ours merges [X, Y], theirs [Y, X]
14// hidden-near candidates c and z, z below c through 2 commits; both sides merge [c, z]: git has one base, c
15// hidden-far the same with 12 commits between c and z: the first window cuts that link (#42)
16// Settled: the history below the base(s), where a cut lands inside the settled region:
17// none the base(s) are roots
18// short 3 commits below
19// deep 40 commits below (more than the cap of 32 below: a walk to the root is limit_exceeded)
20// Server: the seven behaviours of test/fuzz/liar.mjs's merge-base family (test/fuzz/mergelies.js).
21// Op: mergeBase, mergeBranch; and rebaseBranch on the honest server where git has one base. Where the branch holds a
22// merge commit (the hidden shapes' [c, z]) git rebase linearizes it and ply refuses, typed (not_linear, rebase.js's
23// stated contract); every other rebase cell must equal `git rebase` tree for tree.
24//
25// Every tree is additive (each commit adds f/<name>), so every merge and rebase git performs is clean and the
26// expected tree is git's, not ours. maxMergeDepth is 32 for every cell.
27import { test, beforeAll as before, afterAll as after } from 'vitest';
28import assert from 'node:assert/strict';
29import { join } from 'node:path';
30import { readFileSync, rmSync, mkdtempSync } from 'node:fs';
31import { spawnSync } from 'node:child_process';
32import { tmpdir } from 'node:os';
33import { tmpRoot, makeBareRepo, startGitServer, fsckProblems } from './server.js';
34import { startProxy } from './proxy.js';
35import { MERGE_LIES, mergeLie } from './fuzz/mergelies.js';
36import { oracleRediff } from './gitversion.js';
37import { mergeBase, mergeBranch } from '../src/merge.js';
38import { rebaseBranch, cherryPick, revertCommit } from '../src/rebase.js';
39import { createTransport as createTransportR } from '../src/http.js';
40import { withLimits } from '../src/limits.js';
41import { Tracer } from '../src/otel.js';
42import { TYPE } from '../src/objects.js';
43import { unwrapAsync } from './unwrap.js';
45import { unwrap } from './unwrap.js';
46// Throwing adapters over the Result API (0.2.0): the assertions below are about the throw.
47const createTransport = (...a) => unwrap(createTransportR(...a));
48const rediff = oracleRediff();
49const ENV = { ...process.env, GIT_AUTHOR_NAME: 'w', GIT_AUTHOR_EMAIL: 'w@x', GIT_COMMITTER_NAME: 'w', GIT_COMMITTER_EMAIL: 'w@x', GIT_AUTHOR_DATE: '1700000000 +0000', GIT_COMMITTER_DATE: '1700000000 +0000', GIT_CONFIG_COUNT: '1', GIT_CONFIG_KEY_0: 'commit.gpgsign', GIT_CONFIG_VALUE_0: 'false' };
50const sh = (cwd, args, input) => { const r = spawnSync('git', ['-C', cwd, ...args], { encoding: 'utf8', env: ENV, input, maxBuffer: 1 << 26 }); if (r.status !== 0 && !args.includes('merge-tree')) throw new Error(`git ${args.join(' ')}: ${r.stderr}`); return r; };
51const out = (cwd, args, input) => sh(cwd, args, input).stdout.trim();
52const CAP = 32;
53const CODES = new Set(['pack_corrupt', 'protocol', 'network', 'timeout', 'aborted', 'not_git', 'not_found', 'http', 'limit_exceeded', 'remote_error', 'cas_conflict', 'push_rejected', 'ambiguous', 'merge_conflict', 'unrelated_histories', 'not_fast_forward', 'not_linear']);
55export const POSITION = { above: [3, 3], at: [8, 8], below: [11, 11], skew: [8, 2] };
56export const MULTIPLICITY = { one: null, two: null, 'hidden-near': 2, 'hidden-far': 12 };
57export const SETTLED = { none: 0, short: 3, deep: 40 };
58const SERVERS = Object.keys(MERGE_LIES);
60// A shape as an ordered list of [name, parents] (parents first), the tips, and the bases git must find (by name).
61function shape(pos, mult, settled) {
62 const spec = []; const add = (n, ps) => spec.push([n, ps]);
63 const below = SETTLED[settled];
64 const under = prefix => { // a chain of `below` commits under the base(s); returns the name to hang them on (or null)
65 if (!below) return null;
66 for (let i = below; i >= 1; i--) add(`${prefix}${i}`, i < below ? [`${prefix}${i + 1}`] : []);
67 return `${prefix}1`;
68 };
69 const side = (tag, k, top) => { // k commits above `top` (an array of parents for the lowest), the tip is `${tag}1`
70 for (let i = k; i >= 1; i--) add(`${tag}${i}`, i === k ? top : [`${tag}${i + 1}`]);
71 return `${tag}1`;
72 };
73 const [ko, kt] = POSITION[pos];
74 let bases, ours, theirs;
75 if (mult === 'one') {
76 const s = under('s'); add('B', s ? [s] : []); bases = ['B'];
77 ours = side('o', ko, ['B']); theirs = side('t', kt, ['B']);
78 } else if (mult === 'two') {
79 const s = under('s'); add('X', s ? [s] : []); add('Y', s ? [s] : []); bases = ['X', 'Y'];
80 ours = side('o', ko, ['X', 'Y']); theirs = side('t', kt, ['Y', 'X']);
81 } else {
82 const L = MULTIPLICITY[mult];
83 const s = under('s'); add('z', s ? [s] : []);
84 for (let i = L; i >= 1; i--) add(`h${i}`, [i === L ? 'z' : `h${i + 1}`]);
85 add('c', ['h1']); bases = ['c'];
86 ours = side('o', ko, ['c', 'z']); theirs = side('t', kt, ['c', 'z']);
87 }
88 return { spec, ours, theirs, bases, k: [ko, kt] };
89}
91// The shape as a real repository: fast-import, one commit per spec entry, each adding f/<name> to the union of its
92// parents' files. Returns name → oid and the lie target (dag.js model shape, commit and tree bytes).
93function build(root, name, { spec, ours, theirs }) {
94 const bare = makeBareRepo(root, name);
95 const files = new Map(); const mark = new Map(); let stream = '';
96 const data = s => `data ${Buffer.byteLength(s)}\n${s}\n`;
97 spec.forEach(([n, ps], i) => {
98 const f = new Set([`f/${n}`]); for (const p of ps) for (const x of files.get(p)) f.add(x); files.set(n, f);
99 mark.set(n, i + 1);
100 stream += `reset refs/tmp/b\ncommit refs/tmp/b\nmark :${i + 1}\nauthor w <w@x> 1700000000 +0000\ncommitter w <w@x> 1700000000 +0000\n${data(n)}`;
101 if (ps.length) stream += `from :${mark.get(ps[0])}\n`; for (const p of ps.slice(1)) stream += `merge :${mark.get(p)}\n`;
102 stream += 'deleteall\n'; for (const x of [...f].sort()) stream += `M 100644 inline ${x}\n${data(x.slice(2))}`;
103 });
104 const marks = join(bare, 'marks');
105 sh(bare, ['fast-import', '--quiet', `--export-marks=${marks}`], stream);
106 const byMark = new Map(readFileSync(marks, 'utf8').trim().split('\n').map(l => { const [m, o] = l.split(' '); return [+m.slice(1), o]; }));
107 const oid = new Map(spec.map(([n], i) => [n, byMark.get(i + 1)]));
108 sh(bare, ['update-ref', '-d', 'refs/tmp/b']);
109 sh(bare, ['update-ref', 'refs/heads/main', oid.get(ours)]); sh(bare, ['update-ref', 'refs/heads/feat', oid.get(theirs)]);
110 // the lie target: commits as dag.js readModel gives them, and every commit's and root tree's bytes, read in one batch
111 const all = [...oid.values()];
112 const batch = r => { const buf = spawnSync('git', ['-C', bare, 'cat-file', '--batch'], { input: r.join('\n') + '\n', maxBuffer: 1 << 26 }).stdout; const res = []; let p = 0;
113 while (p < buf.length) { const nl = buf.indexOf(10, p); const [, , size] = buf.subarray(p, nl).toString().split(' '); const s = +size; res.push(new Uint8Array(buf.subarray(nl + 1, nl + 1 + s))); p = nl + 1 + s + 1; } return res; };
114 const cdata = batch(all); const commitData = new Map(all.map((o, i) => [o, cdata[i]]));
115 const commits = new Map(all.map((o, i) => { const txt = Buffer.from(cdata[i]).toString('latin1'); return [o, { tree: /^tree ([0-9a-f]{40})/.exec(txt)[1], parents: [...txt.matchAll(/^parent ([0-9a-f]{40})$/gm)].map(m => m[1]), date: 1700000000 }]; }));
116 const treeList = [...new Set([...commits.values()].map(c => c.tree))]; const tdata = batch(treeList); const trees = new Map(treeList.map((t, i) => [t, tdata[i]]));
117 return { bare, oid, target: { model: { commits }, commitData, treeOf: c => trees.get(commits.get(c).tree) } };
118}
120let root, cleanup, srv, decoy;
121before(async () => {
122 ({ root, cleanup } = tmpRoot()); srv = await startGitServer(root);
123 // the unrelated commit for mb:extra-foreign
124 const d = makeBareRepo(root, 'decoy');
125 sh(d, ['fast-import', '--quiet'], 'commit refs/heads/main\ncommitter d <d@x> 1700000000 +0000\ndata 6\ndecoy\nM 100644 inline decoy.txt\ndata 6\ndecoy\n\n');
126 const head = out(d, ['rev-parse', 'main']);
127 decoy = { type: TYPE.COMMIT, data: new Uint8Array(spawnSync('git', ['-C', d, 'cat-file', 'commit', head]).stdout) };
128});
129after(async () => { await srv?.close(); cleanup?.(); });
131// One cell: run `op` behind `server` on a fresh copy of the shape's refs; return the problems git finds with it.
132async function cell(S, R, server, op, seed, git) {
133 const M = { ...R.target, decoy, lied: 0, omitted: 0 };
134 const ours = R.oid.get(S.ours), theirs = R.oid.get(S.theirs);
135 sh(R.bare, ['update-ref', 'refs/heads/main', ours]); sh(R.bare, ['update-ref', 'refs/heads/feat', theirs]);
136 const proxy = await startProxy(srv.url, mergeLie(M, server, seed));
137 const url = `${proxy.url}/${R.name}.git`; const limits = withLimits({ requestTimeoutMs: 5000, maxMergeDepth: CAP });
138 let res = null, err = null;
139 try {
140 if (op === 'mergeBase') res = await unwrapAsync(mergeBase(createTransport(url, { tracer: new Tracer(), limits }), ours, theirs, { maxDepth: CAP }));
141 else if (op === 'mergeBranch') res = await unwrapAsync(mergeBranch(url, { ref: 'refs/heads/main', from: 'refs/heads/feat', author: { name: 'm', email: 'm@x' } }, { tracer: new Tracer(), limits, rediff }));
142 else res = await unwrapAsync(rebaseBranch(url, { ref: 'refs/heads/main', onto: 'refs/heads/feat', committer: { name: 'r', email: 'r@x' }, time: 1700000000 }, { tracer: new Tracer(), limits, rediff }));
143 } catch (e) { err = e; }
144 await proxy.close();
145 const p = []; const lied = M.lied > 0;
146 const same = (x, y) => x.length === y.length && x.every((v, i) => v === y[i]);
147 const now = out(R.bare, ['rev-parse', 'refs/heads/main']);
148 if (err) {
149 if (!CODES.has(err.code)) p.push(`untyped ${err.code ?? err.name}: ${err.message}`);
150 if (now !== ours) p.push('ref moved on error');
151 const ok = err.code === 'pack_corrupt' || err.code === 'limit_exceeded' ? lied // a lie, caught or run to the cap
152 : err.code === 'merge_conflict' ? git.bases.length > 1 && same([...(err.bases ?? [])].sort(), git.bases) // criss-cross refusal, git's bases
153 : err.code === 'not_linear' ? op === 'rebaseBranch' && git.branchMerges > 0 : false; // ply rebases linear branches only
154 if (!ok) p.push(`${err.code} (${lied ? 'lied to' : 'HONEST'}): ${err.message}`);
155 } else if (op === 'mergeBase') {
156 if (!same([...res.bases].sort(), git.bases)) p.push(`bases ${res.bases.map(x => x.slice(0, 8))} != git ${git.bases.map(x => x.slice(0, 8))} (${lied ? 'lied to' : 'HONEST'}, depth ${res.depth})`);
157 } else if (op === 'mergeBranch') {
158 if (git.bases.length !== 1) p.push(`merged (${res.outcome}) where git has ${git.bases.length} bases`);
159 else if (res.outcome !== 'merge' || res.base !== git.bases[0] || res.tree !== git.mergeTree) p.push(`merge ${res.outcome} base ${String(res.base).slice(0, 8)} tree ${String(res.tree).slice(0, 8)}; git: base ${git.bases[0].slice(0, 8)} tree ${git.mergeTree.slice(0, 8)}`);
160 else if (!same(out(R.bare, ['rev-list', '--parents', '-n1', 'main']).split(' ').slice(1), [ours, theirs])) p.push('merge commit parents are not [ours, theirs]');
161 } else if (git.branchMerges > 0) p.push(`rebased a branch with ${git.branchMerges} merge commit(s): ply's contract is not_linear`);
162 else {
163 const trees = out(R.bare, ['log', '--format=%T', '--reverse', `${theirs}..main`]).split('\n');
164 if (!same(trees, git.rebaseTrees)) p.push(`rebase trees ${trees.length} != git rebase ${git.rebaseTrees.length} (or differ)`);
165 }
166 if (!err && op !== 'mergeBase') { const f = fsckProblems(R.bare); if (f.length) p.push(`fsck: ${f[0]}`); }
167 // lies the pack itself contradicts are pack_corrupt whenever they fired
168 if (lied && ['mb:omit-want', 'mb:extra-foreign'].includes(server) && err?.code !== 'pack_corrupt') p.push(`${server} fired but outcome ${err ? err.code : 'success'}`);
169 return { problems: p, lied, outcome: err ? (err.code ?? `untyped ${err.name}`) : op === 'mergeBase' ? `ok(${res.bases.length})@${res.depth}` : `ok:${res.outcome}` };
170}
172test('merge-base outcome space: position × multiplicity × settled × server × op, every cell equal to git', { timeout: 15 * 60_000 }, async () => {
173 const shapes = []; for (const pos of Object.keys(POSITION)) for (const mult of Object.keys(MULTIPLICITY)) for (const settled of Object.keys(SETTLED)) shapes.push({ pos, mult, settled });
174 const fails = [], fired = new Map(SERVERS.map(s => [s, 0])), tally = new Map(); let cells = 0, seq = 0;
175 const runShape = async ({ pos, mult, settled }, idx) => {
176 const S = shape(pos, mult, settled); const name = `s${idx}`; const R = { ...build(root, name, S), name };
177 const ours = R.oid.get(S.ours), theirs = R.oid.get(S.theirs);
178 // git's answer, and the tags checked against it: the multiplicity's base count and the position's k on each side
179 const bases = out(R.bare, ['merge-base', '--all', ours, theirs]).split('\n').sort();
180 assert.deepEqual(bases, S.bases.map(n => R.oid.get(n)).sort(), `${pos}/${mult}/${settled}: git's bases are the shape's`);
181 const excl = bases.map(b => `^${b}`);
182 assert.deepEqual([+out(R.bare, ['rev-list', '--count', ours, ...excl]), +out(R.bare, ['rev-list', '--count', theirs, ...excl])], S.k, `${pos}/${mult}/${settled}: k above the base(s)`);
183 const mt = sh(R.bare, ['merge-tree', '--write-tree', ours, theirs]); assert.equal(mt.status, 0, 'git merges cleanly');
184 // merges on the rebased branch (git rebase drops them and linearizes; ply refuses: not_linear, its stated contract)
185 const git = { bases, mergeTree: mt.stdout.split('\n')[0].trim(), rebaseTrees: null, branchMerges: +out(R.bare, ['rev-list', '--count', '--merges', ours, ...excl]) };
186 if (bases.length === 1) {
187 const d = mkdtempSync(join(tmpdir(), 'mbs-')); sh(d, ['clone', '-q', R.bare, '.']); sh(d, ['rebase', '-q', 'origin/feat']);
188 git.rebaseTrees = out(d, ['log', '--format=%T', '--reverse', 'origin/feat..HEAD']).split('\n'); rmSync(d, { recursive: true, force: true });
189 }
190 for (const server of SERVERS) for (const op of ['mergeBase', 'mergeBranch', ...(server === 'mb:honest' && bases.length === 1 ? ['rebaseBranch'] : [])]) {
191 const seed = (idx * 7919 + SERVERS.indexOf(server) * 104729 + op.length) >>> 0;
192 const r = await cell(S, R, server, op, seed, git); cells++; seq++;
193 if (r.lied) fired.set(server, fired.get(server) + 1);
194 const key = `${server} ${op} → ${r.outcome.replace(/@\d+$/, '')}`; tally.set(key, (tally.get(key) ?? 0) + 1);
195 if (r.problems.length) fails.push(`${pos}/${mult}/${settled} ${server} ${op}: ${r.problems.join('; ')}`);
196 }
197 };
198 // shapes in parallel (each has its own repository), cells of one shape in sequence (they share its refs)
199 let next = 0; await Promise.all(Array.from({ length: 6 }, async () => { while (next < shapes.length) { const i = next++; await runShape(shapes[i], i); } }));
200 const expected = shapes.length * (SERVERS.length * 2) + shapes.filter(s => s.mult !== 'two').length;
201 console.log(`# merge-base space: ${shapes.length} shapes, ${cells} cells (expected ${expected}), ${fails.length} failures`);
202 console.log([...tally].sort().map(([k, v]) => `# ${String(v).padStart(4)} ${k}`).join('\n'));
203 assert.equal(cells, expected);
204 for (const s of SERVERS) if (s !== 'mb:honest') assert.ok(fired.get(s) > 0, `${s} fired in some cell`);
205 assert.deepEqual(fails, []);
206});
208// Parent count of the commit pickCommit is asked to replay. 0 and 1 are what git cherry-pick / revert do; 2 and 3 are
209// merges, which git refuses without -m and ply refuses as not_linear before writing anything.
210test('pickCommit: parents 0–3 × cherry-pick/revert, against git', { timeout: 120_000 }, async () => {
211 const bare = makeBareRepo(root, 'picks');
212 const blob = text => out(bare, ['hash-object', '-w', '--stdin'], text);
213 const tree = entries => out(bare, ['mktree'], [...entries].sort((a, b) => (a[2] < b[2] ? -1 : 1)).map(([mode, oid, name]) => `${mode} blob ${oid}\t${name}\n`).join(''));
214 const commit = (tr, parents, msg) => out(bare, ['commit-tree', tr, ...parents.flatMap(p => ['-p', p]), '-m', msg]);
215 const g = blob('g\n'), aB = blob('b\n'), aS = blob('s\n'), sideBlob = blob('side\n'), z = blob('z\n');
216 const R = commit(tree([['100644', g, 'g.txt']]), [], 'root');
217 const Z = commit(tree([['100644', z, 'z.txt']]), [], 'other');
218 const B = commit(tree([['100644', aB, 'a.txt'], ['100644', g, 'g.txt']]), [R], 'base');
219 const S = commit(tree([['100644', aS, 'a.txt'], ['100644', g, 'g.txt']]), [B], 'single');
220 const side = commit(tree([['100644', aB, 'a.txt'], ['100644', g, 'g.txt'], ['100644', sideBlob, 'b.txt']]), [B], 'side');
221 const merged = tree([['100644', aS, 'a.txt'], ['100644', g, 'g.txt'], ['100644', sideBlob, 'b.txt']]);
222 const M = commit(merged, [S, side], 'merge');
223 const Three = commit(merged, [S, side, B], 'three');
224 const byParents = [R, S, M, Three];
225 sh(bare, ['update-ref', 'refs/heads/main', B]);
226 const work = mkdtempSync(join(tmpdir(), 'ply-pick-'));
227 sh(work, ['clone', '-q', bare, '.']);
228 const url = `${srv.url}/picks.git`;
229 const who = { name: 'p', email: 'p@x' };
230 const limits = withLimits({ requestTimeoutMs: 15_000 });
231 const tipFor = (n, op) => (n === 0 && op === 'cherry' ? Z : n === 1 && op === 'revert' ? S : B);
232 let cells = 0;
233 try {
234 for (const n of [0, 1, 2, 3]) for (const op of ['cherry', 'revert']) {
235 const commitOid = byParents[n];
236 const tip = tipFor(n, op);
237 sh(bare, ['update-ref', 'refs/heads/main', tip]);
238 sh(work, ['checkout', '-qf', tip]);
239 const gitArgs = op === 'cherry' ? ['cherry-pick', commitOid] : ['revert', '--no-edit', commitOid];
240 const gRes = spawnSync('git', ['-C', work, ...gitArgs], { encoding: 'utf8', env: ENV });
241 let ply = null, err = null;
242 try {
243 const spec = { ref: 'refs/heads/main', commit: commitOid, committer: who, time: 1700000000 };
244 ply = op === 'cherry'
245 ? await unwrapAsync(cherryPick(url, spec, { tracer: new Tracer(), limits, rediff }))
246 : await unwrapAsync(revertCommit(url, spec, { tracer: new Tracer(), limits, rediff }));
247 } catch (e) { err = e; }
248 const where = `${op} parents=${n}`;
249 const head = out(bare, ['rev-parse', 'refs/heads/main']);
250 if (n >= 2) {
251 assert.equal(gRes.status, 128, `${where}: ${gRes.stderr}`);
252 assert.match(gRes.stderr, /is a merge but no -m option was given/u, where);
253 assert.equal(err?.code, 'not_linear', `${where}: ${err?.message}`);
254 assert.match(err.message, new RegExp(`${commitOid} has ${n} parents`), where);
255 assert.equal(head, tip, where);
256 } else {
257 assert.equal(gRes.status, 0, `${where}: ${gRes.stderr}`);
258 assert.equal(err, null, `${where}: ${err?.code} ${err?.message}`);
259 assert.equal(ply.outcome, 'ok', where);
260 assert.equal(ply.tree, out(work, ['rev-parse', 'HEAD^{tree}']), where);
261 assert.equal(head, ply.oid, where);
262 assert.deepEqual(fsckProblems(bare), [], where);
263 }
264 cells++;
265 }
266 } finally { rmSync(work, { recursive: true, force: true }); }
267 assert.equal(cells, 8);
268});
Diagnostics4 git calls · 28 ms
CallStatusSizeTime028 ms
discover200152 B2 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch 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 · 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=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 · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=23 git.response.bytes=38434 git.response.cache=HIT git.response.duration_ms=3 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=55Open pack map
fetch2007.3 KiB · hit23 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=7439 git.response.cache=HIT git.response.duration_ms=23 git.fetch.wants=b94cf62d906a302284382da06f7a3fa478b20289 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=7439 git.pkt.payload.max=7418 git.sideband.band1.bytes=7417 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
- a5e2f1765d96fda9
- Request
- cb5fbd4b…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format