main
1// The buffered decoder ply had before #172 made inflate() a collector over the pull (src/inflatestream.ts), tables and
2// all: kept in test/ as an independent oracle. test/packstream.test.js holds the one decoder in src/ to it (bytes,
3// consumed count, stats) for every chunking, so a mutant there cannot pass by changing both sides of the comparison.
4// It does not know the zlib window (a back-reference past CINFO's window is taken if it lands in the output) and reads
5// CINFO 8..15 as the header checksum alone; the pull refuses both, and the tests name the difference.
7import type { ErrorOf } from '../../src/errors.js';
8import { fail } from '../../src/errors.js';
9import type { Err, Result } from '../../src/result.js';
10import { ok, assertNever, getOrElse } from '../../src/result.js';
11import { fromNullable, fromNullish, type Input } from '../../src/absent.js';
12import { DEFAULT_LIMITS, checkLimit } from '../../src/limits.js';
13import { take } from '../../src/bytes.js';
14import {
15 ZLIB_HEADER_BYTES, ZLIB_CM_DEFLATE, ZLIB_CM_MASK, ZLIB_FDICT, ZLIB_HEADER_MOD, ADLER_BYTES, ADLER_MOD,
16 DEFLATE_BTYPE_BITS, DEFLATE_STORED, DEFLATE_FIXED, DEFLATE_DYNAMIC,
17 DEFLATE_STORED_HEADER_BYTES, DEFLATE_STORED_LEN_MASK,
18 DEFLATE_BIT_TABLE, DEFLATE_LITERALS, DEFLATE_EOB, DEFLATE_LENGTH_CODES,
19 DEFLATE_HLIT_BASE, DEFLATE_HLIT_BITS, DEFLATE_HDIST_BASE, DEFLATE_HDIST_BITS, DEFLATE_HCLEN_BASE, DEFLATE_HCLEN_BITS,
20 DEFLATE_HLIT_MAX, DEFLATE_HDIST_MAX, DEFLATE_CODELEN_CODES, DEFLATE_CODELEN_BITS,
21 DEFLATE_REPEAT_PREV, DEFLATE_REPEAT_ZERO3,
22 DEFLATE_REPEAT16_BASE, DEFLATE_REPEAT16_BITS, DEFLATE_REPEAT17_BASE, DEFLATE_REPEAT17_BITS,
23 DEFLATE_REPEAT18_BASE, DEFLATE_REPEAT18_BITS, DEFLATE_BFINAL_BITS, BYTE_SHIFT, BE32_SHIFTS, ADLER_SHIFT, zlibBound,
24} from '../../src/format.js';
25/* oxlint-disable no-magic-numbers -- RFC 1951 §3.2.5 length/distance alphabets and the fixed Huffman assignment */
26// The length and distance alphabets, built as RFC 1951 §3.2.5 defines them: each code's extra bits, and a base that is
27// the previous base plus the previous code's range (2^extra). Length code 285 is the exception: 0 extra bits, base 258.
28// test/mutant-kill.test.js holds these against the RFC's printed tables.
29const LBASE: number[] = [];
30const LEXT: number[] = [];
31const DBASE: number[] = [];
32const DEXT: number[] = [];
33for (let base = 3, i = 0; i < 29; i++) { const x = i < 8 || i === 28 ? 0 : (i >> 2) - 1; LEXT.push(x); LBASE.push(i === 28 ? 258 : base); base += 1 << x; }
34for (let base = 1, i = 0; i < 30; i++) { const x = i < 4 ? 0 : (i >> 1) - 1; DEXT.push(x); DBASE.push(base); base += 1 << x; }
35export const CLORDER: readonly number[] = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
37export const DEFLATE_TABLES: { readonly LBASE: readonly number[]; readonly LEXT: readonly number[]; readonly DBASE: readonly number[]; readonly DEXT: readonly number[] } = /* @__PURE__ */ Object.freeze({ LBASE, LEXT, DBASE, DEXT });
39export type Huffman = { readonly count: Uint16Array; readonly symbol: Uint16Array };
40// Canonical Huffman table from code lengths (puff algorithm). Returns {count, symbol}.
41// Indexed reads in this file are in range (each is bounded where it is read, as the comments there say), which
42// noUncheckedIndexedAccess cannot see; `as number` says so at no runtime cost (a fallback per read is bundle bytes).
43/* oxlint-disable typescript/no-unsafe-type-assertion, typescript/non-nullable-type-assertion-style -- in-range indexed reads, see above (`as number`, not the `!` src/ forbids) */
44export function huffBuild(lengths: ArrayLike<number>): Huffman {
45 const count = new Uint16Array(DEFLATE_BIT_TABLE);
46 const symbol = new Uint16Array(lengths.length);
47 const offs = new Uint16Array(DEFLATE_BIT_TABLE);
48 for (let i = 0; i < lengths.length; i++) { const l = lengths[i] as number; count[l] = (count[l] as number) + 1; }
49 count[0] = 0;
50 for (let l = 1; l < DEFLATE_BIT_TABLE; l++) offs[l] = (offs[l - 1] as number) + (count[l - 1] as number);
51 for (let s = 0; s < lengths.length; s++) { const l = lengths[s] as number; if (l) { const at = offs[l] as number; symbol[at] = s; offs[l] = at + 1; } }
52 return { count, symbol };
53}
55// lengths 0-143: 8, 144-255: 9, 256-279: 7, 280-287: 8
56export const FIXED_LIT: Huffman = huffBuild(new Uint8Array(288).fill(8).fill(9, 144, 256).fill(7, 256, 280));
57export const FIXED_DIST: Huffman = huffBuild(new Uint8Array(30).fill(5));
58/* oxlint-enable no-magic-numbers */
60export function adler32(bytes: Uint8Array, a = 1, b = 0): number {
61 // oxlint-disable-next-line no-param-reassign -- a and b are the running sums a caller may seed; updating them is the algorithm
62 for (let i = 0; i < bytes.length; i++) { a = (a + (bytes[i] as number)) % ADLER_MOD; b = (b + a) % ADLER_MOD; }
63 return ((b << ADLER_SHIFT) | a) >>> 0;
64}
66// expectedSize: the size the output must have (a pack header's); maxOutput: the cap on the output (limits.maxObjectSize
67// when left out); verifyAdler: check the zlib trailer's checksum (default true); raw: a deflate stream with no zlib
68// header or trailer (default false).
69export type InflateConfig = {
70 readonly expectedSize: number;
71 readonly maxOutput: number;
72 readonly verifyAdler: boolean;
73 readonly raw: boolean;
74};
75export type InflateOptions = Input<InflateConfig>;
76export type InflateStats = {
77 blocks: number; stored: number; fixed: number; dynamic: number;
78 literals: number; matches: number; matchBytes: number; maxDist: number; maxLen: number;
79};
80export type Inflated = { readonly out: Uint8Array; readonly consumed: number; readonly stats: InflateStats };
81export type InflateError = ErrorOf<'pack_corrupt'> | ErrorOf<'limit_exceeded'> | ErrorOf<'bad_request'>;
83// A deflate block's type (BTYPE, RFC 1951 §3.2.3). Bit value 3 is reserved and invalid.
84export type BlockType = 'stored' | 'fixed' | 'dynamic';
85type BlockKind = BlockType | 'invalid';
86// DEFLATE_STORED, DEFLATE_FIXED, DEFLATE_DYNAMIC (format.ts) are BTYPE 0, 1, 2.
87const blockKind = (btype: number): BlockKind => {
88 switch (btype) {
89 case DEFLATE_STORED: return 'stored';
90 case DEFLATE_FIXED: return 'fixed';
91 case DEFLATE_DYNAMIC: return 'dynamic';
92 default: return 'invalid';
93 }
94};
95type Corrupt = ErrorOf<'pack_corrupt'>;
96const corrupt = (msg: string): Err<Corrupt> => fail('pack_corrupt', msg);
97// What one step of the block loop returns: done (the shared DONE, so a step that succeeds allocates nothing), or the
98// refusal that ends the stream.
99type Step = Result<null, InflateError>;
100const DONE: Step = ok(null);
101// The bit reader and the Huffman decoder return a value, or one of these in its place. A value is never negative (bits
102// are masked to fewer than 31 of them, a symbol is a Uint16), so `< 0` is the check, and the check is at every read.
103const END = -1; // the input ran out
104const NO_CODE = -2; // no code of any length matched
105const ended = (): Err<Corrupt> => corrupt('inflate: unexpected end of input');
106const unread = (v: number): Err<Corrupt> => (v === NO_CODE ? corrupt('inflate: invalid huffman code') : ended());
108// oxlint-disable-next-line eslint/complexity -- one decoder (header, blocks by exhaustive block type, trailer)
109export function inflateRef(buf: Uint8Array, pos = 0, opts: InflateOptions = {}): Result<Inflated, InflateError> {
110 const { verifyAdler = true, raw = false } = opts;
111 const expected = fromNullish(opts.expectedSize);
112 // Omitted means the object cap. An explicit Infinity used to disable the check (`n > Infinity` is false).
113 let maxOutput = DEFAULT_LIMITS.maxObjectSize;
114 const givenMax = fromNullable(opts.maxOutput);
115 if (givenMax.tag === 'some') {
116 const m = checkLimit(givenMax.value, 'maxObjectSize');
117 if (!m.ok) return m;
118 maxOutput = m.value;
119 }
120 const over = (msg: string, what: string, got: number): Err<ErrorOf<'limit_exceeded'>> => fail('limit_exceeded', msg, { what, got, max: maxOutput });
121 const start = pos;
122 const stats: InflateStats = { blocks: 0, stored: 0, fixed: 0, dynamic: 0, literals: 0, matches: 0, matchBytes: 0, maxDist: 0, maxLen: 0 };
123 // bit reader (LSB-first); p is also the zlib header's cursor
124 let p = pos;
125 let bitbuf = 0;
126 let bitcnt = 0;
127 if (!raw) {
128 const hdr = take(buf, p, ZLIB_HEADER_BYTES);
129 if (!hdr.ok) return hdr;
130 const cmf = hdr.value[0] as number;
131 const flg = hdr.value[1] as number;
132 if ((cmf & ZLIB_CM_MASK) !== ZLIB_CM_DEFLATE) return corrupt(`zlib: unsupported method ${cmf & ZLIB_CM_MASK}`);
133 if (((cmf << BYTE_SHIFT) | flg) % ZLIB_HEADER_MOD !== 0) return corrupt('zlib: bad header check');
134 if (flg & ZLIB_FDICT) return corrupt('zlib: preset dictionary not supported');
135 p += ZLIB_HEADER_BYTES;
136 }
137 if (expected.tag === 'some' && expected.value > maxOutput) return fail('limit_exceeded', `inflate: expected size ${expected.value} exceeds limit ${maxOutput}`, { what: 'inflate expected size', got: expected.value, max: maxOutput });
138 // The stream may not run past zlibBound of the size it will produce (format.js): a run of non-final empty stored blocks
139 // (5 bytes in, 0 out) used to be consumed to the end of the buffer, so a pack's bytes bounded its CPU, not its objects.
140 // Without an expected size the output cap stands in. Checked where a block starts (so an endless stream is refused a
141 // few bytes past the bound, before any more of it is read) and when the stream ends (a last block may be long).
142 const declared = getOrElse(expected, maxOutput);
143 const maxInput = zlibBound(declared);
144 const tooLong = (n: number): Err<Corrupt> => corrupt(`inflate: zlib stream longer than its declared size allows (${n} > ${maxInput} for ${declared} bytes)`);
145 const guess = Math.max(256, (buf.length - p) * 3); // oxlint-disable-line no-magic-numbers -- output-buffer growth, not a wire-format fact
146 let out = new Uint8Array(getOrElse(expected, Math.min(maxOutput, guess)));
147 let o = 0;
148 const ensure = (n: number): Step => {
149 if (o + n <= out.length) return DONE;
150 if (expected.tag === 'some') return corrupt(`inflate: output exceeds expected ${expected.value}`);
151 if (o + n > maxOutput) return over(`inflate: output exceeds limit ${maxOutput}`, 'inflate output', o + n);
152 let cap = Math.min(maxOutput, out.length * 2); // oxlint-disable-line no-magic-numbers -- output-buffer growth, not a wire-format fact
153 while (cap < o + n) cap = Math.min(maxOutput, cap * 2); // oxlint-disable-line no-magic-numbers -- output-buffer growth, not a wire-format fact
154 const nb = new Uint8Array(cap); nb.set(out.subarray(0, o)); out = nb;
155 return DONE;
156 };
158 // n bits, or END. The block loop is a hot loop of small closures, so a read returns a number, never a Result.
159 const bits = (n: number): number => {
160 let v = bitbuf;
161 while (bitcnt < n) {
162 if (p >= buf.length) return END;
163 v |= (buf[p++] as number) << bitcnt; bitcnt += BYTE_SHIFT;
164 }
165 bitbuf = v >>> n; bitcnt -= n;
166 return v & ((1 << n) - 1);
167 };
168 // puff's decode, one code bit at a time, the bit read inline: a call to bits(1) per code bit was the hot spot (PR body).
169 // A symbol, END, or NO_CODE.
170 const decode = (h: Huffman): number => {
171 let code = 0;
172 let first = 0;
173 let index = 0;
174 for (let len = 1; len < DEFLATE_BIT_TABLE; len++) {
175 if (bitcnt === 0) {
176 if (p >= buf.length) return END;
177 bitbuf = buf[p++] as number; bitcnt = BYTE_SHIFT;
178 }
179 code |= bitbuf & 1; bitbuf >>>= 1; bitcnt--; // oxlint-disable-line oxc/bad-bitwise-operator -- puff's decode: the next bit goes in at bit 0
180 const c = h.count[len] as number;
181 if (code - first < c) return h.symbol[index + code - first] as number;
182 index += c; first = (first + c) << 1; code <<= 1;
183 }
184 return NO_CODE;
185 };
186 const codes = (lit: Huffman, dist: Huffman): Step => {
187 for (;;) {
188 const sym = decode(lit);
189 if (sym < 0) return unread(sym);
190 if (sym < DEFLATE_LITERALS) {
191 const room = ensure(1);
192 if (!room.ok) return room;
193 out[o++] = sym; stats.literals++;
194 continue;
195 }
196 if (sym === DEFLATE_EOB) return DONE;
197 const li = sym - DEFLATE_HLIT_BASE;
198 if (li >= DEFLATE_LENGTH_CODES) return corrupt('inflate: bad length symbol');
199 const lx = bits(LEXT[li] as number);
200 if (lx < 0) return ended();
201 const len = (LBASE[li] as number) + lx;
202 const di = decode(dist);
203 if (di < 0) return unread(di);
204 if (di >= DEFLATE_HDIST_MAX) return corrupt('inflate: bad distance symbol');
205 const dx = bits(DEXT[di] as number);
206 if (dx < 0) return ended();
207 const d = (DBASE[di] as number) + dx;
208 if (d > o) return corrupt('inflate: distance too far back');
209 const room = ensure(len);
210 if (!room.ok) return room;
211 stats.matches++; stats.matchBytes += len;
212 if (d > stats.maxDist) stats.maxDist = d;
213 if (len > stats.maxLen) stats.maxLen = len;
214 // A match that does not overlap its own output is one copy; an overlapping one repeats its last d bytes, so it is
215 // copied byte by byte (the overlap is the encoding: `d = 1, len = 258` is a run of one byte).
216 if (d >= len) { out.copyWithin(o, o - d, o - d + len); o += len; }
217 else { let from = o - d; for (let i = 0; i < len; i++) out[o++] = out[from++] as number; }
218 }
219 };
220 // A dynamic block's code length codes, then the literal/length and distance code lengths they encode (RFC 1951
221 // §3.2.7), then the block's symbols.
222 const dynamic = (): Step => {
223 const hlit = bits(DEFLATE_HLIT_BITS);
224 const hdist = bits(DEFLATE_HDIST_BITS);
225 const hclen = bits(DEFLATE_HCLEN_BITS);
226 // A read that runs out reads no byte, so the next read of as many bits or more runs out too: HLIT's failure is
227 // HDIST's (5 bits each). HCLEN (4) can still be there after HDIST ran out, so both are checked.
228 if (hdist < 0 || hclen < 0) return ended();
229 const nlen = hlit + DEFLATE_HLIT_BASE;
230 const ndist = hdist + DEFLATE_HDIST_BASE;
231 const ncode = hclen + DEFLATE_HCLEN_BASE;
232 if (nlen > DEFLATE_HLIT_MAX || ndist > DEFLATE_HDIST_MAX) return corrupt('inflate: bad dynamic counts');
233 const lengths = new Uint8Array(DEFLATE_HLIT_MAX + DEFLATE_HDIST_MAX);
234 for (let i = 0; i < ncode; i++) {
235 const l = bits(DEFLATE_CODELEN_BITS);
236 if (l < 0) return ended();
237 lengths[CLORDER[i] as number] = l;
238 }
239 const lencode = huffBuild(lengths.subarray(0, DEFLATE_CODELEN_CODES));
240 let i = 0;
241 while (i < nlen + ndist) {
242 const sym = decode(lencode);
243 if (sym < 0) return unread(sym);
244 if (sym < DEFLATE_REPEAT_PREV) { lengths[i++] = sym; continue; }
245 let base: number;
246 let rx: number;
247 let val = 0;
248 if (sym === DEFLATE_REPEAT_PREV && i === 0) return corrupt('inflate: repeat with no previous');
249 if (sym === DEFLATE_REPEAT_PREV) { val = lengths[i - 1] as number; base = DEFLATE_REPEAT16_BASE; rx = bits(DEFLATE_REPEAT16_BITS); }
250 else if (sym === DEFLATE_REPEAT_ZERO3) { base = DEFLATE_REPEAT17_BASE; rx = bits(DEFLATE_REPEAT17_BITS); }
251 else { base = DEFLATE_REPEAT18_BASE; rx = bits(DEFLATE_REPEAT18_BITS); } // 18: lencode has 19 symbols, 0-18
252 if (rx < 0) return ended();
253 let rep = base + rx;
254 if (i + rep > nlen + ndist) return corrupt('inflate: repeat overflow');
255 while (rep--) lengths[i++] = val;
256 }
257 if (lengths[DEFLATE_EOB] === 0) return corrupt('inflate: no end-of-block code');
258 return codes(huffBuild(Array.from(lengths.subarray(0, nlen))), huffBuild(Array.from(lengths.subarray(nlen, nlen + ndist))));
259 };
260 // One block: its header bits are read, then its body by its type, exhaustively.
261 const block = (type: BlockKind): Step => {
262 switch (type) {
263 case 'stored': {
264 stats.stored++;
265 bitbuf = 0; bitcnt = 0; // discard to byte boundary
266 if (p + DEFLATE_STORED_HEADER_BYTES > buf.length) return corrupt('inflate: truncated stored header');
267 const sh = buf.subarray(p, p + DEFLATE_STORED_HEADER_BYTES); // in range: checked on the line above
268 const len = (sh[0] as number) | ((sh[1] as number) << BYTE_SHIFT);
269 const nlen = (sh[2] as number) | ((sh[3] as number) << BYTE_SHIFT);
270 if (len !== (~nlen & DEFLATE_STORED_LEN_MASK)) return corrupt('inflate: stored length check failed');
271 p += DEFLATE_STORED_HEADER_BYTES;
272 if (p + len > buf.length) return corrupt('inflate: truncated stored block');
273 const room = ensure(len);
274 if (!room.ok) return room;
275 out.set(buf.subarray(p, p + len), o); o += len; p += len; // in range: "truncated stored block" above
276 return DONE;
277 }
278 case 'fixed':
279 stats.fixed++;
280 return codes(FIXED_LIT, FIXED_DIST);
281 case 'dynamic':
282 stats.dynamic++;
283 return dynamic();
284 case 'invalid': return corrupt('inflate: invalid block type');
285 }
286 return assertNever(type);
287 };
289 let last: number;
290 do {
291 if (p - start > maxInput) return tooLong(p - start);
292 last = bits(DEFLATE_BFINAL_BITS);
293 const btype = bits(DEFLATE_BTYPE_BITS);
294 // BFINAL (1 bit) that ran out leaves BTYPE (2) nothing to read: BTYPE's check is BFINAL's too
295 if (btype < 0) return ended();
296 stats.blocks++;
297 const done = block(blockKind(btype));
298 if (!done.ok) return done;
299 } while (!last);
301 const result = out.subarray(0, o);
302 if (!raw) {
303 if (p + ADLER_BYTES > buf.length) return corrupt('inflate: truncated adler32');
304 const ad = buf.subarray(p, p + ADLER_BYTES); // in range: checked on the line above
305 const want = (((ad[0] as number) << (BE32_SHIFTS[0] as number)) | ((ad[1] as number) << (BE32_SHIFTS[1] as number)) | ((ad[2] as number) << (BE32_SHIFTS[2] as number)) | (ad[3] as number)) >>> 0;
306 if (verifyAdler && adler32(result) !== want) return corrupt('inflate: adler32 mismatch');
307 p += ADLER_BYTES;
308 }
309 if (expected.tag === 'some' && o !== expected.value) return corrupt(`inflate: size ${o} != expected ${expected.value}`);
310 if (p - start > maxInput) return tooLong(p - start);
311 return ok({ out: result, consumed: p - start, stats });
312}
Diagnostics4 git calls · 27 ms
CallStatusSizeTime027 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 B2 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=UPDATING 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=21 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
fetch2006.1 KiB · hit22 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=6197 git.response.cache=HIT git.response.duration_ms=22 git.fetch.wants=abe5caaa61e4eb323b0fd257235373e71956e04d 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=6197 git.pkt.payload.max=6176 git.sideband.band1.bytes=6175 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
- a5e2ebd0d85d4bc2
- Request
- 9ec80e9f…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format