1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
//! [`BlobLocation`] — A citizen of [`AsyncLocate::Location`](super::AsyncLocate::Location), and never THE law.
use Utf8Bytes;
use crateToGraphqlOutput;
/// WHERE a blob is, in the shape a backend with nothing more to say elects.
///
/// # It is A citizen of the seat, not the seat's definition
///
/// [`AsyncLocate::Location`](super::AsyncLocate::Location) is BARE: the backend defines what a location IS,
/// and a store that knows an etag, a generation, a bucket or a signed expiry writes its OWN type
/// carrying them. This one exists so that a backend which knows only the address — the shipped
/// filesystem store is exactly that — does not have to mint a struct to say so, and so that the
/// crate has one worked example of a location crossing the wire.
///
/// Nothing here is privileged. No framework path asks for this type, no bound names it, and a
/// backend electing its own pays nothing for declining it. That is the whole difference between a
/// convenience and a law, and it is why the seat above carries no bound: a bound would have made
/// this shape the only shape.
///
/// # The ADDRESS is text, and the rest is optional because a pure render cannot invent it
///
/// [`address`](Self::address) is the one member that is always there — it is the part a client
/// round-trips, and it is the part derivable from the key alone.
/// [`size`](Self::size) and [`content_type`](Self::content_type) are `Option`, and the reason is
/// [`AsyncLocate::location`](super::AsyncLocate::location)'s pin rather than modesty: describing an address
/// does NO I/O, so a fact only a `stat` or a `HEAD` could supply is a fact this type reports as
/// absent. A backend that already holds one — because its manifest carries it, or because its
/// listing returned it — fills it in; the shipped filesystem store does not, and leaves both unsaid.
///
/// A member that is structurally unknowable to one backend and ordinary to another is exactly what
/// `Option` is for, and it is why those two are not on the [`AsyncLocate`](super::AsyncLocate) seat itself.
// The wire face, hand-written for the reason `ingraph-codegen`'s `emit::wire` writes its own: a
// derive would publish this type's rustdoc as schema descriptions, and a description is a schema
// commitment rather than a side effect of documenting Rust.
//
// Which is also why this note is `//` and not `///`. `#[Object]` calls `get_rustdoc` on the BLOCK
// and on every method with no key to decline it, so a doc comment here does not document the impl —
// it publishes itself into the SDL as `type BlobLocation`'s description. Measured, by reading a
// schema that had one.
//
// The method idents wear `__async_graphql_` and every field spells `#[graphql(name = "…")]`, which
// is the ruled pin AND, here, forced twice over: an `async fn address` in this block would be a
// second definition of the inherent `address` above (`E0592`), and the library's own camelCase
// fallback over a prefixed ident would publish `asyncGraphqlAddress` — a name no client wants to
// read, and the reason layer 3 is written out on every field rather than on the renamed ones.
//
// The prefix names the BACKEND, per the ruling of 2026-08-13, so a second GraphQL binding on this
// same type mints `__smear_address` beside these three and neither face is the reason the other
// cannot be written. `ingraph-codegen`'s `method::wire_method` is the emitted half's one door; this
// is the library's own face wearing what it emits.
/// The OUTPUT CROSSING: a location is returned BY REFERENCE, the identity row every type that
/// already has a wire face takes.
///
/// The row lives beside the type rather than in
/// [`graphql::output`](crate::ToGraphqlOutput)'s own table because it is what a BACKEND's location
/// row will look like — the trait is `ingraph`'s and the type is the implementer's, so the impl is
/// ordinary local work with no orphan rule anywhere near it. That this crate's own citizen writes
/// exactly the row a third party writes is the point.