Artifactspublic-v0

ply

main
ply4 git calls24 ms44 KiB3 cachedprotocol v2
331 lines19 KiBRaw
1// .gitattributes, as git reads them (attr.c, dir.c, wildmatch.c, quote.c): parse, match and fill, byte for byte. Pure.
2//
3// Strings here are byte strings (one char per byte, as String.fromCharCode(byte)): paths and attribute files are bytes,
4// git's ctype is ASCII-only, and every comparison is bytewise. Use `bytesToStr` / `utf8ToStr` at the edges.
5//
6// What is modelled: one attribute stack per path — the built-in `[attr]binary -diff -merge -text` at the bottom, the
7// root .gitattributes (the only file allowed to define macros), then one .gitattributes per directory down to the
8// path's own; patterns with gitignore semantics (no '/' → basename at any depth below the file's directory; trailing
9// '/' → directories only, so never a file; leading '/' anchors; wildmatch with WM_PATHNAME); states set / -unset /
10// !unspecified / =value; git's fill order (most specific file first, lines bottom-up, a line's states right to left,
11// first assignment wins, a macro set to true expands where it is assigned). Not modelled: $GIT_DIR/info/attributes,
12// core.attributesFile and system attributes — they live on the server, not in the tree.
13//
14// Verified against `git check-attr --source` (test/fuzz/attributes.mjs).
16/* oxlint-disable unicorn/prefer-code-point -- byte strings (above): charCodeAt/fromCharCode are the byte <-> char map; codePointAt would pair surrogates */
17import type { Option, Result } from './result.js';
18import type { ErrorOf } from './errors.js';
19import type { Input } from './absent.js';
20import { encodeBytes } from './bytes.js';
21import { none, some, getOrElse, map } from './result.js';
22import { fromNullable, mapGet, withDefaults } from './absent.js';
24// The last element of a stack, taken off it; None when the stack is empty.
25export const popLast = <T>(xs: T[]): Option<T> => fromNullable(xs.pop());
27// A state as a line assigns it: true (set), false (-unset), null (!unspecified), or a =value (A6: an AttrValue union).
28export type AttrValue = boolean | null | string;
29export type AttrState = readonly [name: string, value: AttrValue];
30export type Pattern = {
31 readonly pattern: string;
32 readonly negative: boolean;
33 readonly mustBeDir: boolean;
34 readonly nodir: boolean;
35 readonly prefix: number;
36 readonly endsWith: boolean;
37};
38// A line that defines a macro, or a pattern line: `'pat' in line` tells them apart. A skipped line is null.
39export type AttrLine =
40 | { readonly macro: string; readonly states: readonly AttrState[] }
41 | { readonly pat: Pattern; readonly states: readonly AttrState[] };
42export type ParseConfig = { readonly macrosOk: boolean; readonly reserveBuiltin: boolean };
43export type ParseOptions = Input<ParseConfig>;
44const parseDefaults = (): ParseConfig => ({ macrosOk: false, reserveBuiltin: true });
46export const UNSET = null; // '!attr' — explicitly unspecified
47const BLANK = ' \t\r\n';
48const MAX_LINE = 2048;
49const MAX_FILE = 100 * 1024 * 1024;
50const BUILTIN = '[attr]binary -diff -merge -text';
52export const bytesToStr = (bytes: Uint8Array): string => { let s = ''; for (let i = 0; i < bytes.length; i += 8192) s += String.fromCharCode(...bytes.subarray(i, i + 8192)); return s; };
53// encodeBytes: a path whose tree name held escaped bytes (#43) is matched on those bytes, as check-attr matches them.
54// A string with no byte form (a lone surrogate) is refused.
55export const utf8ToStr = (s: string): Result<string, ErrorOf<'bad_request'>> => map(encodeBytes(s, 'path'), bytesToStr);
57// ---- git's sane_ctype (ASCII only) ----
58type Ctype = (c: number) => boolean;
59const isAlpha: Ctype = c => (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
60const isDigit: Ctype = c => c >= 48 && c <= 57;
61const isUpper: Ctype = c => c >= 65 && c <= 90;
62const isLower: Ctype = c => c >= 97 && c <= 122;
63const isSpace: Ctype = c => c === 9 || c === 10 || c === 13 || c === 32;
64const isPrint: Ctype = c => c >= 0x20 && c <= 0x7e;
65const isGraph: Ctype = c => c >= 0x21 && c <= 0x7e;
66const isCntrl: Ctype = c => c < 32 || c === 127;
67const isPunct: Ctype = c => isGraph(c) && !isAlpha(c) && !isDigit(c);
68const isXdigit: Ctype = c => isDigit(c) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102);
69const isBlank: Ctype = c => c === 32 || c === 9;
70const isGlobSpecial: Ctype = c => c === 42 || c === 63 || c === 91 || c === 92; // * ? [ \
72// a Map: the class name comes from .gitattributes, and `[[:constructor:]]` is not a class (wildmatch: ABORT_ALL)
73const CLASSES = new Map<string, Ctype>([['alnum', c => isAlpha(c) || isDigit(c)], ['alpha', isAlpha], ['blank', isBlank], ['cntrl', isCntrl], ['digit', isDigit], ['graph', isGraph], ['lower', isLower], ['print', isPrint], ['punct', isPunct], ['space', isSpace], ['upper', isUpper], ['xdigit', isXdigit]]);
75// ---- wildmatch.c (no WM_CASEFOLD: a bare server repo has core.ignorecase off) ----
76const MATCH = 0;
77const NOMATCH = 1;
78const ABORT_ALL = -1;
79const ABORT_TO_STARSTAR = -2;
80// A line-for-line port of wildmatch.c's dowild: C's pattern and text pointers advance in place, in one function.
81/* oxlint-disable eslint/no-param-reassign, eslint/max-depth, eslint/complexity, eslint/no-unmodified-loop-condition -- a line-for-line port of dowild (above) */
82function dowild(P: string, pi: number, T: string, ti: number, pathname: boolean): number {
83 const p = (i: number): number => (i < P.length ? P.charCodeAt(i) : 0);
84 const t = (i: number): number => (i < T.length ? T.charCodeAt(i) : 0);
85 for (; p(pi) !== 0; ti++, pi++) {
86 let pch = p(pi); let tch = t(ti);
87 if (tch === 0 && pch !== 42) return ABORT_ALL;
88 switch (pch) {
89 default: if (pch === 92) pch = p(++pi); if (tch !== pch) return NOMATCH; continue; // '\\': the next is literal
90 case 63: if (pathname && tch === 47) return NOMATCH; continue; // '?'
91 case 42: { // '*'
92 let matchSlash: boolean;
93 if (p(++pi) === 42) {
94 const prev = pi;
95 while (p(++pi) === 42) { /* skip */ }
96 if (!pathname) matchSlash = true;
97 else if ((prev < 2 || p(prev - 2) === 47) && (p(pi) === 0 || p(pi) === 47 || (p(pi) === 92 && p(pi + 1) === 47))) {
98 if (p(pi) === 47 && dowild(P, pi + 1, T, ti, pathname) === MATCH) return MATCH;
99 matchSlash = true;
100 } else matchSlash = false;
101 } else matchSlash = !pathname;
102 if (p(pi) === 0) {
103 if (!matchSlash && T.includes('/', ti)) return ABORT_TO_STARSTAR;
104 return MATCH;
105 } else if (!matchSlash && p(pi) === 47) {
106 const slash = T.indexOf('/', ti);
107 if (slash < 0) return ABORT_ALL;
108 ti = slash; break; // the slash is consumed by the loop
109 }
110 for (;;) {
111 if (tch === 0) break;
112 if (!isGlobSpecial(p(pi))) {
113 const want = p(pi);
114 while ((tch = t(ti)) !== 0 && (matchSlash || tch !== 47)) { if (tch === want) break; ti++; }
115 if (tch !== want) return matchSlash ? ABORT_ALL : ABORT_TO_STARSTAR;
116 }
117 const m = dowild(P, pi, T, ti, pathname);
118 if (m !== NOMATCH) { if (!matchSlash || m !== ABORT_TO_STARSTAR) return m; }
119 else if (!matchSlash && tch === 47) return ABORT_TO_STARSTAR;
120 tch = t(++ti);
121 }
122 return ABORT_ALL;
123 }
124 case 91: { // '['
125 pch = p(++pi);
126 if (pch === 94) pch = 33; // '^' → '!'
127 const negated = pch === 33;
128 if (negated) pch = p(++pi);
129 let prev = 0;
130 let matched = false;
131 do {
132 if (!pch) return ABORT_ALL;
133 if (pch === 92) { pch = p(++pi); if (!pch) return ABORT_ALL; if (tch === pch) matched = true; }
134 else if (pch === 45 && prev && p(pi + 1) && p(pi + 1) !== 93) { // range
135 pch = p(++pi);
136 if (pch === 92) { pch = p(++pi); if (!pch) return ABORT_ALL; }
137 if (tch <= pch && tch >= prev) matched = true;
138 pch = 0;
139 } else if (pch === 91 && p(pi + 1) === 58) { // [:class:]
140 const s = pi += 2;
141 for (; (pch = p(pi)) && pch !== 93; pi++) { /* shared iterator */ }
142 if (!pch) return ABORT_ALL;
143 const len = pi - s - 1;
144 if (len < 0 || p(pi - 1) !== 58) { pi = s - 2; pch = 91; if (tch === pch) matched = true; }
145 else {
146 const cls = P.slice(s, s + len);
147 const test = CLASSES.get(cls);
148 if (!test) return ABORT_ALL; // malformed [:class:]
149 if (test(tch)) matched = true;
150 pch = 0;
151 }
152 } else if (tch === pch) matched = true;
153 prev = pch; pch = p(++pi);
154 } while (pch !== 93);
155 if (matched === negated || (pathname && tch === 47)) return NOMATCH;
156 continue;
157 }
158 }
159 }
160 return ti < T.length ? NOMATCH : MATCH;
162/* oxlint-enable eslint/no-param-reassign, eslint/max-depth, eslint/complexity, eslint/no-unmodified-loop-condition */
163export const wildmatch = (pattern: string, text: string, pathname = false): boolean => dowild(pattern, 0, text, 0, pathname) === MATCH;
165// ---- dir.c: parse_path_pattern, match_basename, match_pathname ----
166const simpleLength = (s: string): number => { let i = 0; while (i < s.length && !isGlobSpecial(s.charCodeAt(i))) i++; return i; };
167function parsePattern(raw: string): Pattern {
168 let p = raw;
169 let negative = false;
170 // Stryker disable next-line MethodExpression: parseLine drops a negative pattern before this sliced text is read
171 if (p[0] === '!') { negative = true; p = p.slice(1); }
172 let len = p.length, mustBeDir = false;
173 if (len && p[len - 1] === '/') { len--; mustBeDir = true; }
174 const nodir = !p.slice(0, len).includes('/');
175 const prefix = Math.min(simpleLength(p), len);
176 const endsWith = p[0] === '*' && simpleLength(p.slice(1)) === p.length - 1;
177 return { pattern: p.slice(0, len), negative, mustBeDir, nodir, prefix, endsWith };
179function matchBasename(base: string, pat: Pattern): boolean {
180 if (pat.prefix === pat.pattern.length) return base === pat.pattern;
181 if (pat.endsWith) return pat.pattern.length - 1 <= base.length && base.endsWith(pat.pattern.slice(1));
182 return wildmatch(pat.pattern, base);
184function matchPathname(path: string, origin: string, pat: Pattern): boolean {
185 let { pattern, prefix } = pat;
186 if (pattern[0] === '/') { pattern = pattern.slice(1); prefix--; }
187 const baselen = origin.length;
188 if (path.length < baselen + 1 || (baselen && path[baselen] !== '/') || path.slice(0, baselen) !== origin) return false;
189 let name = baselen ? path.slice(baselen + 1) : path;
190 if (prefix > 0) {
191 if (prefix > name.length) return false;
192 if (pattern.slice(0, prefix) !== name.slice(0, prefix)) return false;
193 if (pattern.length === prefix && name.length === prefix) return true;
194 prefix--; pattern = pattern.slice(prefix); name = name.slice(prefix);
195 }
196 return wildmatch(pattern, name, true);
198// path_matches for a file (attributes are only ever asked of files here)
199function pathMatches(path: string, origin: string, pat: Pattern): boolean {
200 if (pat.mustBeDir) return false;
201 if (pat.nodir) return matchBasename(path.slice(path.lastIndexOf('/') + 1), pat);
202 return matchPathname(path, origin, pat);
205// ---- quote.c: unquote_c_style ----
206// quote.c's escapes, by the character after the backslash (a Map: a miss is None)
207const ESCAPES = new Map<string, number>([['a', 7], ['b', 8], ['f', 12], ['n', 10], ['r', 13], ['t', 9], ['v', 11], ['\\', 92], ['"', 34]]);
208// None: an unterminated string or a bad escape (the name is then read unquoted, as git does)
209function unquote(s: string): Option<{ readonly value: string; readonly rest: string }> { // s starts with '"'
210 let i = 1, out = '';
211 for (;;) {
212 let j = i; while (j < s.length && s[j] !== '"' && s[j] !== '\\') j++;
213 out += s.slice(i, j); i = j;
214 if (i >= s.length) return none;
215 if (s[i++] === '"') return some({ value: out, rest: s.slice(i) });
216 const ch = s.charAt(i++); // past the end: '', no escape and no digit → none below
217 const simple = mapGet(ESCAPES, ch);
218 if (simple.tag === 'some') { out += String.fromCharCode(simple.value); continue; }
219 if (ch >= '0' && ch <= '3') {
220 const d1 = s.charAt(i++);
221 const d2 = s.charAt(i++);
222 if (!(d1 >= '0' && d1 <= '7') || !(d2 >= '0' && d2 <= '7')) return none;
223 out += String.fromCharCode(((ch.charCodeAt(0) - 48) << 6) | ((d1.charCodeAt(0) - 48) << 3) | (d2.charCodeAt(0) - 48)); continue;
224 }
225 return none;
226 }
229// ---- attr.c: parse_attr_line ----
230const validName = (n: string): boolean => n.length > 0 && n[0] !== '-' && /^[-A-Za-z0-9_.]+$/u.test(n);
231// git ≥ 2.44 reserves builtin_* (builtin_objectmode): a line naming one is invalid as a whole; older git accepts it
232const reservedIn = (reserveBuiltin: boolean) => (n: string): boolean => reserveBuiltin && n.startsWith('builtin_');
233// oxlint-disable-next-line eslint/no-param-reassign -- the scan index is the result
234const span = (s: string, i: number, set: string, inSet: boolean): number => { while (i < s.length && set.includes(s.charAt(i)) === inSet) i++; return i; };
235function parseStates(s: string, reserved: (n: string) => boolean): AttrState[] | null { // any invalid state voids the line
236 const out: AttrState[] = []; let i = 0;
237 while (i < s.length) {
238 const ep = span(s, i, BLANK, false);
239 let eq = s.indexOf('=', i);
240 // Stryker disable next-line EqualityOperator,ConditionalExpression: indexOf is -1 or past the token start, and a token that starts with '=' is rejected either way
241 if (eq < 0) eq = -1;
242 // The else-if form is one statement, so a disable comment between the branches does not apply.
243 // Stryker disable next-line EqualityOperator: '=' is not blank, so it cannot sit on the exclusive end of the token
244 if (ep < eq) eq = -1;
245 // Stryker disable next-line EqualityOperator: an '=' at index 0 makes the name empty or invalid, so both comparisons reject the line
246 let name = s.slice(i, eq >= 0 ? eq : ep);
247 let value: AttrValue;
248 if (name[0] === '-' || name[0] === '!') { value = name[0] === '-' ? false : UNSET; name = name.slice(1); }
249 else {
250 // Stryker disable next-line EqualityOperator: an '=' at index 0 fails validName before this value is read, so both comparisons reject the line
251 value = eq >= 0 ? s.slice(eq + 1, ep) : true;
252 }
253 if (!validName(name) || reserved(name)) return null;
254 out.push([name, value]);
255 i = span(s, ep, BLANK, true);
256 }
257 return out;
259function parseLineWith(line: string, { macrosOk, reserveBuiltin }: ParseConfig): AttrLine | null {
260 const reserved = reservedIn(reserveBuiltin);
261 const cp = span(line, 0, BLANK, true);
262 if (cp >= line.length || line[cp] === '#') return null;
263 if (line.length >= MAX_LINE) return null;
264 let name: string;
265 let states: string;
266 const q = line[cp] === '"' ? unquote(line.slice(cp)) : none;
267 if (q.tag === 'some') { name = q.value.value; states = q.value.rest; }
268 else { const e = span(line, cp, BLANK, false); name = line.slice(cp, e); states = line.slice(e); }
269 let macro = ''; // validName: a macro's name is never ''
270 if (name.length > 6 && name.startsWith('[attr]')) {
271 if (!macrosOk) return null;
272 const rest = name.slice(6); const k = span(rest, 0, BLANK, true);
273 // Stryker disable next-line MethodExpression: the macro name token contains no blank, so this slice is the whole remainder
274 const mname = rest.slice(k, span(rest, k, BLANK, false));
275 if (!validName(mname) || reserved(mname)) return null;
276 macro = mname;
277 }
278 const parsed = parseStates(states.slice(span(states, 0, BLANK, true)), reserved);
279 if (!parsed) return null;
280 if (macro) return { macro, states: parsed };
281 const pat = parsePattern(name);
282 if (pat.negative) return null; // negative patterns are ignored in attributes
283 return { pat, states: parsed };
285// @decoder parseLine prefix=attr-line
286export function parseLine(line: string, options: ParseOptions): AttrLine | null {
287 return parseLineWith(line, withDefaults(options, parseDefaults()));
289// @decoder parseFile prefix=attr-file
290// maxFile defaults to git's 100MiB attribute-file cap. Tests pass a smaller cap so the boundary is reachable
291// without allocating that buffer on every run.
292export type ParseFileConfig = ParseConfig & { readonly maxFile: number };
293export function parseFile(file: string, options: Input<ParseFileConfig> = {}): AttrLine[] {
294 const { macrosOk, reserveBuiltin, maxFile } = withDefaults(options, { ...parseDefaults(), maxFile: MAX_FILE });
295 if (file.length >= maxFile) return [];
296 const nul = file.indexOf('\0'); const text = nul >= 0 ? file.slice(0, nul) : file; // C string
297 const lines: AttrLine[] = []; let sp = 0;
298 while (sp < text.length) { let ep = text.indexOf('\n', sp); const more = ep >= 0; if (!more) ep = text.length; const l = parseLineWith(text.slice(sp, ep), { macrosOk, reserveBuiltin }); if (l) lines.push(l); sp = ep + (more ? 1 : 0); }
299 return lines;
301const BUILTIN_FILE = parseFile(BUILTIN, { macrosOk: true });
303// Attributes of `path` (byte string, no trailing slash) given the .gitattributes texts by directory:
304// files: Map(dir byte string → file text byte string), '' for the root. Returns Map(name → true | false | null | string).
305// The built-in frame's origin is never read (it holds only the macro); '' keeps the frames one type.
306export type AttributesConfig = { readonly reserveBuiltin: boolean };
307export function attributesFor(path: string, files: ReadonlyMap<string, string>, options: Input<AttributesConfig> = {}): Map<string, AttrValue> {
308 const { reserveBuiltin } = withDefaults(options, { reserveBuiltin: true });
309 const frames: Array<{ readonly origin: string; readonly lines: readonly AttrLine[] }> = [{ origin: '', lines: BUILTIN_FILE }];
310 const dirs = ['']; const last = path.lastIndexOf('/');
311 for (let i = path.indexOf('/'); i >= 0 && i <= last; i = path.indexOf('/', i + 1)) dirs.push(path.slice(0, i));
312 for (const d of dirs) { const text = mapGet(files, d); if (text.tag === 'some') frames.push({ origin: d, lines: parseFile(text.value, { macrosOk: d === '', reserveBuiltin }) }); }
313 // determine_macros: the most specific definition wins (frames top-down, lines bottom-up)
314 const macros = new Map<string, readonly AttrState[]>();
315 for (const { lines } of frames.toReversed()) for (const l of lines.toReversed()) if ('macro' in l && !macros.has(l.macro)) macros.set(l.macro, l.states);
316 const out = new Map<string, AttrValue>();
317 const fillOne = (states: readonly AttrState[]): void => {
318 const todo = [...states];
319 for (let s = popLast(todo); s.tag === 'some'; s = popLast(todo)) {
320 const [name, value] = s.value;
321 if (out.has(name)) continue;
322 out.set(name, value);
323 if (value === true) todo.push(...getOrElse(mapGet(macros, name), []));
324 }
325 };
326 // the built-in frame holds only a macro, which fills nothing
327 for (const { origin, lines } of frames.toReversed()) for (const l of lines.toReversed()) if ('pat' in l && pathMatches(path, origin, l.pat)) fillOne(l.states);
328 return out;
330// None: never mentioned. Some(null): explicitly unspecified ('!attr').
331export const attributeOf = (attrs: ReadonlyMap<string, AttrValue>, name: string): Option<AttrValue> => mapGet(attrs, name);
Diagnostics4 git calls · 24 ms
CallStatusSizeTime024 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 · 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 · hit1 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=1
git.response.bytes=38434
git.response.cache=HIT
git.response.duration_ms=1
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.5 KiB · hit20 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=20
git.response.bytes=6657
git.response.cache=HIT
git.response.duration_ms=20
git.fetch.wants=15ddff7ee52d0dbf3427de709f22b1a5dadd700d
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=6657
git.pkt.payload.max=6636
git.sideband.band1.bytes=6635
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
a5e2c7b0bc454afc
Request
0302bdac…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format