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
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
//! EXPANSION — the one step at the HEAD of a question road, and the seat that may widen it.
//!
//! ```text
//! question ──▶ expand ──▶ [ the original, pinned first ] ──▶ tower walk ──▶ member read ──▶ ┐
//! [ expansion₁ ] ──▶ tower walk ──▶ member read ──▶ ┼─ fuse
//! [ expansion₂ ] ──▶ tower walk ──▶ member read ──▶ ┘
//! ```
//!
//! A [`tower`](super::tower) turns what a person asked into what an index can be asked with, one
//! question at a time. This module is what happens BEFORE the first step: a question may be widened
//! into several, each of which then walks the road the single one already walked, and the ranked
//! streams they come back with enter [`fuse`](super::fuse) as the members they already are.
//!
//! # THE ORIGINAL IS THE FRAMEWORK'S TO PIN, and that is the whole reason the seat has a type
//!
//! [`QueryExpander::expand`] answers EXPANSIONS ONLY — it never returns what it was handed — and
//! [`Expansion::expand`] is what puts the original at the head of the list. The invariant is
//! therefore a fact about the framework's own construction rather than a discipline every
//! implementor has to remember, which is the same division [`Serves`](crate::Serves)' options
//! projection already makes one layer over: what the caller must be able to rely on is built where
//! the framework can build it.
//!
//! It is what makes the DEGRADATION exact. A road with nothing mounted answers `[the original]` and
//! nothing else, so a tower walked over it is walked with the very question it was handed — the
//! same value, the same one walk, the same answer. *Fail-open* is not a posture here; it is the
//! shape of the empty case.
//!
//! # TWO FACES, and the async one is the CALL SEAT
//!
//! The read road is asynchronous, so [`Expansion::expand`] awaits [`AsyncQueryExpander`] and nothing
//! else. [`QueryExpander`] is the cheap implementor's half — a synonym table, a spelling fixer, a
//! test stub, an identity — and it reaches the call seat through the LIFT BRIDGE below rather than
//! through a second call site.
//!
//! The bridge runs ONE WAY. There is no `block_on` in this framework, and an application that
//! genuinely needs an async expander's answer on a blocking road writes that adapter where it owns
//! the runtime — which is where the decision about which runtime belongs.
//!
//! # It is a hook, so it is DYN-COMPATIBLE
//!
//! An expander is chosen by a DEPLOYMENT and held as a handle, which is the hook law's first line —
//! *hooks are assembled, capabilities are implemented*, the division
//! [`Serves`](crate::Serves)' own note draws. So [`AsyncQueryExpander`] cannot be spelled with an
//! `async fn` or an `impl Future` return the way [`AsyncServes`](crate::AsyncServes) — a capability
//! — is, and it is not: it answers a `Pin<Box<dyn Future<Output = …> + Send + '_>>`, which is what a
//! boxed-future alias in any of the futures crates already IS, written out so the signature costs no
//! dependency of its own. [`BatchAnswer`](crate::BatchAnswer) and [`Posted`](crate::Posted) are the
//! same spelling for the same reason.
use ;
use Arc;
use Utf8Bytes;
/// WHERE ONE QUESTION ON THE ROAD CAME FROM — the provenance an [`Expanded`] carries out of the
/// expand step.
///
/// Two registers, and they divide on who authored the question rather than on what it says:
/// [`Original`](Self::Original) is the framework's own — the value the caller handed in, pinned
/// first — and [`Expander`](Self::Expander) carries an expander's own word for what it minted.
///
/// # What it is FOR, which is what keeps it from being decoration
///
/// A fused answer is assembled from several arms, and a reader of one has two questions this seat
/// answers: WHICH ARM agreed (debugging a fusion is reading which streams saw a root and which did
/// not) and WHAT WEIGHT the arm should have carried — [`fuse_weighted`](super::fuse_weighted) takes
/// a coefficient per stream, and *the original outranks its own paraphrases* is a policy that needs
/// to be able to say which stream is the original.
///
/// # The escape is OPEN, and the framework's own register is a UNIT VARIANT
///
/// A translation expander, a synonym table and a spelling fixer are all downstream, so no closed
/// vocabulary could name them and this one does not try — the label is the expander's own word,
/// carried whole. What is NOT open is the original: exactly one value here is the framework's, it
/// is minted in exactly one place ([`Expansion::expand`]), and a policy asking *is this the thing
/// that was actually asked* deserves a `match` arm rather than a string comparison.
///
/// It is EXHAUSTIVE, unlike [`SkipReason`](crate::SkipReason), which is the same shape wearing
/// `#[non_exhaustive]`. The difference is that that vocabulary's own note promises more BUILT-IN
/// reasons, and this one has none to promise: the framework authors one question on the road and
/// everything else arrives from outside it.
/// ONE QUESTION ON THE ROAD — what will be walked, and where it came from.
///
/// The framework's own carrier for a widened question, and the shape
/// [`Expansion::expand`] answers a whole road in. It holds the QUESTION rather than a rewriting of
/// it, because a question's type is the tower's and this layer has no business narrowing it: a
/// structured question widened by a structured expander is the same type it always was.
///
/// # The four-piece vocabulary, and one constructor per register
///
/// [`new`](Self::new) states both seats; [`original`](Self::original) and
/// [`minted`](Self::minted) are the two registers spelled as their own doors, so a caller
/// writing an expander never assembles an [`ExpandOrigin`] by hand. Both fields carry the
/// consuming [`with_`](Self::with_origin) and the in-place [`set_`](Self::set_origin) forms, for
/// [`Flow`](crate::Flow)'s own reason: a value parsed or built elsewhere is owned whole, and
/// reaching one field inside it has no other spelling than `&mut`.
/// WHAT A TEXT-CLASS EXPANDER NEEDS OF A QUESTION, and the whole of it.
///
/// A translation, a synonym table and a spelling fixer all do one thing to a question — read its
/// text and hand back the same question wearing different text — and none of them can name the
/// question types they will be asked about. This contract is what lets ONE such expander serve
/// EVERY textual tower, through the blanket below.
///
/// # The blanket pattern, which is the reason this trait exists
///
/// ```
/// use ingraph::{ExpandOrigin, Expanded, QueryExpander, TextualQuestion};
///
/// /// One word in, its stand-ins out — the cheapest expander there is.
/// struct Synonyms(Vec<(&'static str, &'static str)>);
///
/// impl<Q: TextualQuestion> QueryExpander<Q> for Synonyms {
/// fn expand(&self, question: &Q) -> Vec<Expanded<Q>> {
/// self
/// .0
/// .iter()
/// .filter(|(word, _)| question.text().contains(word))
/// .map(|(word, stand_in)| {
/// Expanded::minted(
/// question.with_text(&question.text().replace(word, stand_in)),
/// "synonyms",
/// )
/// })
/// .collect()
/// }
/// }
///
/// let table = Synonyms(vec![("film", "movie")]);
/// let widened = table.expand(&"a good film".to_owned());
///
/// assert_eq!(widened.len(), 1);
/// assert_eq!(widened[0].query(), "a good movie");
/// assert_eq!(widened[0].origin(), &ExpandOrigin::expander("synonyms"));
/// ```
///
/// A STRUCTURED expander — one that widens a question by its fields rather than by its text — still
/// writes `impl QueryExpander<ThatQuestion>` for the concrete type, and the two do not collide: the
/// blanket above is over `Q` for ONE expander type, so it constrains nothing about what other
/// expanders may implement.
///
/// # `with_text` REBUILDS rather than mutates
///
/// `&self -> Self`, so every other seat on the question is carried across and the caller's own value
/// is left standing — which is what an expander asked to produce SEVERAL widenings of one question
/// needs. A question type whose other seats depend on its text (a pre-tokenised cache, a detected
/// script) recomputes them here, where it is the only party that knows how.
/// The SHIPPED textual question, and the one the tower grammar's own examples are written with.
///
/// `#[ingraph::tower(question(type = "String"))]` is the canonical declaration, so the type it names
/// answers this contract out of the box rather than making every such tower write two lines that
/// could only say this.
/// **A QUESTION, WIDENED** — the blocking face, and the ergonomic half of the pair.
///
/// # It answers EXPANSIONS ONLY
///
/// The original is never returned from here. [`Expansion::expand`] pins it at the head of the road
/// before anything of this trait's is called, so an implementor that returned its own input would
/// be asking the road to walk it twice. An expander with nothing to add answers the empty vec, and
/// the road is then exactly what it would have been with nothing mounted.
///
/// # FAIL-OPEN, and it has no other shape available to it
///
/// There is no `Result` here, which is the contract rather than an omission: a model that timed
/// out, a dictionary that would not load and a translation that came back empty are all *no
/// expansions*, and a search that DIED because the optional widening step did is a worse answer than
/// the unwidened one. So trouble is digested inside the implementor — logged, counted, tapped,
/// whatever the deployment does with it — and what crosses this seam is a list that may be empty.
///
/// # `&self`, unlike a step's `&mut self`
///
/// A [`Serves`](crate::Serves) step holds a reader and takes the exclusive borrow to say so. An
/// expander is a HOOK: one is mounted once and consulted from wherever a question enters, so it is
/// shared rather than owned by a walk, and interior mutability is where an implementor that caches
/// puts its cache.
/// **THE CALL SEAT** — [`QueryExpander`]'s awaited face, and the one [`Expansion::expand`] spends.
///
/// The read road is asynchronous and a real expander reaches a model, so this is the face the step
/// awaits. Everything [`QueryExpander`] states holds here verbatim — expansions only, fail-open,
/// `&self` — and THE ONLY DIFFERENCE IS THAT THE ANSWER IS A FUTURE.
///
/// # The method is `expand_async`, and the pair does NOT share one bare name
///
/// [`Serves`](crate::Serves) and [`AsyncServes`](crate::AsyncServes) both spell their verb `serve`,
/// because a type wears exactly one of those faces and the collision is what tells an author it
/// wrote the wrong one. This pair is the opposite case: the bridge below gives EVERY blocking
/// expander this face too, so one bare name would make `expander.expand(&q)` `E0034` for every
/// implementor in the framework. The suffix is the crate's own answer wherever both faces land on
/// one value — [`QueryArm::run`](crate::QueryArm::run) beside `run_async`,
/// [`Sender::send`](crate::conduit::Sender::send) beside `send_async`.
///
/// # THE FUTURE IS BOXED, and that is the hook law rather than a taste
///
/// An expander is chosen at ASSEMBLY — a deployment names one, a road holds the handle — so the
/// seat has to be dyn-compatible, and a trait whose method returns `impl Future` is not. What is
/// written instead is the type such an alias denotes anyway:
///
/// ```
/// use ingraph::{AsyncQueryExpander, Expanded, QueryExpander};
///
/// /// A blocking stub, which reaches the awaited seat through the bridge below.
/// struct Nothing;
///
/// impl QueryExpander<String> for Nothing {
/// fn expand(&self, _question: &String) -> Vec<Expanded<String>> {
/// Vec::new()
/// }
/// }
///
/// // THE HANDLE A ROAD HOLDS — erased, exactly as a policy or a tap is.
/// let handle: Box<dyn AsyncQueryExpander<String>> = Box::new(Nothing);
/// let widened = tokio::runtime::Builder::new_current_thread()
/// .build()
/// .unwrap()
/// .block_on(handle.expand_async(&"a good film".to_owned()));
///
/// assert!(widened.is_empty());
/// ```
///
/// `+ Send` on the future is part of the CONTRACT rather than something a caller hopes for, for the
/// reason every awaited seat in this crate states it: the road may be a task on somebody's runtime,
/// and a future that could not cross threads would take the whole read's `Send`ness with it.
///
/// # `Send + Sync`, because a hook is SHARED
///
/// The hook law's own words: one handle is consulted from wherever a question enters, concurrently,
/// so the seat states what that requires instead of leaving each mount to discover it. It is the
/// same supertrait [`TickPolicy`](crate::TickPolicy) and its three siblings carry.
/// **THE LIFT BRIDGE** — a blocking expander rides the call seat for free, and it runs ONE WAY.
///
/// A synonym table, a spelling fixer, an identity and a test stub have no future in them, and
/// writing one out would be ceremony over a value that is already computed. So the blocking face is
/// the one an author writes and this impl is what puts it where the road can await it, wrapping the
/// answer in a ready future.
///
/// # It is EAGER, and the doc says so because a reader would otherwise have to guess
///
/// The blocking body runs at the CALL and the future returned is already complete. That is the
/// honest shape for a value with nothing to wait on, and it costs the bridge one bound instead of
/// three: a lazy `async move` block would have to capture `&self` and `&question` across the await
/// and would therefore demand `Sync` of the question type as well, narrowing the set of towers a
/// cheap expander can serve for no behaviour anybody could observe.
///
/// # ONE TYPE, ONE MEANING
///
/// The blanket occupies the whole of [`AsyncQueryExpander<Q>`] for every blocking expander, so a
/// type CANNOT state two answers to the same question — a second, hand-written impl is `E0119`:
///
/// ```compile_fail,E0119
/// use std::{future::Future, pin::Pin};
///
/// use ingraph::{AsyncQueryExpander, Expanded, QueryExpander};
///
/// struct Both;
///
/// impl QueryExpander<String> for Both {
/// fn expand(&self, _question: &String) -> Vec<Expanded<String>> {
/// Vec::new()
/// }
/// }
///
/// impl AsyncQueryExpander<String> for Both {
/// fn expand_async<'a>(
/// &'a self,
/// _question: &'a String,
/// ) -> Pin<Box<dyn Future<Output = Vec<Expanded<String>>> + Send + 'a>> {
/// Box::pin(std::future::ready(Vec::new()))
/// }
/// }
/// ```
///
/// # THERE IS NO REVERSE BRIDGE
///
/// An awaited expander does not acquire a blocking face, and it will not: the only way to build one
/// is to drive a future to completion, which means choosing a runtime — a decision that belongs to
/// the application and never to the framework. A deployment that genuinely needs one writes the
/// adapter where it already owns the runtime, in as many lines as the honesty costs.
/// **THE EXPAND STEP'S SEAT** — what a question road holds, and what an assembly mounts an expander
/// into.
///
/// ABSENT is the shipped state, and the absent seat is the IDENTITY road: a question in, the same
/// question out, one entry long. Nothing about a deployment that mounts nothing changes, which is
/// the property this whole module is measured against.
///
/// # It holds a HANDLE, which is why the seat is a type rather than a parameter
///
/// A tower's steps are types the declaration names; an expander is a VALUE a deployment chooses,
/// possibly at runtime, possibly from configuration, and possibly not at all. So it arrives the way
/// every other assembled hook in this framework arrives — erased, behind a handle, mounted through
/// the [`with_`](Self::with_expander) / [`set_`](Self::set_expander) pair that
/// [`StreamOptions::with_feed_policy`](crate::StreamOptions::with_feed_policy) already spells.
///
/// The handle is an [`Arc`] inside and a [`Box`] at the door, for that same seam's reason: a road
/// is cloned per read and a mount is written once, so the cheap side of the trade is the one that
/// happens often.
///
/// # Examples
///
/// ```
/// use ingraph::{ExpandOrigin, Expanded, Expansion, QueryExpander};
///
/// /// A synonym table, mounted by an assembly that has one.
/// struct Synonyms;
///
/// impl QueryExpander<String> for Synonyms {
/// fn expand(&self, question: &String) -> Vec<Expanded<String>> {
/// vec![Expanded::minted(question.replace("film", "movie"), "synonyms")]
/// }
/// }
///
/// # tokio::runtime::Builder::new_current_thread().build().unwrap().block_on(async {
/// // NOTHING MOUNTED: the road is the question, and only the question.
/// let bare = Expansion::<String>::new();
/// let road = bare.expand("a good film".to_owned()).await;
///
/// assert_eq!(road.len(), 1);
/// assert_eq!(road[0].origin(), &ExpandOrigin::Original);
/// assert_eq!(road[0].query(), "a good film");
///
/// // MOUNTED: the original still leads, and the widening follows it.
/// let widened = bare.with_expander(Box::new(Synonyms));
/// let road = widened.expand("a good film".to_owned()).await;
///
/// assert_eq!(road.len(), 2);
/// assert_eq!(road[0].query(), "a good film");
/// assert_eq!(road[1].query(), "a good movie");
/// # });
/// ```
/// **WHAT ONE ARM OF AN EXPANSION FAMILY COUNTS FOR** — [`Expansion`]'s own knobs seat, and the ARM
/// half of the fan's weight product.
///
/// ```
/// use ingraph::{ArmWeights, ExpandOrigin};
///
/// // The shipped numbers: what was asked counts whole, a paraphrase counts for half.
/// let shipped = ArmWeights::new();
/// assert_eq!(shipped.weight(&ExpandOrigin::Original), 1.0);
/// assert_eq!(shipped.weight(&ExpandOrigin::expander("synonyms")), 0.5);
///
/// // And a deployment that trusts its expander more says so in one call.
/// let trusted = ArmWeights::new().with_paraphrase(0.9);
/// assert_eq!(trusted.weight(&ExpandOrigin::expander("synonyms")), 0.9);
/// ```
///
/// # THERE IS ONE NUMBER HERE, and the missing second one is an ANSWER
///
/// [`ORIGINAL`](Self::ORIGINAL) is `1.0` and is not a knob. Reciprocal rank fusion sums `w / (k +
/// rank)` over the streams of ONE answer, so only the RATIO between two arms' weights orders
/// anything — scaling every arm by the same factor reorders nothing at all. A second knob would
/// therefore be a second spelling of the one number this seat already has, and two spellings of one
/// fact is what this crate refuses everywhere.
///
/// # It is the ② STEP'S [`Serve::Options`], which is where TIERS ONE AND TWO already run
///
/// A tower mounts its widening at a step, and a step's knobs are declared once on the SERVER — so
/// the arm weight arrives through the tower's own options object, at the widening step's own row,
/// with no seat minted anywhere for it. A deployment's override is therefore somebody else's
/// already-built road rather than this type's new one, and the emitted fan walk reads it at the one
/// place the coefficient is computed.
///
/// **The QUERY-TIME tier has its road now**, and the 2026-08-27 census is what named the missing
/// piece: [`AssembledTower::run`](crate::AssembledTower::run) took the deployment's options and
/// nothing beside them. It takes a REQUEST's package too — `Option<Self::SearchOptions>`, the
/// word-keyed object a tower that wrote `expand = "…"` mints an arm-weight row on — and the emitted
/// run lays it over the deployment's with [`over`](Self::over) before the walk reads a coefficient.
/// So the composition below is not waiting for anything: it is the arithmetic every fanned tower's
/// widening runs through.
///
/// # THE CLASSIFICATION: this is a PREFERENCE number, so it rides all three tiers REQUEST-SUPREME
///
/// A weight is a requester's own statement about the answer it wants — *count what I actually asked
/// for more heavily than what you guessed I meant* — and a client that rewrites one is a client
/// asking a different question rather than one escaping a bound. So it is the preference half of the
/// numbers law stated at [`route_depth`](crate::route_depth): all three tiers, and the outermost one
/// wins outright. [`over`](Self::over) is that composition, and it is the whole of it.
///
/// The contrast that gives the classification its teeth is one type over: a BUDGET is protective, so
/// its wire arm may only ever tighten — see
/// [`tightened_budget`](crate::tightened_budget), where the other half of the same law is spent.
///
/// # NO RANGE IS REFUSED HERE, and that is the fold's own sibling rather than an oversight
///
/// A weight is any `f64`, negative and non-finite included. The reason is
/// [`Route::with_weight`](crate::Route::with_weight), which is the same number one layer up and
/// refuses nothing: both multiply an RRF term, both are the caller's own statement about its own
/// answer, and a range checked at one of them and not the other would be two spellings of one policy
/// — with the gap wherever the check was not written. A range this family wants is a range that
/// family wants too, and the day it is ruled it is ruled at both.
///
/// # THE NUMBER IS UNTUNED, and this says so where a tuner will read it
///
/// [`DEFAULT_ARM_WEIGHT`](Self::DEFAULT_ARM_WEIGHT) is `0.5` — a paraphrase counts for half of what
/// was actually asked — chosen as a defensible starting value rather than a measured one, exactly as
/// [`ScriptWeightedFan::DEFAULT_EMPHASIS`](crate::ScriptWeightedFan::DEFAULT_EMPHASIS) was.
///
/// **No round has measured it, and none is scheduled.** What is owed is THE TUNING ROUND — the
/// standing follow-up queue's entry (ingraph #238), demand-gated on a real corpus rather than dated —
/// which re-measures the lexical half after the C2b work, prices the fold's own effect, and turns
/// this knob and [`ScriptWeightedFan::DEFAULT_EMPHASIS`](crate::ScriptWeightedFan::DEFAULT_EMPHASIS)
/// against the SAME data. One round and not two, because the two numbers multiply into one
/// coefficient: tuning either alone tunes their product by guesswork.
///
/// [`with_paraphrase`](Self::with_paraphrase) is the knob that round turns, and until it does a
/// deployment holding its own corpus is better placed to name a number than this constant is.
/// The shipped weights — [`ArmWeights::new`], and one source of truth for them.
/// **THE ② SEGMENT'S KNOBS ARE THE ARM WEIGHT**, and a widening step's options row is this.
///
/// The seat is on the BASE for the reason every step's is: a tower's emitted options PROJECTS
/// `<Ty as Serve>::Options` one field per step and calls no verb doing it, so a widening step's row
/// is minted by the machinery that was already there.
/// **THE ENDOMORPHISM, STATED ONCE AT THE SEAT** — a widening answers the question type it was
/// asked, which is what makes a tower's `answer = "…"` omissible at a ② step.
///
/// It is a LINE and not a capability, exactly as every other [`DefaultServe`] row is: nothing here
/// is callable, so a tower that mounts a widening still reaches [`Expansion::expand`] itself. What
/// this states is the fact the fan grammar's own ordering law is built on — ② is an endomorphism
/// over questions — said in the one place a declaration reads a type off.
/// The identity road — [`Expansion::new`], and one source of truth for it.
/// The handle is shared, so a road is cloned rather than rebuilt — and `Q` is a parameter of the
/// TRAIT OBJECT rather than of anything held, so no bound on it is required or written.
/// WHETHER one is mounted, and never which — an erased handle has no name to print, and a road that
/// tried to invent one would be reporting the `Debug` of a trait object it cannot ask for.