main
1// The differential evaluator (pure): classify each client's answer the same way, compare the runs of a scenario field
2// by field, apply the allow-list, and classify what is left by triangulation (t229u): a difference between ply against
3// the server and ply against the reference is a server bug only when ply meets the reference expectation and stock git
4// against the server reproduces it. Exported as `ply/probes` beside the plans (probe-scenarios.ts); stock git's own
5// answers are parsed in test/probes/git-outcome.ts, which only the in-repository runner needs.
6import { at, readKey } from './absent.js';
7import { assertNever, none } from './result.js';
8import type { Option } from './result.js';
9import { ABSENT, TARGETS, clientOf } from './probe-types.js';
10import type { Allow, Client, Difference, EndState, ErrorClass, Expectation, Field, FinalRef, Finding, OidExpr, FindingClass, Observation, Outcome, Pair, Push, Scenario, Step, StepExpect, StepObservation, Target } from './probe-types.js';
12// ---- one answer, one class ----
13export type Classified = { readonly outcome: Outcome; readonly error: ErrorClass; readonly detail: string };
15const DETAIL_MAX = 300;
16// ply: the Result of an operation. `code` is the PlyError code when it failed.
17export function plyOutcome(r: { readonly ok: true } | { readonly ok: false; readonly code: string; readonly message: string }): Classified {
18 if (r.ok) return { outcome: 'landed', error: null, detail: 'ok' };
19 const detail = r.message.slice(0, DETAIL_MAX);
20 switch (r.code) {
21 case 'push_partial': return { outcome: 'partial', error: r.code, detail };
22 case 'ambiguous': return { outcome: 'ambiguous', error: r.code, detail };
23 case 'cas_conflict': return { outcome: 'conflict', error: r.code, detail };
24 default: return { outcome: 'rejected', error: r.code, detail };
25 }
26}
28// ---- rendering: each compared field as one deterministic string ----
29const sortedJson = (o: Readonly<Record<string, string>>): string => JSON.stringify(Object.fromEntries(Object.entries(o).toSorted(([a], [b]) => a.localeCompare(b))));
30const renderStep = (s: StepObservation, f: 'outcome' | 'error'): string => {
31 const vals = s.outcomes.map(x => (f === 'outcome' ? x.outcome : String(x.error)));
32 return s.outcomes.length === 1 ? vals.join('') : vals.toSorted().join(',');
33};
34export const renderSteps = (obs: Observation, f: 'outcome' | 'error'): string => obs.steps.map((s, i) => `s${i}=${renderStep(s, f)}`).join(';');
36// Object ids shown by seed name where the seed made them (the same on every target), so a difference reads as
37// "main: diverged vs ff" and a race winner can be named.
38export type Names = Readonly<Record<string, string>>; // oid -> name
39const lookup = (table: Readonly<Record<string, string>>, key: string): Option<string> => readKey(table, key);
40const named = (names: Names, oid: string): string => {
41 const n = lookup(names, oid);
42 return n.tag === 'some' ? n.value : oid;
43};
44const byNameOf = (names: Names): Readonly<Record<string, string>> => Object.fromEntries(Object.entries(names).map(([oid, n]) => [n, oid]));
45const refOf = (end: EndState, ref: string): Option<string> => lookup(end.refs, ref);
47type EndField = Exclude<Field, 'outcome' | 'error' | 'expectation' | 'claims'>;
48function renderEnd(s: Scenario, names: Names, end: EndState, field: EndField): string | null {
49 const winners = new Set(s.final.flatMap(f => (f.tag === 'one-of' ? f.names : [])));
50 const refName = (oid: string): string => (s.compare.tag === 'winner-of' && winners.has(named(names, oid)) ? '<winner>' : named(names, oid));
51 if (s.compare.tag === 'winner-of' && (field === 'objects' || field === 'trees' || field === 'ancestry' || field === 'merge-bases')) return null;
52 switch (field) {
53 case 'head': return String(end.head);
54 case 'refs': {
55 const shown: Record<string, string> = Object.fromEntries(Object.entries(end.refs).map(([r, oid]) => [r, refName(oid)]));
56 // a winner that deleted the ref is still the winner
57 if (s.compare.tag === 'winner-of') for (const f of s.final) if (f.tag === 'one-of' && f.names.includes(ABSENT) && !Object.hasOwn(shown, f.ref)) shown[f.ref] = '<winner>';
58 return sortedJson(shown);
59 }
60 case 'objects': return `${end.objects.length}:${end.objects.join(',')}`;
61 case 'trees': return sortedJson(end.trees);
62 case 'ancestry': return end.ancestry.join('|');
63 case 'merge-bases': return sortedJson(end.mergeBases);
64 case 'fsck': return end.fsck.length === 0 ? 'clean' : end.fsck.join('|');
65 }
66 return assertNever(field);
67}
68const END_FIELDS = ['head', 'refs', 'objects', 'trees', 'ancestry', 'merge-bases', 'fsck'] as const;
70// ---- expectation: a run against what the scenario says git http-backend does ----
71const oneOf = (x: StepExpect): string => `${x.outcome}/${String(x.error)}`;
72// Every answer that meets the step, rendered; null when the client is not run on it.
73function expectedOf(e: Expectation, c: Client): readonly string[] | null {
74 switch (e.tag) {
75 case 'one': {
76 const x = c === 'ply' ? e.ply : e.git;
77 return x === null ? null : [oneOf(x)];
78 }
79 case 'either': {
80 const xs = c === 'ply' ? e.ply : e.git;
81 return xs === null ? null : xs.map(x => oneOf(x));
82 }
83 case 'many': {
84 const xs = c === 'ply' ? e.ply : e.git;
85 return xs === null ? null : [xs.toSorted().join(',')];
86 }
87 }
88 return assertNever(e);
89}
90const observedOf = (e: Expectation, s: StepObservation): string => (e.tag === 'many' ? s.outcomes.map(x => x.outcome).toSorted().join(',') : oneOf(s.outcomes[0]));
92// The stated end refs against the refs a judge read.
93const absentName = (f: FinalRef): string => (f.tag === 'one-of' ? ABSENT : 'absent');
94function finalHolds(f: FinalRef, got: Option<string>, gotName: string, byName: Readonly<Record<string, string>>): boolean {
95 switch (f.tag) {
96 case 'absent': return got.tag === 'none';
97 case 'at': {
98 const want = lookup(byName, f.at);
99 return got.tag === 'some' && want.tag === 'some' && got.value === want.value;
100 }
101 case 'one-of': return f.names.includes(gotName);
102 }
103 return assertNever(f);
104}
105function finalShown(f: FinalRef): string {
106 switch (f.tag) {
107 case 'absent': return 'absent';
108 case 'at': return f.at;
109 case 'one-of': return f.names.join('|');
110 }
111 return assertNever(f);
112}
113function finalDiffs(s: Scenario, pair: Pair, obs: Observation, names: Names): Difference[] {
114 const byName = byNameOf(names);
115 const out: Difference[] = [];
116 for (const f of s.final) {
117 const got = refOf(obs.end, f.ref);
118 const gotName = got.tag === 'some' ? named(names, got.value) : absentName(f);
119 if (!finalHolds(f, got, gotName, byName)) out.push({ scenario: s.id, pair, field: 'expectation', left: `${f.ref}=${gotName}`, right: `${f.ref}=${finalShown(f)}` });
120 }
121 return out;
122}
124export function expectationDiffs(s: Scenario, target: 'ref-ply' | 'ref-git', obs: Observation, names: Names): Difference[] {
125 const c: Client = target === 'ref-ply' ? 'ply' : 'git';
126 const pair: Pair = target === 'ref-ply' ? 'ref-ply~expect' : 'ref-git~expect';
127 const out: Difference[] = [];
128 for (const [i, e] of s.expect.entries()) {
129 const want = expectedOf(e, c);
130 const step = at(obs.steps, i);
131 if (want === null || step.tag === 'none') continue;
132 const got = observedOf(e, step.value);
133 if (!want.includes(got)) out.push({ scenario: s.id, pair, field: 'expectation', left: `s${i}=${got}`, right: `s${i}=${want.join('|')}` });
134 }
135 out.push(...finalDiffs(s, pair, obs, names));
136 if (obs.end.fsck.length > 0) out.push({ scenario: s.id, pair, field: 'fsck', left: obs.end.fsck.join('|'), right: 'clean' });
137 return out;
138}
140// ---- claims: a landed answer must be true ----
141const CLAIMS_PAIR: Readonly<Record<Target, Pair>> = { 'ref-ply': 'ref-ply~claims', 'ref-git': 'ref-git~claims', 'art-ply': 'art-ply~claims', 'art-git': 'art-git~claims' };
142// The pushes a step sends, in the order its outcomes are recorded.
143export function pushesOf(s: Scenario, st: Step): readonly Push[] {
144 switch (st.tag) {
145 case 'push': return [st.push];
146 case 'concurrent': return st.pushes;
147 case 'fetch': return [];
148 case 'retry-unlanded': {
149 const of = at(s.steps, st.of);
150 return of.tag === 'none' || of.value.tag === 'retry-unlanded' ? [] : pushesOf(s, of.value);
151 }
152 }
153 return assertNever(st);
154}
155// A push's new id as the seed made it (none for a delete), and how a claim's two sides are shown.
156const wantOf = (e: OidExpr, byName: Readonly<Record<string, string>>): Option<string> => (e.tag === 'zero' ? none : lookup(byName, e.name));
157const oidName = (e: OidExpr): string => (e.tag === 'zero' ? 'absent' : e.name);
158const sameOid = (want: Option<string>, got: Option<string>): boolean => (got.tag === 'none' ? want.tag === 'none' : want.tag === 'some' && want.value === got.value);
159const shownOid = (names: Names, got: Option<string>): string => (got.tag === 'none' ? 'absent' : named(names, got.value));
160// A step one client has no form of is recorded as skipped and judged by nobody.
161export const skippedFor = (st: Step, c: Client): boolean => (c === 'git' ? st.git.tag === 'none' : st.tag === 'push' && st.ply.tag === 'none');
162export function claimDiffs(s: Scenario, target: Target, obs: Observation, names: Names): Difference[] {
163 const last = s.steps.length - 1;
164 const seen = at(obs.steps, last);
165 const step = at(s.steps, last);
166 if (step.tag === 'none' || seen.tag === 'none' || skippedFor(step.value, clientOf(target))) return [];
167 const pushes = pushesOf(s, step.value);
168 const byName = byNameOf(names);
169 const out: Difference[] = [];
170 for (const [i, o] of seen.value.outcomes.entries()) {
171 const p = at(pushes, i);
172 if (o.outcome !== 'landed' || p.tag === 'none') continue;
173 for (const u of p.value.updates) {
174 const got = refOf(obs.end, u.ref);
175 if (!sameOid(wantOf(u.new, byName), got)) out.push({ scenario: s.id, pair: CLAIMS_PAIR[target], field: 'claims', left: `push ${i} landed: ${u.ref}=${shownOid(names, got)}`, right: `${u.ref}=${oidName(u.new)}` });
176 }
177 }
178 return out;
179}
181// ---- the differential: every evaluable pair, field by field ----
182type SidePair = Exclude<Pair, `${string}~expect` | `${string}~claims`>;
183const PAIR_SIDES: Readonly<Record<SidePair, readonly [Target, Target, 'all' | 'end']>> = {
184 'art-ply~ref-ply': ['art-ply', 'ref-ply', 'all'],
185 'art-git~ref-git': ['art-git', 'ref-git', 'all'],
186 'ref-ply~ref-git': ['ref-ply', 'ref-git', 'end'],
187 'art-ply~art-git': ['art-ply', 'art-git', 'end'],
188};
189const SIDE_PAIRS: readonly SidePair[] = ['art-ply~ref-ply', 'art-git~ref-git', 'ref-ply~ref-git', 'art-ply~art-git'];
190export type Runs = Partial<Readonly<Record<Target, Observation>>>;
191const runOf = (runs: Runs, t: Target): Option<Observation> => readKey(runs, t);
193export function evaluablePairs(runs: Runs): Pair[] {
194 const pairs: Pair[] = [];
195 for (const p of SIDE_PAIRS) {
196 const [l, r] = PAIR_SIDES[p];
197 if (runOf(runs, l).tag === 'some' && runOf(runs, r).tag === 'some') pairs.push(p);
198 }
199 if (runOf(runs, 'ref-ply').tag === 'some') pairs.push('ref-ply~expect');
200 if (runOf(runs, 'ref-git').tag === 'some') pairs.push('ref-git~expect');
201 for (const t of TARGETS) if (runOf(runs, t).tag === 'some') pairs.push(CLAIMS_PAIR[t]);
202 return pairs;
203}
205export function compareScenario(s: Scenario, runs: Runs, names: Names): Difference[] {
206 const out: Difference[] = [];
207 for (const p of SIDE_PAIRS) {
208 const [l, r, scope] = PAIR_SIDES[p];
209 const a = runOf(runs, l);
210 const b = runOf(runs, r);
211 if (a.tag === 'none' || b.tag === 'none') continue;
212 if (scope === 'all') for (const f of ['outcome', 'error'] as const) {
213 const la = renderSteps(a.value, f), rb = renderSteps(b.value, f);
214 if (la !== rb) out.push({ scenario: s.id, pair: p, field: f, left: la, right: rb });
215 }
216 for (const f of END_FIELDS) {
217 const la = renderEnd(s, names, a.value.end, f), rb = renderEnd(s, names, b.value.end, f);
218 if (la !== null && rb !== null && la !== rb) out.push({ scenario: s.id, pair: p, field: f, left: la, right: rb });
219 }
220 }
221 const rg = runOf(runs, 'ref-git');
222 const rp = runOf(runs, 'ref-ply');
223 if (rp.tag === 'some') out.push(...expectationDiffs(s, 'ref-ply', rp.value, names));
224 if (rg.tag === 'some') out.push(...expectationDiffs(s, 'ref-git', rg.value, names));
225 for (const t of TARGETS) {
226 const r = runOf(runs, t);
227 if (r.tag === 'some') out.push(...claimDiffs(s, t, r.value, names));
228 }
229 return out;
230}
232// ---- one corner: ply alone against the server (ply-web's workbench) ----
233// ply's run against the server, compared with the scenario's stated ply expectation instead of a ref-ply run: ref-ply
234// meets that expectation at every commit (test/probes/probes.test.js), so for a scenario whose steps each state one
235// outcome a solo difference reads exactly as the art-ply~ref-ply difference a full run records, and the allow-list's
236// art-ply~ref-ply entries apply to it unchanged. A concurrent step's errors are not stated, so not compared. A judge in
237// a Worker has no fsck, so fsck is not compared; the end refs and every landed claim are.
238// A concurrent step states only its outcomes (sorted), so its errors are not compared here.
239// ply's stated answers for one field of a step: one for `one` and `many`, each listed one for `either`.
240function expectRenders(e: Expectation, f: 'outcome' | 'error'): readonly string[] {
241 switch (e.tag) {
242 case 'many': return [e.ply.toSorted().join(',')];
243 case 'one': return [f === 'outcome' ? e.ply.outcome : String(e.ply.error)];
244 case 'either': return [...new Set(e.ply.map(x => (f === 'outcome' ? x.outcome : String(x.error))))];
245 }
246 return assertNever(e);
247}
248const eitherMet = (e: Extract<Expectation, { readonly tag: 'either' }>, seen: Option<StepObservation>): boolean =>
249 seen.tag === 'some' && e.ply.some(p => oneOf(p) === oneOf(seen.value.outcomes[0]));
250export function soloDiffs(s: Scenario, obs: Observation, names: Names): Difference[] {
251 const out: Difference[] = [];
252 for (const f of ['outcome', 'error'] as const) {
253 // a concurrent step's errors are not stated, only its outcomes
254 const steps = s.expect.map((e, i) => ({ e, i, seen: at(obs.steps, i) })).filter(x => f === 'outcome' || x.e.tag !== 'many');
255 const seenOf = (x: (typeof steps)[number]): string => (x.seen.tag === 'some' ? renderStep(x.seen.value, f) : '(not run)');
256 // an `either` step meets its field when the outcome and error seen are one listed pair, not each from a different one
257 const meets = (x: (typeof steps)[number]): boolean => (x.e.tag === 'either' ? eitherMet(x.e, x.seen) : expectRenders(x.e, f).includes(seenOf(x)));
258 const left = steps.map(x => `s${x.i}=${seenOf(x)}`).join(';');
259 const right = steps.map(x => `s${x.i}=${expectRenders(x.e, f).join('|')}`).join(';');
260 if (!steps.every(x => meets(x))) out.push({ scenario: s.id, pair: 'art-ply~expect', field: f, left, right });
261 }
262 out.push(...finalDiffs(s, 'art-ply~expect', obs, names), ...claimDiffs(s, 'art-ply', obs, names));
263 return out;
264}
266// ---- allow-list, then triangulation ----
267// An art-ply~ref-ply entry covers the same difference on art-ply~expect (ref-ply meets the expectation; see soloDiffs).
268const matches = (a: Allow, d: Difference): boolean => a.scenario === d.scenario && (a.pair === d.pair || (a.pair === 'art-ply~ref-ply' && d.pair === 'art-ply~expect')) && a.field === d.field && a.left === d.left && a.right === d.right;
269export const allowFor = (allow: readonly Allow[], d: Difference): Option<Allow> => at(allow.filter(a => matches(a, d)), 0);
271export type Verdict = {
272 readonly expected: ReadonlyArray<{ readonly difference: Difference; readonly reason: string }>;
273 readonly findings: readonly Finding[];
274 // entries whose scenario and pair were evaluated in this run, and that matched nothing: the run fails on any
275 readonly unused: readonly Allow[];
276};
278const has = (ds: readonly Difference[], s: string, p: Pair, f: Field | null): boolean => ds.some(d => d.scenario === s && d.pair === p && (f === null || d.field === f));
279const noGitForm = (s: Scenario): boolean => s.steps.some(st => st.git.tag === 'none');
280// a scenario one client cannot run at all: its targets are not run, so no pair with them is evaluated
281export const runsFor = (s: Scenario, c: Client): boolean => !s.steps.every(st => skippedFor(st, c));
283type Why = { readonly class: FindingClass; readonly why: string };
284const why = (c: FindingClass, text: string): Why => ({ class: c, why: text });
286// The server pairs: ply or stock git against the server, read against its reference run or the expectation.
287function classifyServer(s: Scenario, d: Difference & { readonly pair: 'art-ply~ref-ply' | 'art-ply~expect' | 'art-git~ref-git' | 'art-ply~art-git' }, all: readonly Difference[]): Why {
288 const plyRefWrong = has(all, s.id, 'ref-ply~expect', null);
289 switch (d.pair) {
290 case 'art-ply~ref-ply':
291 if (plyRefWrong) return why('unresolved', 'ply misses the reference expectation, so a difference on the server cannot be attributed');
292 if (noGitForm(s)) return why('unresolved', 'ply is right on the reference; this scenario has no native-git form to reproduce it with');
293 if (has(all, s.id, 'art-git~ref-git', d.field)) return why('server-bug', 'ply is right on the reference and stock git reproduces the difference on the server');
294 return why('unresolved', 'ply is right on the reference but stock git does not reproduce it on the server: a behaviour only ply\'s bytes reach, or ply\'s handling of this server\'s answer');
295 case 'art-ply~expect':
296 return why('unresolved', 'ply alone against the server: ply meets this expectation against git http-backend at this commit, so the server answered differently or ply read its answer differently; stock git and the reference did not run, so export the scenario and run it with test/probes to close the triangle');
297 case 'art-git~ref-git':
298 return has(all, s.id, 'ref-git~expect', null) ? why('unresolved', 'stock git misses the reference expectation') : why('server-bug', 'the same stock git client answers differently against the server than against git http-backend');
299 case 'art-ply~art-git':
300 if (has(all, s.id, 'art-ply~ref-ply', d.field) || has(all, s.id, 'art-git~ref-git', d.field)) return why('unresolved', 'follows from a same-client difference listed separately');
301 return why('unresolved', 'ply and stock git leave different repositories on the server while each matches its reference run');
302 }
303 return assertNever(d.pair);
304}
306export function classify(s: Scenario, d: Difference, all: readonly Difference[]): Why {
307 const gitRefWrong = has(all, s.id, 'ref-git~expect', null);
308 switch (d.pair) {
309 case 'ref-ply~expect':
310 return gitRefWrong ? why('unresolved', 'stock git misses the expectation on the reference too: the expectation or the harness is wrong') : why('client-bug', 'ply misses the reference expectation that stock git meets');
311 case 'ref-git~expect':
312 return why('unresolved', 'stock git against git http-backend misses the stated expectation: fix the scenario or the reference policy');
313 case 'ref-ply~ref-git':
314 return has(all, s.id, 'ref-ply~expect', null) ? why('client-bug', 'ply leaves a different repository than stock git on the reference and misses its expectation') : why('unresolved', 'ply and stock git leave different repositories on the reference; the expectation does not decide which is right');
315 case 'art-ply~ref-ply':
316 case 'art-ply~expect':
317 case 'art-git~ref-git':
318 case 'art-ply~art-git':
319 return classifyServer(s, { ...d, pair: d.pair }, all);
320 case 'ref-ply~claims':
321 return why('client-bug', 'ply said landed against git http-backend and the refs do not show it');
322 case 'ref-git~claims':
323 return why('unresolved', 'stock git said landed against git http-backend and the refs do not show it: the harness is wrong');
324 case 'art-ply~claims':
325 return has(all, s.id, 'art-git~claims', null) ? why('server-bug', 'the server told both clients a push landed that the refs do not show') : why('unresolved', 'ply said landed and the refs do not show it; stock git was not told the same');
326 case 'art-git~claims':
327 return why('server-bug', 'the server told stock git a push landed that the refs do not show');
328 }
329 return assertNever(d.pair);
330}
332export function judge(scenarios: readonly Scenario[], diffs: readonly Difference[], allow: readonly Allow[], evaluated: ReadonlyArray<{ readonly scenario: string; readonly pairs: readonly Pair[] }>): Verdict {
333 const used = new Set<Allow>();
334 const expected: Array<{ difference: Difference; reason: string }> = [];
335 const findings: Finding[] = [];
336 for (const d of diffs) {
337 const a = allowFor(allow, d);
338 if (a.tag === 'some') { used.add(a.value); expected.push({ difference: d, reason: a.value.reason }); continue; }
339 const s = at(scenarios.filter(x => x.id === d.scenario), 0);
340 if (s.tag === 'none') continue;
341 findings.push({ ...d, ...classify(s.value, d, diffs) });
342 }
343 const ran = (a: Allow): boolean => evaluated.some(e => e.scenario === a.scenario && e.pairs.includes(a.pair));
344 return { expected, findings, unused: allow.filter(a => ran(a) && !used.has(a)) };
345}
Diagnostics4 git calls · 365 ms
CallStatusSizeTime0365 ms
discover200152 B4 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=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 · hit3 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=145 git.response.cache=HIT git.response.duration_ms=3 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=359 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=55Open pack map
fetch2006.0 KiB359 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=6193 git.response.cache=MISS git.response.duration_ms=359 git.fetch.wants=1e16cd04e9e71241e441109b30f36b4bda5ef2d6 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=6193 git.pkt.payload.max=6172 git.sideband.band1.bytes=6171 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
- a5e2aaaffdebe6b0
- Request
- 42bec783…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format