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
//! WHAT THE DOORS EMIT AROUND `k` — the ONE currency they now carry, the fork that is GONE, and the
//! two boundaries where a non-zero number is spent back into a plain `usize`.
//!
//! Beside [`by_key`](super::by_key) and [`similar_set`](super::similar_set) on this directory's own
//! precedent: one file per thing being proved. What only a token reading can prove is a TYPE and an
//! ABSENCE — the framework suite runs the doors and can see what they answer, but *no conversion is
//! written anywhere in this emission* is a fact about the emitted text.
//!
//! # The claim this file used to make, and the one it makes now
//!
//! It used to assert an ORDER: the doors kept `limit : usize`, each body forked a zero into an early
//! empty answer, and where that fork sat relative to a door's own by-key read was the difference
//! between a named refusal and a silent empty page. Every one of those assertions was about a branch.
//!
//! The currency is `NonZeroUsize` now, door-family-wide, so *ask for nothing* is not a request a
//! caller can compose and the branch has nothing left to decide. What is asserted here instead is the
//! SIGNATURE — because a type is what replaced the branch — and the ABSENCE of the conversion, which
//! is what says the fork was deleted rather than relocated.
//!
//! # The two `usize` boundaries are asserted TOO, and they are not a leak
//!
//! `ranked_keys` / `ranked_keys_excluding` / `set_scored` / `filled` count SURVIVORS, and a walk asked
//! for nothing is a legal call with an empty answer where an ENGINE asked for nothing is not a
//! question at all. So the runtime walks keep a plain `usize` and the doors spend `NonZeroUsize::get`
//! at the crossing. Asserting the spelling is what keeps the two currencies from being confused back
//! into one.
use ;
/// The DOOR CURRENCY, spelled as the emitted tokens spell it.
const CURRENCY: &str = "limit : :: core :: num :: NonZeroUsize";
/// The conversion the retype DELETED — the zero fork, in the only spelling any door ever wrote it in.
const FORK: &str = "NonZeroUsize :: new (limit)";
/// The emission's tokens as text — the gate-blind reading, the doors living inside the observation
/// gate pair.
/// The same model with its election relabelled a SET, which is what the two `_with` doors hang off.
/// One door's own tokens, cut at the next item — signature, `where` clause and body, and none of the
/// neighbour's docs.
///
/// The cut matters here for the reason it matters in [`by_key`](super::by_key): an assertion about a
/// door's own text that ran into the next door's prose would answer about a sentence rather than
/// about a statement.
/// EVERY DOOR OF THE FAMILY that takes a budget, counted rather than sampled — the vector side's five
/// under a SET election, and the full-text side's four.
/// **THE DOOR FAMILY CARRIES ONE CURRENCY, AND IT IS THE SEAM'S** — asserted over the whole roster
/// rather than over a door somebody remembered.
///
/// The negative half is what makes it a claim: a `limit : usize` anywhere in the family is a door
/// that still admits a number the engine below it cannot be handed, which is the two-seat disease the
/// k-seat round cured from the other side.
/// **THE ZERO FORK IS GONE FROM THE WHOLE EMISSION**, which is the difference between deleting a
/// branch and moving one.
///
/// The subject is the EMISSION and not a door, deliberately: a fork that survived anywhere — pushed
/// into a helper, hidden in one arm of a fanned leg — would satisfy a per-door assertion and would
/// still mean the type had not been trusted. There is exactly one spelling any door ever wrote this
/// in, and this says the emission contains none of it.
///
/// MUTATION-CHECKED: put back the `match NonZeroUsize::new(limit)` any one door used to open with,
/// and this reds while every behavioural test stays green — which is the whole of what an absence
/// needs a token reading for.
/// **THE UNBOUNDED ASK IS SPELLED IN THE FAMILY'S OWN CURRENCY.**
///
/// Tier B asks tier A for every above-floor key, because its own fill loop's filter is what decides
/// how many of them fill a page. That ask used to be `usize::MAX`; it is `NonZeroUsize::MAX` now, and
/// the SEMANTICS are unchanged — a huge `k` means *as many as exist*, and what it costs is the
/// engine's business in its own storage.
/// **THE WALKS KEEP `usize`, AND THE DOORS SPEND THE NON-ZERO NUMBER AT THE CROSSING.**
///
/// A walk counts SURVIVORS — a walk asked for nothing is a legal call with an empty answer — so the
/// runtime helpers were not retyped, and the boundary is written out at each door that reaches one.
/// The assertion is the spelling, because the alternative that compiles is a door that quietly
/// retyped a walk and made *nothing survived* unrepresentable too.
/// **THE FULL-TEXT DOOR TAKES THE SAME SEAT**, at both grains its subject comes in.
///
/// The whole-subject door and a per-column one are two subjects and one law, so the `k` they hand
/// `search` sits between the query text and the knobs in both — which is the parameter law read off
/// the emission rather than off the trait. It is the door's own `limit` that arrives there now, with
/// nothing in between, and the knobs beside it are the door's own `options` rather than the fixed
/// `None` that stood in the seat while it was unwired.