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
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
//! What a record contributes to an index, and which index it lands in: [`FulltextRecord`],
//! [`FulltextTable`], [`BlobRecord`], [`BlobTable`], [`VectorRecord`].
//!
//! Four traits and no engine. A document is text, an embedding is coordinates, a key is a value and
//! a slot is a name — none of them mentions Tantivy or FTS5 or Lance — so this module compiles in a
//! build with no backend family at all, exactly as the storage forms do. What an engine adds is
//! NOTHING a record has to know about: a key reports itself in COLUMNS ([`Field`](crate::Field),
//! one impl per TYPE), and the JOIN between a record and an engine is the EMISSION's — the code that
//! can see a record's fields is the code that crosses them into an engine's entry.
//!
//! An engine RECORD TRAIT used to make that join —
//! `TantivyRecord: FulltextRecord + Identifiable<Id: TantivyKey>` was the shape — and A′ retired it.
//! A trait joining a record to an engine has to name the engine's own key capability, which is a
//! local trait over foreign key types, which is the orphan wall: `impl TantivyKey for i64` in a
//! declaring crate was `E0117`, so the crate owed the id vocabulary a shipped impl per member and a
//! completeness proof beside them. An ENGINE-BLIND row has no such wall — it names no engine for an
//! orphan rule to be about — and the join it used to make is a line of emitted code instead.
//!
//! # Three families are here, and the fourth is not
//!
//! Meta records are not written, because nothing asks for one: a row's value is backend-shaped
//! columns rather than anything a neutral trait could return. The ADDRESS is the one piece all four
//! share, which is why it is the entity binding's — [`Identifiable`](crate::Identifiable)'s id,
//! reached through [`Transformer`] — and sits beside the families rather than inside one of them.
//!
//! Blob was the second to arrive, and what asked is [`store`](crate::store): a blob store's seam is
//! the cheapest of the three, because a blob's address is derivable from its key alone — it needs
//! no query language, no element vocabulary and no document schema to be useful. Its NAMING
//! authority, [`BlobTable`], arrived with the blob-engine round, and what asked for it is
//! [`Creation::async_blob_slot`](crate::Creation::async_blob_slot): a launch that mints a handle has to read the
//! family's name off the declaration, or the caller states a pairing nothing checks.
//!
//! Vector is the third, and what unblocked it was the ELEMENT. This note used to say that a vector
//! record could not be spelled without the element vocabulary first, and that was true of the
//! vocabulary it meant: 721 lines holding three marker types, a runtime enum shadowing them, a
//! packing per element and an engine-admission seam. [`Embedding<E, N>`](crate::Embedding) replaced
//! it by naming the element type instead of a marker for it, so what a vector record now needs to
//! be spelled is a slice per elected column. Its own naming authority has NOT crossed — no launch
//! door mints a vector handle yet, and until one does there is nothing for the const to be read by.
//!
//! # Identity is ORTHOGONAL to the document, and a supertrait of the name
//!
//! [`FulltextRecord`] does not require [`Transformer`], and [`FulltextTable`] does. That is one
//! decision twice, and the two bounds are what it buys:
//!
//! - `T: FulltextRecord` is what a party rendering text writes, and it reaches no `T::Key` —
//! `E0220`, pinned by that trait's own `compile_fail` doctest. Under the supertrait the bound
//! would carry identity silently, and no type could have a document before it had a key.
//! - `T: FulltextTable` is what a party writing to the index writes, and it reaches `T::Key`
//! through the supertrait chain without naming [`Transformer`]. A slot name is where a document
//! is put, and a namer that could not reach what the document is answered as would name a
//! resource it can say nothing else about.
//!
//! ADDRESSING is not what holds that second bound up, and the stale answer is the obvious one.
//! Which entry a document replaces or deletes is the ID's question — an unbrowsable engine names an
//! entry by the id it came in under — and [`Identifiable`](crate::Identifiable) answers it alone,
//! being a supertrait of [`Transformer`] rather than a member of it, so a bound naming that smaller
//! trait would already have reached the address. What keeps [`Transformer`] here is the OUTPUT
//! half: the whole key, ancestry included, is what a hit is handed back under, and that is what the
//! doctest below writes — `address_of` returns `T::Key`, which no smaller bound projects.
//!
//! Both halves are pinned: the second by this module's doctest, the first by its `compile_fail`
//! twin and by `tests/downstream.rs`, which writes both functions from outside the crate.
use Future;
use Cow;
use crate::;
/// A full-text entry: the document to index.
///
/// Unlike a meta record, the neutral trait exposes the VALUE — a document is text in every backend,
/// where a row's value is backend-shaped columns — so there is something for a bound-free trait to
/// return.
///
/// # `type Document` is the SIMPLE shape, and the general one is designed
///
/// `docs/2026-07-28-derive-design-notes.md` records the direction this becomes:
/// `fn document(&self, doc: &mut DocSink)` plus a const field-declaration list, symmetric with a
/// key's encode. That shape can write SEVERAL NAMED fields, each with its own tokenizer, index
/// option and stored flag, which one associated type cannot express — a single `Document` is one
/// box of text.
///
/// It is not built here because neither half of it exists: there is no `DocSink`, no field
/// declaration, and no derive to emit against them. When it lands, [`Document`](Self::Document)
/// goes away and [`document`](Self::document) takes a sink and returns nothing, so every impl
/// written against this trait is rewritten. The trait's name, its independence from [`Transformer`]
/// and its place in the family are what survive that change; the method signature is not.
///
/// # Examples
///
/// A bound naming only this trait reaches the document and no key, which is the separation's whole
/// content:
///
/// ```
/// use ingraph::FulltextRecord;
///
/// struct Caption(String);
///
/// impl FulltextRecord for Caption {
/// type Document = String;
///
/// fn document(&self) -> &String {
/// &self.0
/// }
/// }
///
/// fn document_of<T: FulltextRecord>(record: &T) -> &T::Document {
/// record.document()
/// }
///
/// assert_eq!(document_of(&Caption("a red car".to_owned())), "a red car");
/// ```
///
/// And it reaches no key, because there is none to reach:
///
/// ```compile_fail,E0220
/// use ingraph::FulltextRecord;
///
/// fn key_of<T: FulltextRecord>(record: &T) -> T::Key {
/// record.key()
/// }
/// ```
/// WHICH full-text slot a record's documents land in — the record's durable SLOT name.
///
/// A slot rather than a table, because that is the vocabulary the full-text engines share: one
/// Tantivy index or one FTS5 virtual table PER SLOT, which is what gives each its own corpus
/// statistics.
///
/// # Why the name lives on the RECORD
///
/// `Self` is the record type, which keeps three things apart that a single name per entity would
/// conflate: an entity is not an index, a key TYPE is not an index (two records can share one key
/// type), and a slot is not a table. Each family names its OWN resource with its OWN key.
///
/// A `const`, because a record's slot is fixed at its type and needs no value to ask — and because
/// a `const` is the position [`SlotName::new`]'s refusal becomes `E0080` in, at the impl that
/// names the slot rather than at a store that renders it.
///
/// # Examples
///
/// ```
/// use ingraph::{FulltextRecord, FulltextTable, Identifiable, SlotName, Transformer};
///
/// struct Caption {
/// media: u64,
/// frame: u32,
/// text: String,
/// }
///
/// #[derive(Debug, PartialEq)]
/// struct CaptionKey {
/// media: u64,
/// frame: u32,
/// }
///
/// #[derive(Debug, PartialEq)]
/// struct CaptionLineage {
/// media: u64,
/// }
///
/// impl Identifiable for Caption {
/// type Id = u32;
///
/// fn id_ref(&self) -> &u32 {
/// &self.frame
/// }
/// }
///
/// impl Transformer for Caption {
/// type Key = CaptionKey;
/// type Lineage = CaptionLineage;
/// type Record = Self;
/// type Graphql = ();
///
/// fn key(&self) -> CaptionKey {
/// CaptionKey {
/// media: self.media,
/// frame: self.frame,
/// }
/// }
/// }
///
/// impl FulltextRecord for Caption {
/// type Document = String;
///
/// fn document(&self) -> &String {
/// &self.text
/// }
/// }
///
/// impl FulltextTable for Caption {
/// const SLOT: &'static SlotName = SlotName::new("captions");
/// }
///
/// // The bound names this trait alone, and reaches the whole key — the output address, ancestry
/// // included — through the supertrait chain.
/// fn address_of<T: FulltextTable>(record: &T) -> (&'static SlotName, T::Key) {
/// (T::SLOT, record.key())
/// }
///
/// let caption = Caption {
/// media: 7,
/// frame: 12,
/// text: "a red car".to_owned(),
/// };
/// let (slot, key) = address_of(&caption);
///
/// assert_eq!(slot.as_ref(), "captions");
/// assert_eq!(key, CaptionKey { media: 7, frame: 12 });
/// ```
/// The ARTIFACT FAMILY a blob record's objects land in — the blob side's naming authority, and
/// [`FulltextTable`]'s sibling in every respect that matters.
///
/// Where a full-text slot is a corpus and a vector slot is a table, a blob slot is the FIRST SEGMENT
/// of a hierarchical object name — a directory under a filesystem store's root, the leading
/// object-key segment in an object store. Everything below it is the key's own walk, so this const
/// is the whole of what a family is called.
///
/// # Why the name lives on the RECORD, and why it is a `const`
///
/// [`FulltextTable`]'s two reasons, unchanged, because they were never about full text. `Self` is
/// the record type, which keeps an entity, a key TYPE and a slot apart where one name per entity
/// would conflate them; and a `const` is the position [`SlotName::new`]'s refusal becomes `E0080`
/// in — at the impl that NAMES the family, rather than at a store that renders it. A slot reaches a
/// directory, where no quoting exists, so the charset fence is not decoration.
///
/// # The [`Transformer`] supertrait, for the same half it is there for one family over
///
/// Not addressing — [`Identifiable`](crate::Identifiable) would already have reached that. It is the
/// OUTPUT half: what a caller holding a family gets back is the whole `Self::Key`, ancestry
/// included, because that key IS the address under this family's slot. A namer that could not
/// project the key would be naming a resource it can say nothing else about.
///
/// # Examples
///
/// ```
/// use ingraph::{BlobRecord, BlobTable, Identifiable, SlotName, Transformer};
///
/// struct Thumbnail {
/// media: u64,
/// frame: u32,
/// pixels: Vec<u8>,
/// }
///
/// #[derive(Debug, PartialEq)]
/// struct ThumbnailKey {
/// media: u64,
/// frame: u32,
/// }
///
/// impl Identifiable for Thumbnail {
/// type Id = u32;
///
/// fn id_ref(&self) -> &u32 {
/// &self.frame
/// }
/// }
///
/// impl Transformer for Thumbnail {
/// type Key = ThumbnailKey;
/// type Lineage = u64;
/// type Record = Self;
/// type Graphql = ();
///
/// fn key(&self) -> ThumbnailKey {
/// ThumbnailKey {
/// media: self.media,
/// frame: self.frame,
/// }
/// }
/// }
///
/// impl BlobRecord for Thumbnail {
/// type Bytes = Vec<u8>;
///
/// fn bytes(&self) -> &Vec<u8> {
/// &self.pixels
/// }
///
/// fn extension() -> Option<&'static str> {
/// Some("png")
/// }
/// }
///
/// impl BlobTable for Thumbnail {
/// const SLOT: &'static SlotName = SlotName::new("thumbnails");
/// }
///
/// // What a launch door writes: the family's name and the key that addresses inside it, off ONE
/// // type and with no pairing for a caller to state.
/// fn family_of<T: BlobTable>(record: &T) -> (&'static SlotName, T::Key) {
/// (T::SLOT, record.key())
/// }
///
/// let thumbnail = Thumbnail {
/// media: 7,
/// frame: 12,
/// pixels: vec![0x89, 0x50],
/// };
/// let (slot, key) = family_of(&thumbnail);
///
/// assert_eq!(slot.as_ref(), "thumbnails");
/// assert_eq!(key, ThumbnailKey { media: 7, frame: 12 });
/// ```
/// AN ARTIFACT FAMILY, seen from the declaration that SERVES it — the bridge two macro expansions
/// cross when neither can read the other's tokens.
///
/// # The wall this exists to go around
///
/// A blob family's wire fields belong on the OUTPUT OBJECT of the entity its objects are derived
/// from, and that object is written by the ENTITY's expansion. What the fields need — the family's
/// slot, how its addresses end, which store holds them — is written on the FAMILY's declaration. Two
/// derives do not see each other's tokens, and a second `#[Object]` block bolted onto one type
/// afterwards is `E0119` three times over (`ContainerType`, `OutputType`, `ObjectType`), so nothing
/// can be added later either.
///
/// So the family's declaration writes these facts into a TYPE, and the entity's `locate(…)` word
/// hands its expansion the family's PATH. Everything crosses as a projection off that path, which is
/// zero cross-expansion token reading, and the wall never arises.
///
/// # What is here, and what is deliberately one trait out
///
/// This trait carries what the DECLARATION knows about itself, and nothing that depends on a
/// deployment or on a wire face. The three facts that do are traits of their own, each with its own
/// presence:
///
/// | fact | trait | present when |
/// |---|---|---|
/// | the slot, the type-level suffix, the upstream | [`BlobArtifact`] | always |
/// | the suffix a hydrated ROW renders | [`ArtifactSuffix`] | always, defaulting to [`SUFFIX`](Self::SUFFIX) |
/// | where the objects live, and how an address is reached | [`ArtifactStore`] | the family named a store this crate can spell, or a third party wrote the impl |
/// | the bytes may be served INLINE | [`ArtifactData`] | the declaration wrote `data` |
///
/// The split is what keeps the family open. A store the framework has never heard of is bound at a
/// GRAPH ROOT, which no declaration's expansion can see — so [`ArtifactStore`] is left for whoever
/// can name the store, and the family's own declaration still answers everything else.
/// The SUFFIX one HYDRATED ROW renders — where the `extension` word's six forms are resolved.
///
/// # Why the row is a type PARAMETER and not an associated type
///
/// The row this reads is the entity's OUTPUT OBJECT, whose type the family's own expansion cannot
/// name: it exists only where the entity declared a `graphql(…)` block, and naming it would make
/// every artifact family demand a wire face from its upstream — including the families that only
/// ever store. As a parameter it costs nothing: the four COLUMN forms emit ONE impl at the row they
/// actually read, and the two forms that read no row take the blanket and bind for every `Row` there
/// is.
///
/// # The DEFAULT is the two column-less forms, and it is not a placeholder
///
/// `extension = "png"` and the omitted form both answer off the type, so the default body IS their
/// implementation and a family taking either emits `impl<Row> ArtifactSuffix<Row> for …` with an
/// empty body. There is no overlap with the column forms, because a family is on exactly one of the
/// six roads.
///
/// # The `with` hook eats the COLUMN VALUE, and that is what makes it ONE function
///
/// The write lane holds an upstream field and the read face holds the entity's own column; a hook
/// over the VALUE is spendable from either, where a hook over the row would need two different rows
/// and would be two functions pretending to be one. Nothing about that is enforced at this seat —
/// the hook is called by the emission, at the span its author wrote — and it is stated because this
/// is where the read half of it arrives.
/// A row held a value its family's own fence does not admit.
///
/// It carries all four parts of the sentence a caller has to be able to write — WHICH family, WHICH
/// column, what the row held, and what the declaration admits — because a resolver surfacing this on
/// the wire has no other source for any of them.
/// WHERE an artifact family's objects live, and the verb a wire face spends on them.
///
/// # Why the verb is HERE and not bounded at the face
///
/// A resolver holding a family's type and a store would still be unable to call the seam: minting
/// the handle takes one of two construction traits, the read scope is the backend's own associated
/// type, and the payload is a third. Every one of those is knowable only where the STORE TYPE is —
/// and that is exactly this impl. So the impl carries the CALL and the face carries the QUESTION,
/// which is what lets one face be written for every backend there will ever be.
///
/// # Its presence IS the openness, and not a gap
///
/// A family naming a store `ingraph` ships gets this impl from its own expansion. A family naming a
/// store bound at a graph root does not, and cannot: the binding is written where the program is
/// assembled, and no declaration's expansion can see a graph root. So the trait is left
/// hand-implementable, and a third-party store reaches every wire field the shipped one does by
/// writing it — which is the whole of what this seam's openness claim comes to.
///
/// # `type Active` is DEAD, and this is not it under another name
///
/// The design once had a family's expansion project the DEPLOYMENT-SELECTED engine into an
/// associated type. That was measured impossible and ruled out: under single-write the emission
/// writes no door at all, the deployment picks by which handle it OPENS, and a family may legally
/// declare no store. What is projected here is none of those — it is the store TYPE the family's own
/// declared word names, which is a fact of the declaration and not a selection. The OPENED store
/// still arrives at run time, through the door in a request's context, and nothing on this trait is
/// a handle, a root, or a live connection.
/// This family's bytes may be served INLINE — the `data` word, as a capability.
///
/// # A trait rather than a flag, because presence has to be CHECKABLE
///
/// The word is written on the FAMILY and the field that spends it is emitted by the ENTITY, so what
/// crosses between them has to be something a bound can ask about. A `const DATA: bool` is readable
/// at run time and useless at emission time; a trait is `E0277` at the word that asked, naming the
/// family and the word it never wrote.
///
/// # A supertrait of [`ArtifactStore`] and not of [`BlobArtifact`]
///
/// Serving bytes means READING them, and reading them takes the store — so the capability saying
/// *these bytes may travel* is only meaningful where there is somewhere to read them from.
/// # The note names BOTH ROADS, because two real words are what this bound joins
///
/// A wire field asking for bytes is written on the ENTITY — a `data` ask inside its `locate(…)`
/// position — because a field's presence belongs to the expansion that writes the `#[Object]` block.
/// The capability is written on the FAMILY, because whether an object may travel inline is a fact
/// about the objects. So an unsatisfied bound here has TWO repairs, in two different declarations,
/// and nothing at this seat can know which one the author meant. A note naming one of them would
/// send half its readers to the wrong file.
/// A blob-store entry: its byte payload and its file format.
///
/// Independent of the other record faces — no shared supertrait; its identity is the orthogonal
/// [`Transformer`] address, implemented separately. Like [`FulltextRecord`], the neutral trait
/// exposes the VALUE, because a blob's payload is a byte string in every backend.
///
/// # The key IS the address
///
/// A blob's key stores AS its fields — the segments of a HIERARCHICAL OBJECT NAME, in the key's own
/// column order, parent ids first — so an entity's subtree contains every descendant artifact and a
/// hard-delete by lineage is a prefix removal. A filesystem renders that name as directory levels,
/// an object store as object-key segments where the lineage prefix maps to a key-prefix delete.
/// Deliberately NOT content-addressed: identical bytes under two keys store twice, which is exactly
/// what keeps a key's location stable when its bytes are rewritten.
///
/// The rendering itself is the BACKEND's — see [`store`](crate::store), where a backend's own record
/// trait says how a key becomes an address. This trait states what every backend needs and no
/// backend's scheme.
/// A vector-index entry: its embedding.
///
/// Unlike a meta record, the neutral trait exposes the VALUE — an embedding is kind-shaped, a
/// coordinate array in every backend, where a row's value is backend-shaped columns — so there is
/// something for a bound-free trait to return. That is [`FulltextRecord`]'s asymmetry one family
/// over, and it is principled rather than incidental.
///
/// # The element is a TYPE FACT, and it is the element type itself
///
/// `type Element = f32`, not a marker standing for `f32`. The reference implementation named one
/// marker per element — `element::F32`, whose `Carrier` was `Arc<[f32]>` — for a reason that was
/// about NAMES rather than about elements: a free `F32` type would have collided with the
/// primitive and with the arms of the runtime enum beside it.
/// [`Embedding<E, N>`](crate::Embedding) dissolved that collision by naming the primitive, so the
/// element crosses as itself and [`vector`](Self::vector) hands back a slice — the carrier SPELLED
/// rather than projected through a marker's associated type.
///
/// What survives the change is why the element was a type at all: it is a COMPILE-TIME INVARIANT,
/// so one record cannot yield mixed elements across its instances. What does not survive is what
/// the marker carried BESIDE the carrier — a `descriptor()` naming a runtime element tag, and a
/// `to_value()` packing coordinates for a staged write. Each belonged to machinery this crate does
/// not have.
///
/// # The width is a fact of the FIELD, and it is not restated here
///
/// A record whose field is `Embedding<f32, 768>` yields 768 coordinates because
/// [`Embedding::new`](crate::Embedding::new) checked the length once, at construction. A `const
/// DIM` on this trait would be a second home for that fact, and two homes for one fact are free to
/// disagree. Where a width must be PASSED — [`AsyncVectorStore::vector`](crate::AsyncVectorStore::vector)
/// takes a slot's `dim` — the call site reads [`Embedding::DIM`](crate::Embedding::DIM) off the
/// same field type, so the width has one author whether it is used as a type or as a number.
///
/// # Examples
///
/// A record projecting an embedding field, and the width read off that field's own type:
///
/// ```
/// use std::sync::Arc;
///
/// use ingraph::{Embedding, VectorColumn, VectorRecord};
///
/// struct Keyframe {
/// media: u64,
/// ordinal: u32,
/// embedding: Embedding<f32, 768>,
/// }
///
/// struct KeyframeLineage {
/// media: u64,
/// }
///
/// impl VectorRecord for Keyframe {
/// type Element = f32;
/// type Filter = KeyframeLineage;
///
/// fn vectors(&self) -> impl Iterator<Item = (VectorColumn, &[f32])> {
/// core::iter::once((
/// VectorColumn::new("embedding"),
/// self.embedding.coordinates(),
/// ))
/// }
/// }
///
/// fn coordinates_of<T: VectorRecord>(record: &T) -> Vec<(VectorColumn, &[T::Element])> {
/// record.vectors().collect()
/// }
///
/// let keyframe = Keyframe {
/// media: 7,
/// ordinal: 12,
/// embedding: Embedding::new(Arc::from(vec![0.5; 768])).expect("768 coordinates"),
/// };
///
/// let elected = coordinates_of(&keyframe);
/// assert_eq!(elected.len(), 1, "one election is the smallest N, not a different shape");
/// assert_eq!(elected[0].1.len(), Embedding::<f32, 768>::DIM);
/// ```
///
/// And the bound reaches no key, because there is none to reach — the address is
/// [`Transformer`]'s, implemented beside this face rather than beneath it:
///
/// ```compile_fail,E0220
/// use ingraph::VectorRecord;
///
/// fn key_of<T: VectorRecord>(record: &T) -> T::Key {
/// record.key()
/// }
/// ```
///
/// # A record states N embeddings, and the ELECTION is what names each one
///
/// One declaration may elect several embeddings and they live as several columns of ONE slot, so
/// what this face hands back is a LIST of (column, coordinates) rather than one slice. N = 1 is the
/// smallest N and not a separate shape: a single-election record yields a one-item iterator, and no
/// caller branches on the count.
///
/// The columns are the ELECTED ones and nothing else. A declaration's other embedding-typed fields
/// are ordinary payload — stored, hydrated, reached through their own accessors — and they are
/// absent here, which is the payload posture made mechanical rather than promised: what no election
/// names, no `knn` can reach, through any column.