Artifactspublic-v0

ply

main
ply4 git calls25 ms44 KiB3 cachedprotocol v2
390 lines19 KiBRaw
1// ply-memlab: a scratch Worker that runs ply's streaming paths inside real isolate limits (128 MB memory, the CPU limit
2// in worker.config). It is a measurement rig, not product code: bench/worker-mem/README.md says how to run it.
3//
4// Every route needs `Authorization: Bearer <MEMLAB_TOKEN>`. Read access to the seed repo comes from the Artifacts
5// binding (namespace ply-loadgen): each request mints its own short-lived read token and revokes it when done.
6//
7// Responses are NDJSON: progress lines while a cell runs (so the client sees bytes long before the end), then one
8// `{"final":true,...}` line. Each request also logs one `memlab` line, which joins the cell to its Workers Observability
9// invocation (CPU, wall, outcome) by request id.
10import * as ply from '../../dist/index.js';
12const MIB = 1024 * 1024;
13const GIB = 1024 * MIB;
14const READ_TOKEN_TTL_S = 900;
15const PROGRESS_EVERY_BYTES = 64 * MIB;
16// The transport counts every band-1 byte against maxPackBytes. The seed pack is ~1 GiB, so the transport cap is raised
17// here and only here; the scan's own budget (WORK_BUDGET) is what bounds inflate work. Time is bounded by ply's
18// default stall limits (#258): firstByteTimeoutMs and idleTimeoutMs, 60 s each, cut an exchange that stops making
19// progress, while a long one that keeps streaming (the ~55 s scan of the ~1 GiB pack, run ml-20261110t034240z) runs
20// on. No whole-exchange requestTimeoutMs: a cap sized to the pack would only hide a stall behind a longer wait.
21const TRANSPORT_LIMITS = ply.withLimits({ maxPackBytes: 8 * GIB });
23const enc = new TextEncoder();
25async function authorized(req, env) {
26 const got = req.headers.get('authorization') ?? '';
27 const want = `Bearer ${env.MEMLAB_TOKEN ?? ''}`;
28 if (!env.MEMLAB_TOKEN) return false;
29 const a = enc.encode(got);
30 const b = enc.encode(want);
31 if (a.length !== b.length) return false;
32 return crypto.subtle.timingSafeEqual(a, b);
35// A read token for one repo, minted through the binding and revoked by the returned function.
36async function readToken(env, repo, scope = 'read') {
37 const handle = await env.REPOS.get(repo);
38 const minted = await handle.createToken(scope, READ_TOKEN_TTL_S);
39 // 'revoked', or why not: expiry (READ_TOKEN_TTL_S) is the backstop either way.
40 const revoke = async () => {
41 try {
42 if (!minted.id) return 'no-id';
43 if (typeof handle.revokeToken !== 'function') return 'no-revokeToken';
44 await handle.revokeToken(minted.id);
45 return 'revoked';
46 } catch (e) { return `revoke-failed: ${String(e?.message ?? e).slice(0, 120)}`; }
47 };
48 return { token: minted.plaintext, revoke };
51function client(remote, token, limits = TRANSPORT_LIMITS) {
52 const gh = ply.GitHttp.create(remote, { auth: { token, user: 'x' }, limits });
53 if (!gh.ok) throw new Error(`transport: ${gh.error.code} ${gh.error.message}`);
54 return gh.value;
57const scanLimits = name => (name === 'worker' ? ply.WORKER_LIMITS : ply.DEFAULT_LIMITS);
59// Drives one pack scan over an async source of byte chunks. Returns counts; a refusal is returned, not thrown.
60async function scanSource(source, opts, progress) {
61 const init = ply.parsePackInit(opts);
62 if (!init.ok) return { ok: false, error: { code: init.error.code, message: init.error.message } };
63 const scan = init.value;
64 const out = { objects: 0, deltas: 0, types: {}, packBytes: 0, inflated: 0, trailer: null, maxChunk: 0 };
65 let nextProgress = PROGRESS_EVERY_BYTES;
66 const drain = () => {
67 for (;;) {
68 const p = ply.parsePackPull(scan);
69 if (!p.ok) return { error: p.error };
70 const piece = p.value;
71 switch (piece.kind) {
72 case 'need': return { need: true };
73 case 'header': out.count = piece.count; break;
74 case 'object':
75 out.objects++;
76 out.types[piece.type] = (out.types[piece.type] ?? 0) + 1;
77 if (piece.base.tag !== 'none') out.deltas++;
78 break;
79 case 'chunk':
80 out.inflated += piece.bytes.length;
81 if (piece.bytes.length > out.maxChunk) out.maxChunk = piece.bytes.length;
82 break;
83 case 'object-end': break;
84 case 'trailer': out.trailer = piece.trailer; break;
85 case 'end': return { end: true };
86 default: break;
87 }
88 }
89 };
90 for await (const chunk of source) {
91 out.packBytes += chunk.length;
92 ply.parsePackFeed(scan, chunk);
93 const r = drain();
94 if (r.error) return { ok: false, error: { code: r.error.code, message: r.error.message, what: r.error.what ?? null }, ...out };
95 if (r.end) return { ok: true, ...out };
96 if (out.packBytes >= nextProgress) {
97 nextProgress += PROGRESS_EVERY_BYTES;
98 await progress({ packBytes: out.packBytes, objects: out.objects, inflated: out.inflated });
99 }
100 }
101 ply.parsePackClose(scan);
102 const r = drain();
103 if (r.error) return { ok: false, error: { code: r.error.code, message: r.error.message, what: r.error.what ?? null }, ...out };
104 return { ok: Boolean(r.end), ...out, ...(r.end ? {} : { error: { code: 'harness', message: 'pack ended without end piece' } }) };
107// Cell 1: fetch the whole seed history as one pack and scan it with the work budget, holding nothing.
108async function cellScan(q, env, progress) {
109 const { token, revoke } = await readToken(env, q.repo);
110 try {
111 const gh = client(q.remote, token);
112 const span = gh.tracer.start('memlab.scan');
113 const t0 = Date.now();
114 const source = gh.packStream({ wants: [q.commit] }, span);
115 const r = await scanSource(source, ply.packScanOpts(scanLimits(q.limits), true, ply.WORK_BUDGET), progress);
116 span.end();
117 return { ...r, wallMs: Date.now() - t0, limits: q.limits ?? 'default', budget: 'WORK_BUDGET' };
118 } finally { tokenState.last = await revoke(); }
121// Cell 2: one large blob through ply's read path (openBlob: fetch, inflate, verify), streamed and counted, not held.
122async function cellRead(q, env) {
123 const { token, revoke } = await readToken(env, q.repo);
124 try {
125 const gh = client(q.remote, token, ply.DEFAULT_LIMITS);
126 const t0 = Date.now();
127 const opened = await ply.openBlob(gh.t, q.blob);
128 if (!opened.ok) return { ok: false, error: { code: opened.error.code, message: opened.error.message }, wallMs: Date.now() - t0 };
129 const reader = opened.value.stream.getReader();
130 let bytes = 0;
131 let maxChunk = 0;
132 for (;;) {
133 const { done, value } = await reader.read();
134 if (done) break;
135 bytes += value.length;
136 if (value.length > maxChunk) maxChunk = value.length;
137 }
138 return { ok: bytes === opened.value.size, size: opened.value.size, bytes, maxChunk, wallMs: Date.now() - t0 };
139 } finally { tokenState.last = await revoke(); }
142// A one-object pack whose blob inflates to `declared` zero bytes. Built once per isolate (CompressionStream is native).
143let bombCache = null;
144async function bombPack(declared) {
145 if (bombCache && bombCache.declared === declared) return { ...bombCache, cached: true };
146 const t0 = Date.now();
147 const cs = new CompressionStream('deflate');
148 const writer = cs.writable.getWriter();
149 const zeros = new Uint8Array(MIB);
150 const pump = (async () => {
151 for (let left = declared; left > 0; left -= MIB) await writer.write(left >= MIB ? zeros : zeros.subarray(0, left));
152 await writer.close();
153 })();
154 const parts = [];
155 for await (const c of cs.readable) parts.push(c);
156 await pump;
157 const z = ply.concat(parts);
158 const head = ply.encodeObjHeader(3, declared);
159 const body = ply.concat([enc.encode('PACK'), new Uint8Array([0, 0, 0, 2, 0, 0, 0, 1]), head, z]);
160 const sha = new Uint8Array(await crypto.subtle.digest('SHA-1', body));
161 bombCache = { declared, pack: ply.concat([body, sha]), zlibBytes: z.length, genMs: Date.now() - t0 };
162 return { ...bombCache, cached: false };
165// Cell 3: the bomb must be refused before inflate work runs past the budget.
166async function cellBomb(q, _env, progress) {
167 const declared = Number(q.declared ?? GIB);
168 const bomb = await bombPack(declared);
169 const feed = async function* () {
170 const step = 64 * 1024;
171 for (let i = 0; i < bomb.pack.length; i += step) yield bomb.pack.subarray(i, i + step);
172 };
173 const t0 = Date.now();
174 const r = await scanSource(feed(), ply.packScanOpts(scanLimits(q.limits), true, ply.WORK_BUDGET), progress);
175 return { ...r, refused: !r.ok, declared, packLen: bomb.pack.length, zlibBytes: bomb.zlibBytes, genMs: bomb.genMs, genCached: bomb.cached, scanMs: Date.now() - t0, limits: q.limits ?? 'default' };
178// The last token's revoke outcome, reported on the cell's final line.
179const tokenState = { last: null, write: null };
180const pending = (name, why) => ({ ok: false, pending: true, cell: name, why });
182// Cell 4a: the streaming pack index (#236, scanPackIndex): the whole seed history from packStream, oids on (each whole
183// object hashed while streaming), work budget, verify on. Reports the index's own held column bytes and how many
184// entries' resolved type stayed unknown.
185async function cellIndex(q, env) {
186 const fn = ply.scanPackIndex;
187 if (typeof fn !== 'function') return pending('index', 'ply has no scanPackIndex export (#236)');
188 const { token, revoke } = await readToken(env, q.repo);
189 try {
190 const gh = client(q.remote, token);
191 const span = gh.tracer.start('memlab.index');
192 const t0 = Date.now();
193 const oids = q.oids !== 'off';
194 const r = await fn(gh.packStream({ wants: [q.commit] }, span), { oids, budget: ply.WORK_BUDGET, verify: true, limits: scanLimits(q.limits) });
195 span.end();
196 if (!r.ok) return { ok: false, error: { code: r.error.code, message: String(r.error.message).slice(0, 300) }, wallMs: Date.now() - t0 };
197 const v = r.value;
198 const types = {};
199 let unknown = 0;
200 for (let i = 0; i < v.count; i++) {
201 const t = v.columns.type[i];
202 if (t === 0) unknown++;
203 types[t] = (types[t] ?? 0) + 1;
204 }
205 return { ok: true, count: v.count, objects: v.count, packBytes: v.bytes, trailer: v.trailer, heldBytes: v.heldBytes, perEntryBytes: v.count ? v.heldBytes / v.count : null, resolvedTypes: types, unknownType: unknown, oids, wallMs: Date.now() - t0 };
206 } finally { tokenState.last = await revoke(); }
209// R2 spool (harness-side; ply stays storage-neutral). The pack is written once by the `spool` cell as a multipart
210// upload in fixed parts (R2 needs every part but the last the same size), then read back by range for resolvePackRange.
211const SPOOL_PART_BYTES = 16 * MIB;
212const spoolKey = q => `spool/${q.key}`;
214// A ply RangeSource over one R2 object: each read is one ranged get, streamed.
215function r2Range(bucket, key, size) {
216 return {
217 size,
218 read: async (offset, length) => {
219 if (!Number.isInteger(offset) || !Number.isInteger(length) || offset < 0 || length < 0 || offset + length > size) {
220 return { ok: false, error: ply.plyError('bad_request', `range ${offset}+${length} outside ${size} bytes`) };
221 }
222 if (length === 0) return { ok: true, value: new ReadableStream({ start(c) { c.close(); } }) };
223 const obj = await bucket.get(key, { range: { offset, length } });
224 if (!obj || !obj.body) return { ok: false, error: ply.plyError('not_found', `spool object ${key} is gone`) };
225 return { ok: true, value: obj.body };
226 },
227 };
230// Cell: spool the whole seed history into R2 (run once per key).
231async function cellSpool(q, env, progress) {
232 const { token, revoke } = await readToken(env, q.repo);
233 try {
234 const gh = client(q.remote, token);
235 const span = gh.tracer.start('memlab.spool');
236 const t0 = Date.now();
237 const up = await env.SPOOL.createMultipartUpload(spoolKey(q));
238 const parts = [];
239 let buf = new Uint8Array(SPOOL_PART_BYTES);
240 let fill = 0;
241 let total = 0;
242 const flush = async last => {
243 if (fill === 0 && !last) return;
244 parts.push(await up.uploadPart(parts.length + 1, fill === SPOOL_PART_BYTES ? buf : buf.slice(0, fill)));
245 buf = new Uint8Array(SPOOL_PART_BYTES);
246 fill = 0;
247 };
248 try {
249 for await (const chunk of gh.packStream({ wants: [q.commit] }, span)) {
250 let at = 0;
251 while (at < chunk.length) {
252 const n = Math.min(chunk.length - at, SPOOL_PART_BYTES - fill);
253 buf.set(chunk.subarray(at, at + n), fill);
254 fill += n; at += n; total += n;
255 if (fill === SPOOL_PART_BYTES) { await flush(false); if (parts.length % 8 === 0) await progress({ spooled: total }); }
256 }
257 }
258 if (fill > 0) await flush(true);
259 const done = await up.complete(parts);
260 span.end();
261 return { ok: done.size === total, key: spoolKey(q), size: done.size, packBytes: total, parts: parts.length, wallMs: Date.now() - t0 };
262 } catch (e) {
263 await up.abort().catch(() => {});
264 throw e;
265 }
266 } finally { tokenState.last = await revoke(); }
269// Cell: scanPackIndex over the spooled object, then resolvePackRange over R2 ranged reads. Every entry must end with a
270// type and an oid (unknowns 0). Held memory is the two indexes' columns plus the resolver's base cache bound.
271async function cellResolve(q, env) {
272 const head = await env.SPOOL.head(spoolKey(q));
273 if (!head) return { ok: false, error: { code: 'harness', message: `no spool object ${spoolKey(q)}` } };
274 const t0 = Date.now();
275 const obj = await env.SPOOL.get(spoolKey(q));
276 const idx = await ply.scanPackIndex(obj.body, { oids: true, budget: ply.WORK_BUDGET, verify: true, limits: ply.DEFAULT_LIMITS });
277 if (!idx.ok) return { ok: false, phase: 'index', error: { code: idx.error.code, message: String(idx.error.message).slice(0, 300) } };
278 const scanMs = Date.now() - t0;
279 let indexUnknown = 0;
280 for (let i = 0; i < idx.value.count; i++) if (idx.value.columns.type[i] === 0) indexUnknown++;
281 const cacheBytes = Number(q.cacheBytes ?? ply.RESOLVE_CACHE_BYTES);
282 const res = await ply.resolvePackRange(idx.value, r2Range(env.SPOOL, spoolKey(q), head.size), { cacheBytes, budget: ply.WORK_BUDGET, limits: ply.DEFAULT_LIMITS });
283 if (!res.ok) return { ok: false, phase: 'resolve', error: { code: res.error.code, message: String(res.error.message).slice(0, 300) }, indexUnknown };
284 const r = res.value;
285 let unknownType = 0;
286 let unknownOid = 0;
287 const types = {};
288 for (let i = 0; i < r.count; i++) {
289 const t = r.type(i);
290 if (t.tag !== 'some') unknownType++; else types[t.value] = (types[t.value] ?? 0) + 1;
291 if (r.oid(i).tag !== 'some') unknownOid++;
292 }
293 const headFound = q.commit ? r.find(q.commit).tag === 'some' : null;
294 return {
295 ok: unknownType === 0 && unknownOid === 0 && headFound !== false, count: r.count, packBytes: head.size, indexUnknown, unknownType, unknownOid, types, headFound,
296 indexHeldBytes: idx.value.heldBytes, resolvedHeldBytes: r.heldBytes, cacheBytes, heldBoundBytes: idx.value.heldBytes + r.heldBytes + cacheBytes,
297 stats: r.stats, scanMs, wallMs: Date.now() - t0,
298 };
301// Cell: delete a spooled object.
302async function cellSpoolDel(q, env) {
303 const had = await env.SPOOL.head(spoolKey(q));
304 await env.SPOOL.delete(spoolKey(q));
305 const after = await env.SPOOL.head(spoolKey(q));
306 return { ok: after === null, existed: Boolean(had), key: spoolKey(q) };
309// Cell 4b: pushPack (#234). Relays one seed commit to the destination repo as one streamed pack: the fetch asks for
310// `new` with `old` as a have (so the pack is that commit's new objects only, under the 64 MiB push cap), and its band-1
311// bytes go straight into pushPack's request body. Nothing is buffered past a chunk or two. ply's own cap is set just
312// under the host's, so an oversize pack is refused by ply while sending, not by the server.
313const PUSH_LIMITS = ply.withLimits({ maxPackBytes: 64 * MIB - 64 * 1024 });
314async function cellPushPack(q, env, progress) {
315 if (typeof ply.pushPack !== 'function') return pending('pushpack', 'ply has no pushPack export (#234)');
316 const src = await readToken(env, q.repo);
317 let dst = null;
318 try {
319 dst = await readToken(env, q.dst, 'write');
320 const from = client(q.remote, src.token);
321 const to = client(q.dstRemote, dst.token, PUSH_LIMITS);
322 const span = from.tracer.start('memlab.relay');
323 const old = q.old && q.old !== ply.ZERO_OID ? q.old : null;
324 const gen = from.packStream({ wants: [q.new], ...(old ? { haves: [old] } : {}), done: true }, span);
325 let packBytes = 0;
326 let nextProgress = PROGRESS_EVERY_BYTES / 4;
327 let maxChunk = 0;
328 const pack = new ReadableStream({
329 async pull(c) {
330 const n = await gen.next();
331 if (n.done) { c.close(); return; }
332 packBytes += n.value.length;
333 if (n.value.length > maxChunk) maxChunk = n.value.length;
334 if (packBytes >= nextProgress) { nextProgress += PROGRESS_EVERY_BYTES / 4; await progress({ packBytes }); }
335 c.enqueue(n.value);
336 },
337 async cancel(reason) { await gen.return?.(reason); },
338 });
339 const t0 = Date.now();
340 const r = await ply.pushPack(to.t, { commands: [{ ref: 'refs/heads/main', oldOid: old ?? ply.ZERO_OID, newOid: q.new }], pack });
341 span.end();
342 if (!r.ok) return { ok: false, error: { code: r.error.code, message: String(r.error.message).slice(0, 300), original: r.error.original?.code ?? null }, packBytes, maxChunk, wallMs: Date.now() - t0 };
343 const report = JSON.stringify(r.value.report);
344 const refOk = report.includes('refs/heads/main') && !/\bng\b/.test(report);
345 return { ok: refOk, packBytes, sentBytes: r.value.packBytes, maxChunk, wallMs: Date.now() - t0, report: report.slice(0, 300) };
346 } finally {
347 tokenState.last = await src.revoke();
348 if (dst) tokenState.write = await dst.revoke();
349 }
352const CELLS = { scan: cellScan, read: cellRead, bomb: cellBomb, index: cellIndex, pushpack: cellPushPack, spool: cellSpool, resolve: cellResolve, spooldel: cellSpoolDel };
354export default {
355 async fetch(req, env, ctx) {
356 const url = new URL(req.url);
357 const version = env.VERSION?.id ?? '';
358 // Build-time constants from build.mjs (esbuild define).
359 const build = { 'x-memlab-version': version, 'x-memlab-ply': __PLY_SHA__, 'x-memlab-cpu-limit-ms': String(__CPU_LIMIT_MS__) };
360 if (url.pathname === '/health') return new Response('ok', { headers: build });
361 if (!(await authorized(req, env))) return new Response('unauthorized', { status: 401 });
362 const m = /^\/cell\/([a-z]+)$/.exec(url.pathname);
363 const cell = m ? CELLS[m[1]] : undefined;
364 if (!cell) return new Response('no such cell', { status: 404 });
365 const q = Object.fromEntries(url.searchParams);
366 const { readable, writable } = new TransformStream();
367 const writer = writable.getWriter();
368 const line = obj => writer.write(enc.encode(`${JSON.stringify(obj)}\n`));
369 const run = (async () => {
370 const t0 = Date.now();
371 let result;
372 try {
373 tokenState.last = null;
374 tokenState.write = null;
375 result = await cell(q, env, p => line({ progress: true, ...p }));
376 if (tokenState.last) result = { ...result, readToken: tokenState.last };
377 if (tokenState.write) result = { ...result, writeToken: tokenState.write };
378 } catch (e) {
379 result = { ok: false, error: { code: e?.code ?? 'thrown', message: String(e?.message ?? e) } };
380 }
381 const label = q.label ?? m[1];
382 const final = { final: true, route: m[1], label, run: q.run ?? '', i: Number(q.i ?? -1), version, ply: build['x-memlab-ply'], cpuLimitMs: Number(build['x-memlab-cpu-limit-ms']), totalMs: Date.now() - t0, ...result };
383 console.log(JSON.stringify({ memlab: true, label, run: final.run, i: final.i, ok: final.ok, pending: Boolean(final.pending) }));
384 await line(final);
385 await writer.close();
386 })();
387 ctx.waitUntil(run);
388 return new Response(readable, { headers: { 'content-type': 'application/x-ndjson', 'x-memlab-version': version, 'cache-control': 'no-store' } });
389 },
390};
Diagnostics4 git calls · 25 ms
CallStatusSizeTime025 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=18
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.6 KiB · hit19 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=6720
git.response.cache=HIT
git.response.duration_ms=19
git.fetch.wants=4bf823a67683c5f8d575510a5d502addb427da89
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=6720
git.pkt.payload.max=6699
git.sideband.band1.bytes=6698
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
a5e3204849529de8
Request
34cd3029…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format