main
1// The CD rate limiter silent-degradation gate (scripts/cd/rate-gate.ts, docs/rate-limit.md "CD gate").
2import assert from 'node:assert/strict'
3import { readFileSync } from 'node:fs'
4import { test } from 'node:test'
5import { parsePolicy, DEFAULT_RATE_GATE, type RateGatePolicy } from '../scripts/cd/policy.ts'
6import { countRows, type CountRow } from '../scripts/cd/o11y.ts'
7import { countsFromRows, countsFromSpans, judgeRate, pollRate, queryRateRows, sendRateProbes, type RateCounts } from '../scripts/cd/rate-gate.ts'
8import type { Filter } from '../scripts/cd/telemetry.ts'
9import type { ExpectedCold } from '../src/rate/admit.ts'
10import { dig, recordGet } from '../src/absent.ts'
11import { unwrapOr } from '../src/option.ts'
13const POLICY_TEXT = readFileSync(new URL('../scripts/cd/cd.policy.json', import.meta.url), 'utf8')
14const POLICY: RateGatePolicy = parsePolicy(POLICY_TEXT).policy.rate
16/** Real ply.rate.check spans of 59926117 and e61a5742 (2026-11-06): asked for batched, silently ran legacy. */
17const SILENT = (JSON.parse(readFileSync(new URL('./fixtures/cd/rate-silent-legacy.json', import.meta.url), 'utf8')) as { events: unknown[] }).events
18const V59926117 = '59926117-40f5-4d84-aa12-89eac76736b2'
19const VE61A5742 = 'e61a5742-d17e-4adf-beda-0ed2e9e26272'
21const V = 'aaaaaaaa-0000-4000-8000-000000000001'
23type Check = Partial<{ mode: string; decision: string; source: 'default' | 'header'; cold: ExpectedCold; dropped: string }>
25function check(c: Check, version = V): unknown {
26 const field = (key: keyof Check, fallback: string): string => {
27 const got = recordGet(c, key)
28 return got.tag === 'some' ? String(got.value) : fallback
29 }
30 const rate: Record<string, unknown> = { mode: field('mode', 'memo'), decision: field('decision', 'allow'), mode_source: field('source', 'default'), bucket: 'page' }
31 if (c.cold) rate.cold = c.cold
32 if (c.dropped) rate.batch = { dropped: c.dropped }
33 return { $metadata: { spanName: 'ply.rate.check', type: 'span' }, source: { name: 'ply.rate.check', rate, ply: { script_version: version, route: 'rate.check' } } }
34}
36function flush(outcome: 'ok' | 'dropped', fault: string | null = null, version = V): unknown {
37 const rate: Record<string, unknown> = { batch: { outcome } }
38 if (fault) rate.fault = fault
39 return { $metadata: { spanName: 'ply.rate.flush', type: 'span' }, source: { name: 'ply.rate.flush', rate, ply: { script_version: version, route: 'rate.flush' } } }
40}
42/** A ply.rate.refresh span: `cold` is the cause the starting check stamped (rate.refresh.cold), read its outcome. */
43function refresh(cold: string, read: string, version = V): unknown {
44 return { $metadata: { spanName: 'ply.rate.refresh', type: 'span' }, source: { name: 'ply.rate.refresh', rate: { refresh: { trigger: 'cold', cold, read } }, ply: { script_version: version, route: 'rate.refresh' } } }
45}
47function times<T>(n: number, f: () => T): T[] {
48 return Array.from({ length: n }, f)
49}
51const HEALTHY = [check({ cold: 'isolate_start', decision: 'fail_open' }), ...times(40, () => check({})), ...times(30, () => flush('ok'))]
53test('policy: cd.policy.json carries the rate gate with its evidence', () => {
54 assert.equal(POLICY.expectMode, 'memo')
55 assert.equal(POLICY.maxDroppedFlushes, 0)
56 assert.ok(POLICY.maxFailOpenRate > 0 && POLICY.maxFailOpenRate < 1)
57 assert.ok(POLICY.minChecks <= POLICY.probes)
58 assert.match(POLICY.calibration.observed, /128,753/)
59 const body = JSON.parse(POLICY_TEXT) as Record<string, unknown>
60 const { rate: _rate, ...without } = body
61 assert.deepEqual(parsePolicy(JSON.stringify(without)).policy.rate, DEFAULT_RATE_GATE, 'omitted: the default')
62 const bad = { ...body, rate: { ...(body.rate as object), minChecks: 31, probes: 30 } }
63 assert.throws(() => parsePolicy(JSON.stringify(bad)), /rate.minChecks/)
64 const unknown = { ...body, rate: { ...(body.rate as object), extra: 1 } }
65 assert.throws(() => parsePolicy(JSON.stringify(unknown)), /unknown field/)
66})
68test('cloudflare.config.ts RATE_MODE is the mode the gate expects (one edit cannot ship without the other)', () => {
69 const config = readFileSync(new URL('../cloudflare.config.ts', import.meta.url), 'utf8')
70 const found = /RATE_MODE: bindings\.text\("(\w+)"\)/.exec(config)
71 assert.ok(found, 'RATE_MODE binding in cloudflare.config.ts')
72 assert.equal(found[1], POLICY.expectMode)
73 assert.equal(DEFAULT_RATE_GATE.expectMode, POLICY.expectMode)
74})
76test('59926117 / e61a5742: the silent fallback to legacy fails the version (real spans)', () => {
77 for (const version of [V59926117, VE61A5742]) {
78 const counts = countsFromSpans(SILENT, version)
79 assert.ok(unwrapOr(recordGet(counts.modes, 'legacy'), 0) > 0, version)
80 assert.equal(unwrapOr(recordGet(counts.modes, 'batched'), 0), 0)
81 assert.equal(unwrapOr(recordGet(counts.modes, 'memo'), 0), 0)
82 const verdict = judgeRate(counts, POLICY)
83 assert.equal(verdict.kind, 'worker', `${version}: ${verdict.line}`)
84 assert.match(verdict.line, /mode: legacy \d+ of \d+ default-mode checks ran a limiter other than memo/)
85 }
86})
88test('mode: a single default-mode check on the wrong limiter fails, with no minimum sample', () => {
89 const verdict = judgeRate(countsFromSpans([check({ mode: 'legacy' })], V), POLICY)
90 assert.equal(verdict.kind, 'worker')
91 const batched = judgeRate(countsFromSpans([...HEALTHY, check({ mode: 'batched' })], V), POLICY)
92 assert.equal(batched.kind, 'worker', 'batched is not the configured default either')
93 // A deliberate rollback edits expectMode with RATE_MODE: the same spans then pass on batched.
94 const rolledBack = judgeRate(countsFromSpans(times(30, () => check({ mode: 'batched' })), V), { ...POLICY, expectMode: 'batched' })
95 assert.equal(rolledBack.kind, 'pass', rolledBack.line)
96})
98test('mode: load requests that chose their arm with x-ply-rate-mode are not judged', () => {
99 const arms = [...HEALTHY, ...times(50, () => check({ mode: 'legacy', source: 'header' })), ...times(50, () => check({ mode: 'batched', source: 'header', decision: 'fail_open' }))]
100 const verdict = judgeRate(countsFromSpans(arms, V), POLICY)
101 assert.equal(verdict.kind, 'pass', verdict.line)
102 assert.equal(verdict.kind === 'pass' ? verdict.counts.headerChecks : -1, 100)
103})
105test('healthy: memo everywhere, cold fail_open excluded, no drops → pass', () => {
106 const verdict = judgeRate(countsFromSpans(HEALTHY, V), POLICY)
107 assert.equal(verdict.kind, 'pass', verdict.line)
108 assert.match(verdict.line, /fail_open warm 0\/40/)
109})
111test('fail_open: a warm share above the threshold fails; at it passes; cold isolates do not count', () => {
112 const warm = 40
113 const limit = Math.floor(warm * POLICY.maxFailOpenRate)
114 const at = [...times(warm - limit, () => check({})), ...times(limit, () => check({ decision: 'fail_open' }))]
115 assert.equal(judgeRate(countsFromSpans(at, V), POLICY).kind, 'pass')
116 const over = [...times(warm - limit - 1, () => check({})), ...times(limit + 1, () => check({ decision: 'fail_open' }))]
117 const failed = judgeRate(countsFromSpans(over, V), POLICY)
118 assert.equal(failed.kind, 'worker')
119 assert.match(failed.line, /fail_open: \d+\/40 warm default-mode checks failed open/)
120 // A fresh canary: every isolate's first check fails open (no document yet). That is by design, not degradation.
121 const fresh = [...times(15, () => check({ cold: 'isolate_start', decision: 'fail_open' })), ...times(30, () => check({}))]
122 assert.equal(judgeRate(countsFromSpans(fresh, V), POLICY).kind, 'pass')
123 // A broken read path: every warm check fails open.
124 const broken = [...times(3, () => check({ cold: 'isolate_start', decision: 'fail_open' })), ...times(30, () => check({ decision: 'fail_open' }))]
125 assert.equal(judgeRate(countsFromSpans(broken, V), POLICY).kind, 'worker')
126})
128// ply-web#156: the live window of CD 2026-11-12T13-06-51-511Z (33d69a40): 33 default-mode checks, 4 isolate starts, and
129// one crawler request (cf-ray a595ccf10c639249) on isolate 2058502eefa348bb9abc after 339.4 s idle, whose memo had
130// expired; its refresh read ok in 6 ms. Before the Worker stamped rate.cold = memo_expired, that read 1/29 warm.
131const LIVE_156 = [
132 ...times(4, () => check({ cold: 'isolate_start', decision: 'fail_open' })),
133 check({ cold: 'memo_expired', decision: 'fail_open' }),
134 refresh('memo_expired', 'ok'),
135 ...times(28, () => check({})),
136 ...times(33, () => flush('ok')),
137]
139test('#156: an idle isolate\'s expired memo is an expected fail_open, counted on its own, not in the warm share', () => {
140 const verdict = judgeRate(countsFromSpans(LIVE_156, V), POLICY)
141 assert.equal(verdict.kind, 'pass', verdict.line)
142 assert.match(verdict.line, /fail_open warm 0\/28 = 0\.00%/)
143 assert.match(verdict.line, /expected fail_open isolate_start 4\/4, memo_expired 1\/1 \(refresh ok 1, failed 0\)/)
144 // Three idle expiries in one window: 3/31 = 9.7% warm before, a false rollback one expiry away. Now 0 warm.
145 const three = [...LIVE_156, ...times(2, () => check({ cold: 'memo_expired', decision: 'fail_open' })), ...times(2, () => refresh('memo_expired', 'ok'))]
146 const threeVerdict = judgeRate(countsFromSpans(three, V), POLICY)
147 assert.equal(threeVerdict.kind, 'pass', threeVerdict.line)
148 assert.match(threeVerdict.line, /fail_open warm 0\/28/)
149 // The same three as read_failed (no document after a settled refresh) are real failures: 3/31 warm, and 4 fails.
150 const broken = [...LIVE_156, ...times(4, () => check({ decision: 'fail_open' }))]
151 const brokenVerdict = judgeRate(countsFromSpans(broken, V), POLICY)
152 assert.equal(brokenVerdict.kind, 'worker', brokenVerdict.line)
153 assert.match(brokenVerdict.line, /fail_open: 4\/32 warm/)
154})
156test('#156: an expired memo whose own refresh failed is a warm read-path failure', () => {
157 const failedRefresh = [...LIVE_156.filter(e => e !== LIVE_156[5]), refresh('memo_expired', 'fail')]
158 const counts = countsFromSpans(failedRefresh, V)
159 assert.deepEqual(counts.expiredRefresh, { ok: 0, failed: 1 })
160 const verdict = judgeRate(counts, POLICY)
161 assert.match(verdict.line, /fail_open warm 1\/29 = 3\.45%/)
162 assert.match(verdict.line, /1 counted warm/)
163 // Enough of them fail the version, at the unchanged threshold.
164 const many = [...failedRefresh, ...times(3, () => check({ cold: 'memo_expired', decision: 'fail_open' })), ...times(3, () => refresh('memo_expired', 'fail'))]
165 const manyVerdict = judgeRate(countsFromSpans(many, V), POLICY)
166 assert.equal(manyVerdict.kind, 'worker', manyVerdict.line)
167 assert.match(manyVerdict.line, /fail_open: 4\/32 warm/)
168})
170test('dropped: one flush dropped without a fault fails; injected-fault drops do not; overflow does', () => {
171 assert.equal(judgeRate(countsFromSpans([...HEALTHY, flush('dropped')], V), POLICY).kind, 'worker')
172 const faulted = judgeRate(countsFromSpans([...HEALTHY, flush('dropped', 'error=0;attempts=2'), flush('dropped', 'slow-ack=9000;attempts=9')], V), POLICY)
173 assert.equal(faulted.kind, 'pass', faulted.line)
174 const overflow = judgeRate(countsFromSpans([...HEALTHY, check({ dropped: 'overflow' })], V), POLICY)
175 assert.equal(overflow.kind, 'worker')
176 assert.match(overflow.line, /overflow 1/)
177})
179test('too few warm checks: a harness fault, not a pass; a mode or drop failure still fails at once', () => {
180 const few = judgeRate(countsFromSpans(times(5, () => check({})), V), POLICY)
181 assert.equal(few.kind, 'harness_fault')
182 assert.match(few.line, /< minChecks/)
183 assert.equal(judgeRate(countsFromSpans([...times(5, () => check({})), flush('dropped')], V), POLICY).kind, 'worker')
184})
186test('other versions in the window are ignored', () => {
187 const mixed = [...HEALTHY, ...times(10, () => check({ mode: 'legacy' }, 'bbbbbbbb-0000-4000-8000-000000000002')), flush('dropped', null, 'bbbbbbbb-0000-4000-8000-000000000002')]
188 assert.equal(judgeRate(countsFromSpans(mixed, V), POLICY).kind, 'pass')
189})
191/** What Workers Observability's grouped counts return for a set of span events: a key absent on an event drops it. */
192function aggregate(events: readonly unknown[], filter: (rate: Record<string, unknown>, name: string) => boolean, groupBys: readonly string[]): CountRow[] {
193 const rows = new Map<string, CountRow>()
194 for (const e of events) {
195 const source = (e as { source: Record<string, unknown> }).source
196 const rate = dig(source, ['rate'])
197 if (!filter((rate.tag === 'some' ? rate.value : {}) as Record<string, unknown>, String(source.name))) continue
198 const groups: Record<string, string> = {}
199 let complete = true
200 for (const key of groupBys) {
201 const v = dig(source, key.split('.'))
202 if (v.tag === 'none') complete = false
203 else groups[key] = String(v.value)
204 }
205 if (!complete) continue
206 const id = JSON.stringify(groups)
207 const prev = rows.get(id)
208 rows.set(id, { groups, count: (prev ? prev.count : 0) + 1 })
209 }
210 return [...rows.values()]
211}
213test('countsFromRows (the production aggregate path) agrees with countsFromSpans', async () => {
214 const events = [
215 ...HEALTHY,
216 ...times(7, () => check({ decision: 'fail_open' })),
217 ...times(3, () => check({ cold: 'isolate_start' })),
218 ...times(4, () => check({ mode: 'legacy', source: 'header' })),
219 ...times(2, () => check({ mode: 'batched', source: 'header', decision: 'fail_open', cold: 'isolate_start' })),
220 ...times(2, () => check({ cold: 'memo_expired', decision: 'fail_open' })),
221 check({ cold: 'memo_expired', decision: 'fail_open', source: 'header' }),
222 refresh('memo_expired', 'ok'),
223 refresh('memo_expired', 'fail'),
224 refresh('isolate_start', 'fail'),
225 check({ dropped: 'overflow' }),
226 flush('dropped'),
227 flush('dropped', 'error=0;attempts=2'),
228 ]
229 const seen: { filters: readonly Filter[]; groupBys: readonly string[] }[] = []
230 const rows = await queryRateRows('ply', V, async (filters, groupBys) => {
231 seen.push({ filters, groupBys })
232 const has = (key: string, value: string | null = null) => filters.some(f => f.key === key && (value === null || f.value === value))
233 const named = filters.find(f => f.key === '$metadata.spanName')
234 const name = named ? named.value : ''
235 return aggregate(events, (rate, n) => {
236 if (n !== name) return false
237 if (has('rate.mode_source', 'header') && rate.mode_source !== 'header') return false
238 if (has('rate.cold') && dig(rate, ['cold']).tag === 'none') return false
239 if (has('rate.refresh.cold', 'memo_expired') && unwrapOr(dig(rate, ['refresh', 'cold']), '') !== 'memo_expired') return false
240 if (has('rate.batch.dropped') && dig(rate, ['batch', 'dropped']).tag === 'none') return false
241 if (has('rate.batch.outcome', 'dropped') && unwrapOr(dig(rate, ['batch', 'outcome']), '') !== 'dropped') return false
242 if (has('rate.fault') && dig(rate, ['fault']).tag === 'none') return false
243 return true
244 }, groupBys)
245 })
246 assert.deepEqual(countsFromRows(rows), countsFromSpans(events, V))
247 assert.equal(seen.length, 7)
248 for (const q of seen) {
249 assert.ok(q.filters.some(f => f.key === 'ply.script_version' && f.value === V), 'every query is scoped to the version')
250 assert.ok(q.filters.some(f => f.key === '$metadata.service' && f.value === 'ply'))
251 }
252 const cold = seen.find(q => q.filters.some(f => f.key === 'rate.cold'))
253 assert.ok(cold)
254 assert.deepEqual(cold.filters.find(f => f.key === 'rate.cold'), { key: 'rate.cold', operation: 'exists', type: 'string', value: '' })
255 assert.deepEqual(cold.groupBys, ['rate.cold', 'rate.mode_source', 'rate.decision'])
256 const expired = seen.find(q => q.filters.some(f => f.key === 'rate.refresh.cold'))
257 assert.ok(expired)
258 assert.deepEqual(expired.groupBys, ['rate.refresh.read'])
259 const counts = countsFromRows(rows)
260 assert.deepEqual(counts.cold.memo_expired, { checks: 2, failOpen: 2 }, 'the header-mode one is not judged')
261 assert.deepEqual(counts.expiredRefresh, { ok: 1, failed: 1 })
262})
264test('countRows reads a calculations response, grouped and ungrouped', () => {
265 const grouped = { calculations: [{ aggregates: [{ groups: [{ key: 'rate.mode', value: 'batched' }, { key: 'rate.decision', value: 'allow' }], count: 12 }] }] }
266 assert.deepEqual(countRows(grouped), [{ groups: { 'rate.mode': 'batched', 'rate.decision': 'allow' }, count: 12 }])
267 assert.deepEqual(countRows({ calculations: [{ aggregates: [{ value: 0, count: 0 }] }] }), [{ groups: {}, count: 0 }])
268 assert.throws(() => countRows({ events: [] }), /no calculations/)
269})
271test('pollRate: re-queries while too few checks are ingested, then judges; gives up at waitMs', async () => {
272 let t = 0
273 const pages: RateCounts[] = [countsFromSpans(times(3, () => check({})), V), countsFromSpans(times(12, () => check({})), V), countsFromSpans(HEALTHY, V)]
274 let i = 0
275 const verdict = await pollRate(POLICY, { query: async () => pages[Math.min(i++, pages.length - 1)] as RateCounts, sleep: async ms => { t += ms }, now: () => t, pollsMs: [3_000], waitMs: 60_000 })
276 assert.equal(verdict.kind, 'pass')
277 assert.equal(i, 3)
278 t = 0
279 const stuck = await pollRate(POLICY, { query: async () => countsFromSpans([], V), sleep: async ms => { t += ms }, now: () => t, pollsMs: [3_000], waitMs: 10_000 })
280 assert.equal(stuck.kind, 'harness_fault')
281 assert.ok(t <= 10_000)
282})
284test('probes: pinned, carry the load token and a run label, never a mode header; manual redirects', async () => {
285 const sent: { url: string; headers: Record<string, string>; redirect: string }[] = []
286 const r = await sendRateProbes({ baseUrl: 'https://ply.example', worker: 'ply', version: V, loadToken: 'load-secret', label: 'cd-rate:run1:canary', policy: { ...POLICY, probes: 4, probeGapMs: 0 } }, {
287 fetch: async (url, init) => {
288 sent.push({ url, headers: init.headers, redirect: init.redirect })
289 const n = sent.length
290 if (n === 4) throw new Error('network')
291 return { status: n === 3 ? 429 : 302, headers: { get: (h: string) => (h === 'x-ply-version' ? (n === 2 ? 'other' : V) : null) }, body: null }
292 },
293 sleep: async () => {},
294 })
295 assert.deepEqual(r, { sent: 4, answered: 3, onVersion: 2, statuses: { 302: 2, 429: 1, error: 1 } })
296 for (const s of sent) {
297 assert.equal(s.url, `https://ply.example${POLICY.probePath}`)
298 assert.equal(s.headers['cloudflare-workers-version-overrides'], `ply="${V}"`)
299 assert.equal(s.headers['x-ply-load-token'], 'load-secret')
300 assert.equal(s.headers['x-ply-rate-client'], 'cd-rate:run1:canary')
301 assert.equal('x-ply-rate-mode' in s.headers, false, 'the probes must run the default limiter')
302 assert.equal(s.redirect, 'manual')
303 }
304})
Diagnostics4 git calls · 362 ms
CallStatusSizeTime0362 ms
discover200152 B2 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs 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 · 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 1020040 KiB · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=41349 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=526b305930b8ef382f2d7a1f9c0238730a585921 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=41349 git.pkt.payload.max=41254 git.sideband.band1.bytes=41253 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=61 git.pack.bytes=41253 git.pack.ofs_delta=0 git.pack.ref_delta=0 git.pack.chain.max=0 git.pack.trailer=ab60efef4b7243678c75de64a4386986ee885c1c git.pack.full=61Open pack map
fetch2005.5 KiB357 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=357 git.response.bytes=5621 git.response.cache=MISS git.response.duration_ms=357 git.fetch.wants=801dd0fd88a54d2909378fcb91953fdfbe994a7a 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=5621 git.pkt.payload.max=5600 git.sideband.band1.bytes=5599 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-web.git
- Ref
- refs/heads/main
- Commit
- 526b305930b8ef382f2d7a1f9c0238730a585921
- cf-ray
- a5e303c65dd57929
- Request
- 51f19c63…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format