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
//! ASSEMBLY — what a DEPLOYMENT fills a declared tower's seats with, the gate that reads the filling
//! at boot, and the ONE call a resolver makes over the result.
//!
//! ```text
//! #[ingraph::tower] ──▶ the WORDS expand = "Synonyms" · route(router = …, slot = …) · annotate
//! │
//! the deployment ──▶ the SEATS Expansion::with_expander(…) · LaneFan::with_router(…) · a Door
//! │
//! TowerDoor::installed ──▶ the GATE every declared word must have found an instance ← AT BOOT
//! │
//! the resolver ──▶ the RUN AssembledTower::run(&mut steps, question, options, asked)
//! ```
//!
//! [`tower`](super::tower) states what a tower IS ([`SearchTower`](super::SearchTower)) and what one
//! DECLARED ([`DeclaredTower`](super::DeclaredTower)). This module is the third row and it is about
//! neither a type nor a declaration: it is about a VALUE whose seats a deployment has filled.
//!
//! # THE THREE PARTIES, verbatim from the fold door
//!
//! The governance is [`FoldDoor`](crate::FoldDoor)'s, word for word, because it is the same question
//! asked one layer up — *who chooses what a search runs through*:
//!
//! - **the REQUEST never chooses an implementation.** Which expander widens a question and which
//! router cuts it are facts about what the answer MEANS, and a client able to swap them per query
//! is a client able to make two answers of one corpus that cannot be compared. Knobs are a
//! different family and ride all three tiers — see the three-tier law at
//! [`route_depth`](super::route_depth).
//! - **the DECLARATION chooses the DEFAULT**, through the words it writes: `expand = "Synonyms"`
//! names the expander a deployment gets unless it names another, and `route(router = …)` names
//! the router.
//! - **the DEPLOYMENT overrides at launch**, which is what this module is. It fills each seat with
//! the instance it wants — the declared one or its own — and the same act that installs the tower
//! installs the knobs it runs under.
//!
//! # THE GATE: a declared word whose seat is EMPTY is refused AT BOOT
//!
//! [`LaneFan::check`](crate::LaneFan::check)'s own guardrail, generalised to every word a tower
//! writes. A declaration that wrote `expand = "Synonyms"` and an assembly that mounted nothing
//! answers the UNWIDENED result, silently and for ever: the search is simply a little worse than the
//! declaration says it is, which is the hardest defect class there is to trace. So the assembly is
//! read once, at install, and every word that found no instance NAMES ITSELF — see
//! [`SeatsUnfilled`].
//!
//! **AND AN UNMOUNTED SEAT IS STILL THE IDENTITY ROAD**, which is not a contradiction of the above.
//! [`Expansion`](super::Expansion)'s absent expander is a real, supported state: a road with nothing
//! mounted answers `[the original]` and a tower walked over it is walked with the very question it
//! was handed. What the gate refuses is not that state — it is a state that DISAGREES WITH A
//! DECLARATION. A hand-written road that never wrote the word has nothing to disagree with and is
//! gated by nothing.
//!
//! **A TOWER THAT DECLARED NO WORD NEEDS NOTHING.** [`AssembledTower::check`] defaults to the honest
//! nothing, an unfanned tower's emitted gate answers `Ok(())` without reading a field, and the road
//! such a deployment walks is the road it always walked — the amendment's degenerate case, kept
//! degenerate at the assembly too.
//!
//! # THE RUN: one call, whatever the step count
//!
//! A tower's `walk` is an INHERENT fn whose arity is its step count, and a search recipe's expansion
//! has never seen the steps — so a resolver could not write the call, and until this row landed no
//! resolver did. [`AssembledTower::run`] is that call at a FIXED arity: the steps as one value, the
//! question, the DEPLOYMENT's knobs and the REQUEST's. The arity stays the tower macro's own
//! business, on the far side of a trait the macro implements.
//!
//! It is AWAITED whatever the walk's own face is. The caller is a resolver and a resolver is already
//! async, so a blocking tower's `run` wraps its blocking walk rather than making every caller ask
//! [`DeclaredTower::ALL_SYNC`](super::DeclaredTower::ALL_SYNC) which shape it is about to get — the
//! same one-call-seat division [`AsyncQueryExpander`](super::AsyncQueryExpander) already makes over
//! its blocking half. `ALL_SYNC` still answers the HAND-CALL road, where a caller spelling `walk`
//! itself needs to know.
use ;
use crateRouterMissing;
use DeclaredTower;
/// **A TOWER WHOSE SEATS ARE FILLED** — the gate a deployment's assembly is read by, and the ONE
/// call a resolver makes over it.
///
/// Emitted by `#[ingraph::tower]` off the declaration's own words, and hand-writable by anybody: a
/// hand-written tower states its refusal type and calls its own walk, and inherits a gate that
/// refuses nothing.
///
/// # It is stated over the TOWER and spends the STEPS
///
/// Every method here takes [`Steps`](super::SearchTower::Steps) rather than `self`, which is
/// [`walk`]'s own shape one seam over: a tower is a TYPE that names a road and the steps are the
/// VALUE that walks it, and the two are only the same thing because today's declaration is its own
/// steps carrier. A deployment holding its steps somewhere else says so at that seat and every row
/// here follows it without moving.
///
/// [`walk`]: super::tower
/// **WHAT A DECLARATION ASKED FOR AND AN ASSEMBLY DID NOT PROVIDE** — the boot refusal, naming every
/// gap at once.
///
/// [`RouterMissing`]'s twin at the tower's grain, and it carries that refusal whole wherever the gap
/// is a crossing's: a vocabulary a seat already publishes is never restated here, which is the
/// [`FanError`](crate::FanError) discipline the tower's own refusal sum already keeps.
///
/// # EVERY gap, and never the first
///
/// A deployment fixing an assembly wants the whole list: a tower with an unmounted expander AND an
/// unmounted router is two lines in one launch rather than two launches. So the gate collects and
/// this type holds a roster.
/// **ONE DECLARED WORD WHOSE SEAT IS EMPTY** — which step, which word, and what the assembly owed
/// it.
///
/// # There are TWO arms and the third stage has none, which is an ANSWER
///
/// ⟂ `annotate` mounts an ORDINARY SERVER at an ordinary field, so a deployment that left it out
/// wrote a struct literal missing a field: `E0063`, at the assembly, before anything boots. A gate
/// arm for it would be a runtime check standing behind a compile error that has already fired. ②
/// and ④ are here because their seats are TYPES THAT HOLD AN OPTION — a road with no expander and a
/// fan with no router are both perfectly constructible values — so the compiler has nothing to say
/// about them and this does.