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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
//! **THE NAMING CONSTITUTION** — the roster every wire name in this framework is derived from, and
//! the three laws that decide what a name looks like.
//!
//! # Law one: the roster is the framework's OWN vocabulary, and it is Rust-flavoured
//!
//! The default SDL scalar roster is the Rust widths, spelled the way Rust spells them:
//!
//! | Rust type | carrier | SDL scalar | derived filter | wire form |
//! |---|---|---|---|---|
//! | `u8` `u16` `u32` | [`U8`](super::scalar::U8) [`U16`](super::scalar::U16) [`U32`](super::scalar::U32) | `u8` `u16` `u32` | `U8Filter` … | JSON number |
//! | `i8` `i16` `i32` | [`I8`](super::scalar::I8) [`I16`](super::scalar::I16) [`I32`](super::scalar::I32) | `i8` `i16` `i32` | `I8Filter` … | JSON number |
//! | `u64` `u128` | [`U64`](super::scalar::U64) [`U128`](super::scalar::U128) | `u64` `u128` | `U64Filter` `U128Filter` | number ≤ 2^53−1, else decimal text |
//! | `i64` `i128` | [`I64`](super::scalar::I64) [`I128`](super::scalar::I128) | `i64` `i128` | `I64Filter` `I128Filter` | number ≤ 2^53−1, else decimal text |
//! | `f32` `f64` | [`F32`](super::scalar::F32) [`F64`](super::scalar::F64) | `f32` `f64` | `F32Filter` `F64Filter` | JSON number |
//! | `half::f16` | [`F16`](super::scalar::F16) | `f16` | — | JSON number |
//! | `rust_decimal::Decimal` | [`F128`](super::scalar::F128) | `f128` | — | decimal text |
//! | `bytes::Bytes` | [`HexBytes`](super::scalar::HexBytes) | `bytes` | `BytesFilter` | lowercase hex text |
//! | `Vec<u8>` ‡ | [`U8Vector`](super::scalar::U8Vector) | `U8Vector` | `U8VectorFilter` | lowercase hex text |
//! | `smol_bytes::Bytes` ‡ | [`SmolBytes`](super::scalar::SmolBytes) | `SmolBytes` | `SmolBytesFilter` | lowercase hex text |
//! | `[u8; N]` ‡ | [`FixedU8Array<N>`](super::scalar::FixedU8Array) | `Fixed{N}U8Array` | `Fixed{N}U8ArrayFilter` | lowercase hex text |
//! | `std::net::Ipv4Addr` ‡ | [`NetIpv4Addr`](super::scalar::NetIpv4Addr) | `Ipv4Addr` | `Ipv4AddrFilter` | the dotted quad |
//! | `std::net::Ipv6Addr` ‡ | [`NetIpv6Addr`](super::scalar::NetIpv6Addr) | `Ipv6Addr` | `Ipv6AddrFilter` | RFC 5952 canonical text |
//! | `std::net::IpAddr` ‡ | [`NetIpAddr`](super::scalar::NetIpAddr) | `IpAddr` | `IpAddrFilter` | either version's own text |
//! | `std::net::SocketAddrV4` ‡ | [`NetSocketAddrV4`](super::scalar::NetSocketAddrV4) | `SocketAddrV4` | `SocketAddrV4Filter` | `"192.0.2.1:443"` |
//! | `std::net::SocketAddrV6` ‡ | [`NetSocketAddrV6`](super::scalar::NetSocketAddrV6) | `SocketAddrV6` | `SocketAddrV6Filter` | `"[2001:db8::1]:443"` |
//! | `std::net::SocketAddr` ‡ | [`NetSocketAddr`](super::scalar::NetSocketAddr) | `SocketAddr` | `SocketAddrFilter` | either version's own text |
//! | `uuid::Uuid` ‡ | [`HyphenatedUuid`](super::scalar::HyphenatedUuid) | `Uuid` | `UuidFilter` | RFC 9562 lowercase hyphenated text |
//! | `regex::Regex` ‡ § | `RegexPattern` | `Regex` | `RegexFilter` | the PATTERN, verbatim |
//! | `core::num::NonZero*` ‡ | the WIDTH's own carrier | — | `NonZero{Width}Filter` | the width's own form |
//! | [`Count`](crate::Count) ‡ | [`U64`](super::scalar::U64) | — | `CardinalityFilter` | `u64`'s own form |
//!
//! ‡ NAMED vocabularies rather than roster rows — Pascal, and outside `roster()`'s own table. They
//! are listed here because a reader looking up a byte or address column looks in one place.
//!
//! § Behind a cargo feature, so its carrier is named in plain text rather than linked: a link would
//! resolve in some builds and not others, which is exactly what a table read by everyone must not
//! do. `regex::Regex` rides `regex`.
//!
//! **The [`Count`](crate::Count) row mints no scalar either**, and for the `NonZero` family's reason
//! read at a different kind of hole: what the newtype states is a PROVENANCE — *this magnitude
//! counted rows that exist* — which is a fact about where a value came from rather than about which
//! values are legal, so there is nothing for a second scalar to say and nothing for a crossing to
//! refuse. It publishes `u64`, and what the type buys is on the STORAGE side, where the provenance
//! is what lets a cardinality narrow into an `i64` on the two dialects with no unsigned 64-bit
//! column.
//!
//! Its FILTER name is the one exception to law one in this table: `Count` is a named type and would
//! wear `CountFilter`, and that name belongs to the PROTOCOL's own cardinality slot over `usize`
//! (law two, `Int`). Two Rust types under one GraphQL name is a `Registry::create_type` panic, so
//! the declared operand takes the other true word for what it is. `graphql::tests::wire` builds a
//! schema holding both.
//!
//! **The `NonZero` row is the one that mints no scalar of its own**, and that is the 2026-08-25
//! completeness ruling: each of the ten widths crosses on its UNDERLYING integer's roster scalar, so
//! `NonZeroU32Filter { eq: u32 }` sits beside `U32Filter { eq: u32 }` and the two publish one wire
//! form under two names. What the second name carries is the DOMAIN HOLE — a GraphQL scalar has no
//! place to state one — and what enforces it is the crossing, which refuses `0` by name through
//! [`ZeroOperand`](crate::ZeroOperand). The rows read `Int` before that ruling, which stated neither
//! the width nor the refusal; the two 128-bit widths had no wire face at all, async-graphql's
//! `non_zero_integers.rs` stopping at 64 bits exactly as its plain integers do.
//!
//! **A filter's input-object name DERIVES from the scalar name** — `UpperCamel(scalar) + "Filter"`,
//! so `u32` publishes `U32Filter` and `f32` publishes `F32Filter`. The law runs over the rows that
//! HAVE a filter, which is not every row: `f16` and `f128` carry a dash in the column above and
//! publish no input object at all, a declaration having no way to name either width as a column
//! type yet — so no schema this crate builds holds an `F16Filter`. The scalar itself stays
//! Rust-flavoured and lowercase, because that is where the information is; its filter is an input
//! OBJECT, and a type name in a schema is Pascal like every other one — `NonZeroI32Filter` and
//! `TimestampFilter` are the neighbours it has to read beside.
//!
//! The derivation runs inside the table's own macro rather than as a second literal, which is what
//! makes the row the single place either name is written: a row that renamed its scalar and forgot
//! its filter is not a state this file can be left in. `concat!` cannot raise a case, so the
//! mechanism is a `const fn` over the name's bytes — see `scalar::derived_filter`.
//!
//! **The byte row's operand is `bytes::Bytes`, and that is the DEFAULT BYTE HOUSEHOLD ruled on
//! 2026-08-18.** `Vec<u8>` held this row and derived its name from it; it is a NAMED vocabulary now
//! — `U8VectorFilter`, the growable twin of `Fixed{N}U8ArrayFilter` — and the crate that supplies the
//! new default operand is a REQUIRED dependency, because a default roster row cannot sit behind a
//! feature.
//!
//! # EVERY BYTE HOUSEHOLD MINTS ITS OWN SCALAR, ruled 2026-08-19
//!
//! The named vocabularies crossed under the roster's own `bytes` until that date, so a schema
//! published `U8VectorFilter { eq: bytes }` — an input object naming one household over an operand
//! naming another, readable only by someone who already knew the two words described one wire form.
//! Each household publishes its own name for that form now: `U8Vector` for a `Vec<u8>` column,
//! `SmolBytes` for `smol_bytes::Bytes`, `Fixed{N}U8Array` at each width, and `bytes` for the
//! roster's own row.
//!
//! **The WIRE FORM did not move and cannot**: every one of those scalars is a thin newtype skin
//! delegating to ONE reader and ONE renderer — `scalar::read_hex` and `scalar::nibbles` — so the
//! households differ in NAME and in nothing else. A second grammar is not expressible without
//! writing one, which is the property the single kernel exists to hold.
//!
//! The scalars are Pascal because law three puts a named vocabulary there; `bytes` stays lowercase
//! because it is the roster's own row. And the OUTPUT MIRROR moved with them — a field of a `Vec<u8>`
//! column publishes `U8Vector!` where its filter's operand publishes `U8Vector`, the two directions
//! never disagreeing about one column.
//!
//! The wrapping axes compose ON TOP of the derived name and are not part of the derivation:
//! `Nullable` before it, `List`/`Set` between operand and `Filter`. So `Option<u64>` publishes
//! `NullableU64Filter` and `Vec<i16>` publishes `I16ListFilter`, a wrapper being a modifier on a
//! name the scalar owns rather than a name of its own.
//!
//! # The WIDTH decoration, which is the same law over the byte kinds
//!
//! A fixed-width byte column's filter takes one more modifier, and it is the only one carrying a
//! NUMBER: [`FixedBytesFilter`](crate::FixedBytesFilter) puts `Fixed{N}` in front of the reading's
//! name. So `[u8; 16]` publishes `Fixed16U8ArrayFilter`, `Option<[u8; 32]>` publishes
//! `NullableFixed32U8ArrayFilter`, and a blob of the same reading publishes the undecorated name
//! through [`BytesFilter`](crate::BytesFilter).
//!
//! It is the wrapper law applied to a type parameter that happens to hold a width, and it is
//! assembled in ONE place — that filter's own wire face — for the reason every other derivation is:
//! a second literal per width is a second thing to keep in step, and there is no bound on how many
//! widths a declaration will name.
//!
//! The decoration is also what makes the two byte kinds two SCHEMA TYPES. One reading over one
//! operand used to give one name across both, so a schema reaching a fixed column and a blob of the
//! same reading met `Registry::create_type`'s panic; two names cannot collide, and the pair stopped
//! being expressible rather than merely unreachable.
//!
//! The two kinds also publish two FIELD LISTS, which the shape parameter they replaced could not:
//! ten for a blob and eight for a fixed-width column, `contains`/`notContains` being the pair no
//! dialect has a form for at a fixed width. A door that always refused is not published.
//!
//! # Law two: the GraphQL standard five are a NAMED READING, not the default
//!
//! `Int`, `Float`, `String`, `Boolean` and `ID` remain reachable; what `Int` and `Float` are not is
//! what a field gets by saying nothing. [`Std`](super::carrier::Std) is the reading a field NAMES to
//! get those two, and its rows sit beside [`Builtin`](super::carrier::Builtin)'s over the same
//! operands: `ScalarFilter<i32, Std>` publishes `IntFilter { eq: Int }` where `ScalarFilter<i32>`
//! publishes `I32Filter { eq: i32 }`, and both can stand in ONE schema because they are two names.
//!
//! `String` and `Boolean` are reachable WITHOUT naming the reading, because the default already
//! publishes them: those two operands are not roster rows at all (see below), so `TextFilter<String>`
//! is `StringFilter { eq: String }` and the boolean kind is `BooleanFilter { eq: Boolean }`. A `Std`
//! row over either would be a second Rust type under a name the default holds, which
//! `Registry::create_type` answers with a panic — so the reading and the default are ONE row each.
//! `ID` is still missing; see [`Std`](super::carrier::Std) for the table of five.
//!
//! Unspoken is law one. That ordering is the whole point of the constitution: async-graphql spells
//! ten Rust integer widths `Int` and both float widths `Float`, so the library's default answered
//! *this is a number* and a schema could not say which one — the silence this framework declines to
//! inherit.
//!
//! # Law three: CASE IS THE HOUSEHOLD REGISTER
//!
//! Lowercase is the framework's own defaults, Pascal is a NAMED type:
//!
//! - lowercase — every roster SCALAR above, and nothing else.
//! - Pascal — every FILTER, the roster's own included (`U32Filter`); `Score`, `Timestamp`,
//! `NonZeroI32Filter`, `DateTimeFilter`, `Fixed16U8ArrayFilter`, `Ipv4Addr`, `SocketAddrV6`; and
//! every name a declaring crate mints for a type of its own.
//!
//! The register is about the SCALAR vocabulary, which is where a lowercase word says *this is the
//! framework's own reading of a Rust width*. A filter is an input object and its name is a type name
//! in a namespace that has no lowercase citizens, so the round that spelled the filters lowercase is
//! what the 2026-08-18 amendment retired.
//!
//! It is a CONVENTION and this file is where it is written down. **There is no syntactic guard**: a
//! declaring crate may mint a lowercase name, and that space is simply unmanaged — its own
//! responsibility. What settles a collision is the schema-compile layer that is coming, generally,
//! for every pair of types that claim one name; a reservation refusal here would answer one case of
//! that and pretend to answer the rest.
//!
//! The register is also why the old `Vec<u8>`-versus-`bytes::Bytes` name clash does not exist, and
//! it is settled three times over: two derived FILTER names — `BytesFilter` for the roster's own row
//! and `U8VectorFilter` for the named vocabulary beside it — two SCALAR names under them since
//! 2026-08-19, and the case register telling a lowercase roster row from a Pascal named one at a
//! glance.
//!
//! # THE ROSTER ONLY HOUSES WORDS THAT CARRY INFORMATION, which is why `string` and `bool` are gone
//!
//! Ruled 2026-08-18. A lowercase row exists because GraphQL's own vocabulary is SILENT about
//! something a client needs: `Int` spells ten Rust integer widths and `Float` spells two, so `u32`
//! and `f16` say which one; a list of small integers says nothing about a byte shape, so `bytes` and
//! `Fixed16U8Array` do. Text and booleans have no such silence to end — `String` IS the spec's name
//! for exactly this operand and `Boolean` for exactly that one — so a lowercase `string` beside
//! `String` would be a second spelling of one fact, bought at a real price.
//!
//! **The price is the CARRIER, and it is the reason those rows could never be more than names.** A
//! carrier owns its value ([`ScalarType::parse`] hands back a `Self`) and is also what a RESOLVER
//! returns, so minting `string` would make the output row of every text column an owned copy where
//! `String`'s is `&'a String` today. Every text field of every row of every response would pay for
//! it: a semantic change riding in on a naming one, which the scalar suite's own law forbids. And
//! the output mirror law forbids the other way out — publishing `string` on input and `String` on
//! output would be the two directions disagreeing about one column.
//!
//! `bool` would not have paid that — a `bool` is a register — but it has the same nothing to say,
//! and one more structural reason beside it: [`BooleanFilter`](crate::BooleanFilter) is the ONE kind
//! with no carrier axis, four slots and no type parameter, so a lowercase operand there means giving
//! the KIND a parameter rather than giving a row a name.
//!
//! So both rows retire from the table, their filters are the canonical `StringFilter` and
//! `BooleanFilter`, and law two's rows for them are the DEFAULT's — one name per operand, which is
//! what `ingraph/tests/half_roster.rs` pins against a built schema.
//!
//! # What the roster does NOT hold
//!
//! `ID` has no row in either half: GraphQL's is a string-or-int a server may spell how it likes, and
//! which Rust type this framework's ID is has not been decided.
//!
//! **The rest of this section is the 2026-08-25 completeness round's own accounting**, written here
//! because a type with no row is a thing a reader has to be able to look UP. Each entry is a
//! decision with a reason, not a gap waiting to be filled in silence.
//!
//! ## `std::path::PathBuf` and `Path` — REFUSED, and the refusal is about the DOMAIN
//!
//! A path is not text. On Unix it is an arbitrary byte string with no encoding promise and on
//! Windows it is a sequence of 16-bit units that need not be valid UTF-16, so there are real paths
//! no GraphQL `String` can carry — and GraphQL's `String` is defined as a sequence of UTF-8
//! characters, with no escape for the ones that are not. A row here would therefore have exactly
//! two possible shapes and both are refused: a LOSSY one that renders `to_string_lossy` and hands a
//! client a path that does not open, or a REFUSING one whose column is silently unreadable for the
//! rows that happen to hold a non-UTF-8 name — a schema that works until the day it does not.
//!
//! The house answer is to make the decision AT THE DECLARATION instead: a field that holds a path a
//! client is meant to read declares `String` or `smol_bytes::Utf8Bytes` and carries the UTF-8
//! guarantee in its own type, where the conversion's failure is handled once by code that knows what
//! the path is for; a field that holds an OPAQUE path declares a byte vocabulary and crosses as hex.
//! Both are rows this roster already has, and both say what they are.
//!
//! ## `core::time::Duration` and `std::time::SystemTime` — REFUSED, one clock vocabulary
//!
//! `jiff` is this crate's time authority: [`Timestamp`](crate::Timestamp) is the framework's own
//! instant, `DurationFilter` is the elapsed kind, and the four `jiff` rows are the declarable
//! temporal vocabulary. A second family under `Duration` and `SystemTime` would put TWO
//! interchangeable spellings of one fact in one schema — a client meeting `Duration` beside
//! `Duration` (jiff's) would have to learn which resolution and which sign convention each carries,
//! and a declaration would have to choose without the choice meaning anything.
//!
//! That is not a claim that the std types are worse. It is that COMPLETENESS in a vocabulary is not
//! the union of every type that could be spelled: a second word for the thing the first word names
//! is a hazard, and the roster's own first law — a row exists to carry information the wire lacks —
//! rules it out from the other side. A declaration holding a `std::time::Duration` converts at its
//! own boundary, which is one `SignedDuration::try_from` away.
//!
//! ## `char` — no row, and no demand
//!
//! A `char` is a Unicode scalar value, which GraphQL's `String` carries exactly (a one-character
//! string) — so a row would be a length-one refusal over a form the wire already has, and nothing in
//! this workspace declares one. Recorded as a DOOR rather than argued shut: it costs one carrier and
//! one refusal the day something asks, and the refusal is honest (a two-character string is not a
//! `char`).
//!
//! ## `NonZeroUsize` and `NonZeroIsize` — no row, for `usize`'s own reason
//!
//! The `NonZero` family is the ten FIXED widths and stops there. A pointer-width row would advertise
//! a range that changes with the target, so the roster deliberately spells no `usize` scalar for it
//! to cross on — see the cardinality note in [`carrier`](super::carrier), where the whole of that
//! argument is. A declaration that wants a non-zero count names `NonZeroU64` and means one thing on
//! every target.
//!
//! ## `&'static str` — an OUTPUT row and NO input twin, which is the door door (b) leaves ajar
//!
//! [`ToGraphqlOutput`](crate::ToGraphqlOutput) has a row for it: a static string is what a
//! declaration holds when the value is the PROGRAM's rather than the row's, and it publishes as
//! ordinary text with no clone. [`ToGraphqlInput`](crate::ToGraphqlInput) has none and CANNOT: an
//! operand arrives as a `String` built at parse time, and nothing turns one into a `'static` borrow
//! but a leak a client would be driving or an interning table this crate would have to own.
//!
//! **What that costs is measured rather than guessed**, and the measurement is
//! `ingraph/tests/base_type_roster.rs`: the graphql activation asks each published column for a
//! FILTER as well as a face, so a declared `&'static str` FIELD does not activate — the honest shape
//! is a field whose value the declaration computes, or a `String`/`SmolStr` column where the value
//! is the row's. A filter row for it would have to be a `TextWire<&'static str>` whose `cross`
//! cannot be written, so none is faked.
//!
//! ## `uuid::Uuid` HAS a row now, and it is the one that arrived with BOTH halves
//!
//! It is listed with the ‡ vocabularies above rather than absent from this section, and it is worth
//! a sentence here because it is the counter-example the two paragraphs below are read against. The
//! address family reaches a schema and no dialect; the uuid row reaches BOTH, and the reason is that
//! the per-backend question the addresses are still waiting on has an answer for a uuid that every
//! backend already agrees with — sixteen fixed bytes, held natively by all four and compared the same
//! way by all four. Ruled 2026-08-29, one backend at a time and then held against each other in
//! [`StoredAs`](crate::StoredAs)'s own module.
//!
//! Its wire form is TEXT while its stored form is BYTES, and that split is deliberate: the canonical
//! hyphenated spelling is what a client already writes, and the sixteen bytes are what an index
//! wants. See [`HyphenatedUuid`](super::scalar::HyphenatedUuid), whose Rust NAME is the one place
//! this file's carrier-naming rule had to be read for its purpose — `uuid` + `Uuid` collides with
//! itself — and `graphql::scalar`'s module note, where that is written down.
//!
//! ## `regex::Regex` HAS a row too, and it is the first whose CROSSING is a compile
//!
//! Listed with the ‡ vocabularies above, and it reaches BOTH ends like the uuid row: a schema and
//! every dialect. What makes it worth its own paragraph is that reading one is WORK. Every other row
//! in this file parses a fixed grammar; this one builds an automaton, so `parse` can fail for
//! reasons no grammar table lists, `is_valid` costs a compile it then throws away, and the stored
//! column is re-compiled on the way back — see `PatternColumnError` in `column::assemble`, which is
//! where a stored pattern that no longer compiles refuses by name.
//!
//! Its wire form and its stored form are the SAME text, where the uuid row splits them. That is not
//! an inconsistency but the same rule applied: a uuid's bytes are what an index wants and its text
//! is what a client writes, and a pattern has no second representation at all — the automaton is a
//! build product, machine-shaped and meaningless to a client, so the pattern is the value on both
//! sides.
//!
//! **It CANONICALISES NOTHING**, and it is the only named-text row here that does not. A uuid folds
//! four spellings into one and an IPv6 address folds many into RFC 5952; `(?i)a` and `[aA]` accept
//! the same strings and stay two values, two rows and two answers to `eq`. `regex` keeps the pattern
//! verbatim, and no fold this crate could write would be the engine's.
//!
//! **Its filter is `scalar` where its column is TEXT**, which is the one place in this file a
//! family word does not follow a column's shape. The text family's affix operators are unreachable
//! for this operand: the two `LIKE` dialects and mongo derive a pattern from the operand's own
//! characters and demand `V: AsRef<str>` for it, which `regex::Regex` has not got and cannot be
//! given here — both the trait and the type are foreign, so the impl is `E0117`. The bound is
//! all-or-nothing, so a text filter over a pattern column would have lowered on SQLite and on no
//! other backend. Eight ordering operators on four backends is the honest trade, and the affix
//! family is a recorded DOOR: the three lowerings could take a trait of this crate's own carrying
//! `fn as_text(&self) -> &str`, and a pattern column would join the text family the day they do.
//! See `graphql::filter`'s own row, where the measurement is.
//!
//! **AND THE DECLARATION ROAD IS WALLED.** A `#[ingraph::record]` cannot hold a pattern column
//! today: the emission derives `PartialEq` on the per-dialect row struct and on the cursor sum, both
//! of which carry the declared field types, and `regex::Regex` has no `PartialEq` to give. That is a
//! ruling about every record in every downstream crate rather than a row in this file — see
//! `ingraph/tests/regex_citizen.rs`, whose module note carries the two sites and the measurement.
//!
//! ## The NETWORK family has no STORAGE row, and that is a per-dialect ruling this round did not make
//!
//! The six address types reach a schema — scalar, filter, both crossings, collections — and reach no
//! dialect: there is no `Carrier`, no `Assemble` and no comparison lowering for any of them, so a
//! declared column of one is a wire type and not yet a stored one. The reason is that the choice is
//! real: TEXT is portable and sorts wrong, a fixed 4/16-byte column sorts right and needs a
//! per-version decision, and Postgres has an `inet` of its own that neither of the others can use.
//! One ruling per dialect, when a declaration asks.
//!
//! **CIDR and prefix questions are a second door of the same round.** `gte`/`lte` over an address
//! already expresses a subnet — every address under a prefix is a contiguous range — so the case
//! that motivated the family is answered by the ordering vocabulary it has. A dedicated
//! `inSubnet: "10.0.0.0/24"` operand is a second grammar to parse and a prefix arithmetic to
//! implement at each width, and it is not built.
//!
//! # The one row whose BACKING is temporary
//!
//! `f128` is the roster's name for the widest float row and Rust's own `f128` is not stable, so the
//! seat is held by `rust_decimal::Decimal` — an exact BASE-TEN type and not IEEE binary128. The NAME
//! is law one's and is meant to outlive the backing; what a client is told about the backing is the
//! scalar's own description, which says in as many words that the row is a decimal rather than a
//! binary float. When Rust's `f128` stabilises the row changes its operand and keeps its name.
//!
//! The named vocabularies are outside the roster by construction rather than by omission —
//! `Timestamp`, the ten `NonZero` widths, the six ADDRESS types, the cardinality `usize` and jiff's
//! four instants are Pascal rows of [`Builtin`](super::carrier::Builtin)'s, each named for what it
//! IS rather than for a width the roster spells.
//!
//! The address family is where that distinction was last tested, and the mechanism decided it as
//! well as the law: `capitalised` raises ONE byte, so a lowercase snake row (`ipv4_addr`) would
//! derive `Ipv4_addrFilter` and the filter name would have to become a second literal — the one
//! thing the derivation exists to prevent. A named type wearing its own name derives its own filter
//! out of the same literal, at no cost and with no case to raise.
//!
//! [`ScalarType::parse`]: https://docs.rs/async-graphql/7/async_graphql/trait.ScalarType.html
// The module's LAW is unconditional prose; its INVENTORY is not. What a row holds is what
// async-graphql publishes for a type, which is a question a build with no wire library has not got —
// and the consistency test is the only caller, so the runtime half rides `test` as well as the
// binding rather than shipping a table nothing reads.
/// ONE roster row, as the emission-consistency test reads it.
///
/// The three name columns are the literals the table's own macro expanded, and the two `fn` columns
/// are the SDL the BINDING actually emits for that row's types — so an assertion between them is the
/// table against the schema rather than one list against another list.
///
/// `filter` and `filter_face` are `Option` together: [`F16`](super::scalar::F16) and
/// [`F128`](super::scalar::F128) are scalars with no filter of their own, a declaration having no
/// way to name either width as a column type yet.
pub
/// Every MINTED roster row, the optional widths included where their word is on.
///
/// The minted half is what a `Row` can be built from: its two `fn` columns read a face off a
/// CARRIER, and the table's two ‡ rows (`string`, `bool`) have none. Their names are pinned against
/// a built schema in `ingraph/tests/half_roster.rs` instead — which is the same claim made the only
/// way those two rows can make it.
///
/// A `Vec` rather than one flat const because a row behind a cargo feature cannot be an ELEMENT of a
/// const array — an attribute has no position there — so the gates are spent here, once each, where
/// a reader sees the whole roster on one screen.
pub