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
//! [`AsyncFusedRead`] — the one verb a parent asks a fusable member through, and the four seats that make
//! it total over members whose shapes the parent has never seen.
use ;
use ;
/// HOW a parent asks a member for its ranked keys.
///
/// [`Fusable`] says a member has a fusion package; this says how to spend one. It is ONE trait for
/// both modalities, and that is load-bearing: a ROOT holds a member's type PATH and cannot see which
/// kind its declaration is, so a mixed door has to reach every member through one projection.
///
/// There is no second trait carrying the MODALITY, and there was one until 2026-08-19: two markers
/// a consumer could write to demand ONE modality at a field. The word that demanded them — a graph
/// root's `fuse(vector)` / `fuse(fulltext)` trim — retired with the root's own typed doors, and in
/// the rounds after it nothing wrote the bound. A stated capability nobody states is a name in a
/// prelude, so it went; a consumer that wants a modality checked writes its own marker over the
/// members it holds, which is the same one line without this crate carrying it.
///
/// # NO `&self`, and the index type is why
///
/// A declaration's type is a BRAND — `Shots` is not a value anybody holds, it is the name a slot
/// handle is branded with. So the verb is ASSOCIATED, and the state it needs arrives through
/// [`Ctx`](Self::Ctx) exactly as a queries unit's resolvers take theirs from a context rather than
/// from a receiver.
///
/// # `Ctx` is the MEMBER's own, and that is what keeps a root from naming a slot
///
/// A member's own doors take slot handles, read scopes and floors — types written in the member's
/// declaration, generic over the engine, and unspellable at a root that holds a type path. So the
/// member names them INSIDE its own impl and a parent names `<M as AsyncFusedRead<E>>::Ctx<'_>`. The
/// root's door is therefore total over members whose shapes it has never seen, which is the same
/// projection seam [`Fusable`] draws for the packages.
///
/// # The engine is a PARAMETER, and the member's own heterogeneity is not lost
///
/// One engine per MEMBER at this seat: a root's routes are its members, so the root grain's currency
/// law is one engine parameter per route exactly as the index grain's is. A member whose own routes
/// are held by DIFFERENT engines is still reachable — through that member's own `vector_fuse`, which
/// takes one engine per route — and what this seat offers is the member asked through one of them.
/// Widening it would mean a root naming a member's route count, which is the wall this seam exists
/// to keep.
///
/// # The engine parameter is UNBOUNDED, and that is what lets one road carry two modalities
///
/// A vector member is asked through a `VectorEngine` and a full-text one through a
/// `FulltextEngine`, and there is no trait both are. Naming either here would have split this seam
/// in two and put the root's mixed door back where it started — picking a modality per member it
/// cannot see. So the parameter is a NAME: whichever engine the member's own doors take, carried
/// through to `Ctx` and read by nobody in between.