ingraph 0.1.0

A declaration-driven indexing framework: records and nodes are written as Rust types, and the storage rows, the dataflow between them and the GraphQL query surface are emitted from the declaration.
Documentation
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
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
// The docs.rs badge half, for every `#[cfg(feature = "…")]` in this crate at once.
//
// `doc_cfg` DERIVES the "Available on crate feature `x` only" banner from the `cfg` an item already
// carries, so a gated item needs no second attribute and the two halves cannot drift apart. It once
// took a per-item `#[doc(cfg(…))]` and the automatic half was its own `doc_auto_cfg` gate; that gate
// was REMOVED in 1.92 and merged into this one, so naming `doc_cfg` today buys both. A per-item
// `#[doc(cfg(…))]` still overrides where a derived banner would be wrong, and does not double it.
//
// Nightly-only, which is why it rides `cfg_attr`: `docsrs` is set by the `rustdoc-args` in this
// crate's `[package.metadata.docs.rs]` and by nothing else, so every stable build — clippy, test,
// the feature matrix — compiles a crate that has never heard of it. Reproduce what docs.rs renders
// with `RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features -p ingraph`.
#![cfg_attr(docsrs, feature(doc_cfg))]
//! `ingraph` — the indexing framework, regrown demand-driven.
//!
//! A declaration is a Rust type wearing one of `ingraph-derive`'s words, and what it buys is the
//! road under it: the key and lineage types the record is addressed by, the rows a backend stores
//! it as, the node it is computed in and the edges data crosses to reach one, and the filters,
//! orderings and GraphQL face a client asks it with.
//!
//! # 0.1 is a first cut
//!
//! Everything here may change or disappear in a later `0.x`. No API is settled and no migration is
//! promised. The surface is not a design that was drawn and then filled in — it is what the entry
//! rule below has admitted so far.
//!
//! # The entry rule, which is not a phase
//!
//! Nothing enters until something LIVE asks for it: the codegen emits a path that has to resolve, a
//! test names a type it cannot compile without, a downstream crate breaks for the want of it. There
//! is no round where an item is added because it will probably be needed and revisited later. This
//! crate was empty when that rule was written and it is not empty now; the rule is what the
//! difference was grown by, and it is what the next version will be grown by too.
//!
//! # Where items come from
//!
//! `legacy/ingraph` — the previous `ingraph`, moved and renamed `ingraph-legacy`, still building
//! and still green. It is a source to pull from, not a codebase under repair.
//!
//! The rule for taking something out of it is MOVE, NOT REWRITE. The item crosses as it stands,
//! together with its tests, and it is re-read on the way. The re-reading is where judgement is
//! spent; the keystroke is a move. An item that arrives rewritten has lost the one thing the
//! legacy crate was keeping for it, which is the record of what it was already made to survive.
//!
//! # Why a demand filter and not a cleanup pass
//!
//! What the previous crate accumulated was not bad code. It was items whose REASONS had died: a
//! seam for a backend nobody ever opened, a knob belonging to a design that had since been
//! replaced, a conversion for a vocabulary two refactors ago. Reading such a crate to decide what
//! to delete does not scale — every item still reads as defensible on its own, and the evidence
//! that would condemn it is the ABSENCE of a caller, which is not visible from the item.
//!
//! A demand filter never has to make that judgement. An item with a dead reason is structurally
//! impossible here, because entry requires something live to ask, and a dead reason has nothing
//! left to ask with.
//!
//! # When `legacy/ingraph` is deleted
//!
//! When nothing points at it. That is the acceptance criterion, and it is mechanical on purpose —
//! not a call about whether the remainder still looks worth keeping, and not a final pass to
//! decide. While one edge into it survives, it stays. When the last edge goes, it goes.
//!
//! # Why items travel with their tests
//!
//! `legacy/ingraph` carries ~41k lines of tests, and what those encode is not structure — it is
//! MEASUREMENT. Engine probe results (what a deleter does rather than what its docs say; what a
//! maintenance call corrupts under concurrent writes), byte fences over durable rows, mutation
//! pins standing exactly where a plausible-looking change was proven wrong. None of it is
//! recoverable by reading the item it guards, and re-deriving it costs what it cost the first
//! time. The tests are therefore not a follow-up to a move — they are part of one.
//!
//! # What the root re-exports, and what it does not
//!
//! The root carries what a PERSON writes: the traits a downstream implements or names —
//! [`FromFilter`], [`TryFromFilter`], [`ToDatabaseComparison`], and `Carrier` and [`TemporalStorage`]
//! where their features are on — and the storage types a declaration names, which are resolved in
//! the DECLARER's own scope and so have to be reachable under a name a declarer can `use`.
//!
//! Those storage types are the one group whose re-export carries NO backend's feature, and the
//! difference is load-bearing rather than tidy. [`BeU64`] and its neighbours are declared in
//! `storage`, beside no family at all, because a big-endian encoding names no database: gating them
//! on `sqlx` — which is where they used to sit — made a `u64` field declarable on SQLite and
//! undeclarable on MongoDB for a reason belonging to neither.
//!
//! [`FieldName`] is here for a second reason on top of that one: it is what every backend family
//! addresses a column or a key by, so putting it beside one of them would make the other's use of
//! it read as a borrowing. [`SlotName`] joins it under no feature for the first reason alone — an
//! index's name is written where the impl naming it is, and a `const` is spent in the declarer's
//! scope.
//!
//! [`Transformer`], [`FulltextRecord`] and [`FulltextTable`] are on the first count and share the
//! second: they are what a full-text declaration implements, and a document, a key and a slot name
//! no engine, so a build with no backend family has to be able to spell all three. The engine's
//! half of that surface is no longer a record trait at all: A′ took the record off the engine
//! seams, so what an engine names is its own entry builder and its own address vocabulary — and
//! there is no per-engine capability left at all, since a key reports itself in COLUMNS ([`Field`],
//! one impl per TYPE) and every engine reads every row. [`LocalFsBlobRecord`] is still here under
//! nothing, a backend that needs no feature having no gate to carry.
//!
//! The QUERY layer is not lifted either, and this one is a NAME rather than a family: `Edge` is
//! already the arrangement layer's word for a channel between two nodes, and a relay edge is a row
//! with a cursor on it. Two vocabularies, one word — which the module structure has already solved,
//! so `query::Page` and `query::Edge` stay together at their real path rather than one of them
//! being renamed to reach a root the other could not. [`query`] is public for that reason.
//!
//! The TRANSPORT is not lifted either, and it is the same argument at a different register:
//! `Sender`, `Receiver` and `bounded` are the plainest words a channel has, and a root that already
//! carries [`Outbox`], [`Inbox`], [`Feed`] and a `channel` FUNCTION would be answering to two
//! vocabularies through one door. So [`conduit`] is public and its household stays at that path —
//! where `conduit::Sender` reads as the general transport and cannot be mistaken for the declared
//! data edge one layer up.
//!
//! [`shard`] keeps its household for the same reason and one of its own: `Router`, `Bench` and
//! `Crew` are a DEVICE's vocabulary rather than the framework's, and a root that answered to them
//! would be saying that a node's internal crew is something this crate arranges. It is not — the
//! framework knows what nodes exist and how they connect, and what stands behind a node's door is a
//! library a body reaches for by name.
//!
//! A backend family's implementation surface stays at its real path. The comparison types, their
//! conjunction accumulator and the render helpers are what an expansion emits rather than what
//! anyone writes, so they live at `comparison::sql` and are not lifted. The rule is worth stating
//! because the alternative looks harmless: flattening a family into the root costs nothing at the
//! moment it is done and quietly makes the second family's `SqlNullable` and `MongoNullable` a
//! naming problem the module structure had already solved.
//!
//! # The four gates
//!
//! [`if_sqlite!`], [`if_postgres!`], [`if_mysql!`] and [`if_mongo!`] are the root's BACKEND macro
//! surface and the whole of it: each expands the tokens it is given where THIS crate was built with
//! that backend, and to nothing where it was not. ([`bare_options!`], [`bare_origin_options!`] and
//! [`bare_resource_options!`] are the root's three other macros, and they are a different kind of
//! thing — see the launch walk's own note for why a question about a trait impl can only be asked
//! at a call site.)
//!
//! What they are public FOR is that a per-backend half of a declaration is not always emitted. A
//! composite comparison, a conversion only the declaring crate knows how to write, a kind this crate
//! does not ship — those are written BY HAND beside the emission, and a hand-written half for one
//! backend has exactly the coupling an emitted one has. The gate is what relieves it, and it is the
//! same macro the emission spends rather than a second one shaped like it.
//!
//! ## Why a `#[cfg]` asks a different question
//!
//! `#[cfg(feature = "postgres")]` is evaluated in the crate it is WRITTEN in, against that crate's
//! `Cargo.toml`. A declaration living in an application has no `postgres` feature of its own, so the
//! predicate is false wherever the application did not happen to declare a same-named feature — and
//! true, wrongly, wherever it declared one meaning something else. The attribute reads as though it
//! asked *is Postgres compiled in*, and asks *did this crate name a feature `postgres`*, which is a
//! different question with a coincidentally similar spelling.
//!
//! A macro moves the decision to where the answer is. The `#[cfg]` that selects which definition is
//! compiled is `ingraph`'s own, read against `ingraph`'s feature table; the crate invoking it only
//! invokes it. So the condition is evaluated once, by the crate that knows, and the expansion carries
//! no predicate at all.
//!
//! ## A gate may name what the build does not have
//!
//! Each gate slurps `tt`s rather than `item`s, and that is the property a hand-written half spends.
//! An `item` fragment is PARSED before it is matched, so a gate over tokens naming a type only some
//! builds have would fail to parse in the builds that do not — which is the failure a shut gate
//! exists to avoid. Tokens are matched without being parsed, so a shut gate discards them before
//! anything in them has to resolve: `use ingraph::comparison::mongo::…` inside [`if_mongo!`] is
//! silence in a build without MongoDB rather than `E0432`.
//!
//! ## What a gate makes a declaration MEAN
//!
//! An item behind one of these exists per **declared ∩ compiled-in** backend. A declaration naming
//! three databases in a build carrying one gets the one, and the other two are not deferred — there
//! is no impl, so a party demanding one is `E0277` where it demands it.
//!
//! That is what keeps DECLARE-MANY/BUILD-ONE intact while the storability audit is on. Naming a
//! concrete backend in an impl discharges every column's crossing at that backend, which is the audit
//! and is the point; done ungated it would also make a declaration that names Postgres fail to
//! compile in a build without the Postgres driver, which is the invariant [`query::sql`] states from
//! the other side. Gated, the audit runs for exactly the backends the build has, and a build
//! compiling two engines and choosing between them by an options file at runtime has proved at
//! COMPILE time that every record it stores is storable in both.
//!
//! # The words a declaration is written in
//!
//! [`macro@record`], [`macro@entity`], [`macro@fields`], [`macro@operator`], [`macro@fulltext`],
//! [`macro@vector`],
//! [`macro@blob`], [`macro@interface`], [`macro@graph`], [`macro@resource`],
//! [`macro@journal`] and [`macro@mutation`] are `ingraph-derive`'s attribute macros, re-exported
//! here whole under the `derive` feature. `#[ingraph::record(…)]` is the spelling.
//!
//! [`derive@Enum`] and [`derive@Union`] are the two DECLARATION DERIVES, and the form is the
//! difference in what the word does: the attributes above REWRITE the item they sit on, where these
//! two add impls beside a type they never change. `#[derive(ingraph::Enum)]` is the WHOLE of what a
//! vocabulary takes — the storage citizenship, the filter and the wire face are one word, because
//! which schema an enum reaches is reachability rather than a second declaration — and
//! `#[derive(ingraph::Union)]` equips a payload-carrying enum with the way Rust asks which member it
//! holds, plus whichever of the two schema positions its `graphql(…)` word asked for.
//!
//! They are at the root for the reason everything above is, and the rule needed no widening to
//! reach them: THE ROOT CARRIES WHAT A PERSON WRITES, and a declaration is the thing a person
//! writes most. What is new is only that the surface is not a type — a trait a downstream implements
//! and an attribute a downstream applies are the same kind of name from the vantage that matters,
//! which is the one where somebody is holding a pen.
//!
//! ## ONE dependency, and the expansion is what makes it one
//!
//! A macro crate re-exported at its framework's root is usually a convenience. Here it is what makes
//! the default expansion correct. Every one of these emits `::ingraph::__private::…` absolutely —
//! see [`__private`] for why an emitted path is rooted and not resolved — so an expansion lands in a
//! crate where the name `ingraph` has to denote the framework. Reaching the attribute through the
//! same crate is what guarantees that: the dependency supplying the word and the dependency
//! supplying the path it writes are one entry in one manifest, and cannot be half-present.
//!
//! `crate = "path::to::ingraph"` is the escape for a consumer that renamed the dependency or reaches
//! the framework through a shim of its own, and it stays what it was — the option is for a crate
//! whose `ingraph` is somewhere else, not for one that has to assemble the framework from two.
//!
//! ## Why the words are DEFAULT-ON
//!
//! Every feature outside the tier ladder below is something a build ASKS for: a vocabulary it
//! declares fields of, a wire binding, a dialect, an engine. This one is what the crate looks like
//! to the party that declares against it, and a root surface reachable only by naming a feature is
//! not a root surface — a declarer would meet the framework by first being told the framework is
//! off.
//!
//! The opt-out is what makes that defensible rather than a decision taken for everybody:
//! `default-features = false, features = ["runtime"]` declines the whole proc-macro tier, and a
//! consumer that RUNS a graph and declares nothing gets exactly what it had. The tier is spelled
//! back because this feature IMPLIES it — see [the tiers](#the-tiers) — so dropping the default
//! drops the layer with it unless the layer is asked for by name.
//!
//! ## `ingraph::interface` is a module AND an attribute
//!
//! It is not a collision and needs no rename on either side: a module lives in the type namespace
//! and an attribute macro in the macro namespace, so `ingraph::interface::InterfaceKind` and
//! `#[ingraph::interface(…)]` resolve past each other. `record` and `operator` are the same shape
//! against private modules. The claim is pinned from outside the crate in `tests/downstream.rs`,
//! which is the only vantage a public name can be judged from.
//!
//! ## The macro crate keeps its own name
//!
//! `ingraph-derive` is still a crate, still published, still tested directly — this is a SECOND name
//! rather than a move. Its own corpus spells `ingraph_derive::record` on purpose: that suite's
//! subject is the macro, and a fixture reaching it through this re-export would be testing the
//! re-export instead.
//!
//! # The tiers
//!
//! Three features cut the crate into a LADDER rather than a lattice — `derive` ⊃ `runtime` ⊃
//! `engine` ⊃ the core — each naming the one below it. A build picks a rung; there is no
//! combination to get wrong and no powerset to test.
//!
//! - **The core**, which is `default-features = false`, is the VOCABULARY layer: what a declaration
//!   is spelled in and what it lowers through. The scalar roster and the filter machine, the marker
//!   interpretation, the comparison crossing traits, the storage forms, the keys and cursors, the
//!   column shapes and the schema descriptions. A downstream crate that declares field types of its
//!   own and joins this crate's filter vocabulary — implementing [`ToGraphqlFilter`], [`Marker`],
//!   [`ScalarFilter`] and their neighbours for its own types — needs exactly this and no rung above
//!   it.
//! - **`engine`** adds `retrieve`: the road a question travels, the mechanisms a `dedup(…)` word
//!   selects between, the fold semantics, the fusion tree and the search tower. It pulls no
//!   dependency at all, which is why it is a rung rather than part of the one above.
//! - **`runtime`** adds `arrange`, `drive`, `operator`, `resource` and `source` — the layer that
//!   RUNS a graph — and six dependencies with them: `flume`, `cronp` and `agnostic-lite`, which are
//!   what the layer cannot run without, and `derive_more`, `futures-core` and `futures-sink`, which
//!   are what nothing BELOW the layer ever named. The five modules arrive as one word because they
//!   name one another: no cut inside the block leaves a compilable half. It also
//!   carries `jiff-tz`, jiff's TIME ZONE DATABASE, because `drive::poll::calendar` is the one
//!   thing here that asks for a zone by name — a build below this rung keeps every jiff type and
//!   loses only the resolution of an IANA name. That word is public, so a build wanting the database
//!   and not the scheduler names it and stops.
//! - **`derive`** adds the words a declaration is written in, and implies `runtime`.
//!
//! ## Why `derive` implies `runtime`
//!
//! Because an expansion writes `::ingraph::__private::<segment>::<Item>` ABSOLUTELY and cannot put
//! a `#[cfg]` over one. A `#[cfg(feature = "runtime")]` written inside an expansion asks whether
//! the DECLARING crate has a feature by that name, which is [the four gates](#the-four-gates)'
//! whole subject — so the alternative is a gate macro pair of this crate's own wrapped around every
//! emitted path that names a tiered segment. The implication states it once instead, and states it
//! where a consumer can read it.
//!
//! What the implication forbids is a build that can DECLARE a graph and has no layer to run one,
//! which is not a configuration anyone asked for: a declaration IS a graph.
//!
//! A consumer reaching the attributes as `ingraph_derive::record` rather than `ingraph::record` is
//! outside the implication and names the tier itself. That is one crate — this workspace's own
//! fixture corpus — and its manifest says so where the dependency is declared.

// THE TIER LADDER, pinned here rather than trusted to the manifest. Both implications are stated in
// `Cargo.toml` and both are load-bearing in a way an ordinary build never exercises: `derive`'s is
// what keeps every emitted shelf path resolving, and `runtime`'s is what makes the feature matrix a
// chain of named lanes instead of a lattice. An edit dropping either word would compile HERE and
// fail in somebody else's crate at the first expansion, so it fails here instead — with the sentence
// that names the row that lost its word.
#[cfg(all(feature = "derive", not(feature = "runtime")))]
compile_error!(
  "the `derive` feature must imply `runtime`. An expansion writes `__private::drive`, \
   `__private::source`, `__private::operator`, `__private::resource` and `__private::retrieve` as \
   absolute paths and cannot gate one, so a build carrying the words and not the layers is `E0433` \
   at every declaration. Restore `derive = [\"dep:ingraph-derive\", \"runtime\"]`."
);
#[cfg(all(feature = "runtime", not(feature = "engine")))]
compile_error!(
  "the `runtime` feature must imply `engine`. A driven node is what answers a retrieve, and the \
   tiers are a chain so the matrix is a set of named lanes rather than a powerset over independent \
   words. Restore `runtime = [\"engine\", …]`."
);
// THE THIRD IMPLICATION, and the one the compiler would refuse anyway. `TimeZone::system` does not
// EXIST without jiff's `tz-system`, so dropping `jiff-tz` from `runtime` is already a red build —
// what this line buys is the SENTENCE. Without it the reader gets `E0599: no function or associated
// item named `system` found for struct `TimeZone`` at `drive::poll::calendar`, which names neither
// the row that lost a word nor the manifest it lives in.
#[cfg(all(feature = "runtime", not(feature = "jiff-tz")))]
compile_error!(
  "the `runtime` feature must imply `jiff-tz`. `drive::poll::calendar` resolves a schedule's zone — \
   `TimeZone::system()` for a bare cron word and `TimeZone::get(name)` for `tz = \"…\"` — and the \
   first of those is compiled out of jiff without its `tz-system` feature. Restore `runtime = \
   […, \"jiff-tz\"]`."
);

// THE CRATE UNDER ITS OWN NAME, and it exists for exactly one seat: `primitives::lang`'s two
// composed filters wear `#[derive(ingraph::Filter)]`, which is the SAME door a declaring crate uses
// and whose expansion writes `::ingraph::__private::…` absolutely. Without this line that path has
// nothing to resolve to inside the crate that defines it, and the family would have to restate its
// wire faces by hand — two hand-written copies of what the emitter already writes, in the one place
// where a drift between the two would be invisible.
//
// It is not a general licence to derive here. Every FILTER KIND this crate ships is hand written
// through `filter_input_object!`, because a kind is the framework's own vocabulary; the language
// family is a DECLARATION the framework happens to ship, and it is declared the way a downstream
// declares one. The gate on `primitives::lang` says the same thing in the feature table.
#[cfg(feature = "derive")]
extern crate self as ingraph;

// SIX of these ride a TIER, and the gate is on the `mod` line rather than inside the bodies: a tier
// a build declined costs it no line at all, and the module list is where a reader can see in one
// screen what each word is.
//
// `runtime` carries FIVE — `arrange`, `drive`, `operator`, `resource`, `source` — and the five are
// one word because they are one strongly connected block: `drive` names the other four and each of
// the four names `drive` back, so no cut inside leaves a compilable half. `engine` carries
// `retrieve`, the query road, which pulls no dependency and is therefore free to offer separately.
//
// The rest is the CORE, which every build has: the vocabularies a declaration is spelled in, the
// filter and comparison machinery it lowers through, the storage forms and keys, and the
// descriptions a schema is stated with. A downstream crate that declares field types and joins the
// filter vocabulary — the measured floor — needs none of the six.
#[cfg(feature = "runtime")]
mod arrange;
pub mod batch;
mod column;
pub mod comparison;
#[cfg(feature = "runtime")]
pub mod conduit;
mod cursor;
mod document;
#[cfg(feature = "runtime")]
mod drive;
mod election;
mod field;
/// The FLAGS VOCABULARY — a bit set a column holds, and the free functions that read one.
///
/// PUBLIC, where `marker` and `column` are private and re-exported: the module's contents are what
/// a person writing a flags column by hand reaches for — the strict text form, the name list, the
/// three operand doors — and grouping them under one word is what keeps nine helpers off the root.
/// The TRAIT is re-exported below regardless, because emitted code and hand-written impls both name
/// it.
#[cfg(feature = "flags")]
pub mod flags;
mod gate;
mod graphql;
mod id;
pub mod interface;
mod lane;
mod marker;
mod measure;
mod name;
#[cfg(feature = "runtime")]
mod operator;
mod ordering;
mod primitives;
mod project;
pub mod query;
mod reason;
mod record;
#[cfg(feature = "runtime")]
mod resource;
#[cfg(feature = "engine")]
mod retrieve;
mod route;
mod schema;
mod script;
#[cfg(feature = "runtime")]
pub mod shard;
#[cfg(feature = "tokio-signal")]
pub mod signal;
mod slot;
mod sort;
#[cfg(feature = "runtime")]
mod source;
mod state;
mod storage;
mod store;
mod transform;

// The root carries what a PERSON writes: the crossing traits a declaration implements or names, the
// sink a hand-written converter takes, the surfaces a downstream joins a family's vocabulary
// through, and the storage types a field declaration spells. What only an EXPANSION writes is
// addressed where it lives, at `comparison::sql` and `comparison::mongo`: the comparison kinds, the
// clause machine and the rendering vocabularies are not names this crate answers to at its root.
//
// The arrangement layer is at the root for the reason the compute unit is: a topology is DECLARED
// by hand — the builder, the typed handle it mints, the two vocabularies a node and an edge are
// declared with, the frozen graph a person reads layers off, and the three refusals validating one
// can state. Nothing about it is emitted, so there is nothing here an expansion reaches instead.
//
// Under `runtime` with the rest of its block: a topology is checked in order to be RUN, and the
// four layers it wires are all behind the same word.
#[cfg(feature = "runtime")]
pub use arrange::{
  ArrangeError, ChannelGraph, CycleError, DirectFanoutError, DriverKind, Edge, EdgeEndpointError,
  EdgeId, FanoutKind, GraphBuilder, Node, NodeHandle, NodeId,
};
#[cfg(all(feature = "jiff", feature = "time"))]
pub use comparison::TemporalStorage;
// The MongoDB family's own join surface, and one name more than the SQL family needs at this level:
// a SQL comparison's backend is `sqlx::Sqlite` and its siblings, which a declarer already has from
// sqlx, while MongoDB's is this crate's own. Without it here the type every `ComplexComparison`
// bound has to spell would be the one type a person could not `use` from where they are looking.
#[cfg(feature = "mongo")]
pub use comparison::mongo::{Mongo, MongoCarrier};
// `NullOrder` joins `BindCeiling` and `QuoteIdent` for their reason: it is a per-dialect capability
// a DIALECT implements, and a dialect this crate does not ship is written by hand.
#[cfg(feature = "sqlx")]
pub use comparison::sql::{BindCeiling, Carrier, JsonElement, NullOrder, QuoteIdent};
#[cfg(all(feature = "mysql", feature = "jiff"))]
pub use comparison::sql::{MySqlDuration, MySqlDurationError};
#[cfg(all(feature = "postgres", feature = "jiff"))]
pub use comparison::sql::{PgDuration, PgDurationError};
// `ToFlattenedComparison` is deliberately NOT here: it is blanket-implemented, so nobody writes one,
// and the only party that spells it is an expansion — which reaches it through the shelf. A
// downstream joins the vocabulary by implementing `CompositeComparison` on its own comparison, which
// is why that one is.
pub use comparison::{
  At, Backend, CollapsibleComparison, ComplexComparison, CompositeComparison, Frame, FromFilter,
  Path, RecordAddress, ReferentialComparison, ToDatabaseComparison, ToRelatedComparison,
  TryFromFilter,
};
// The ORDERING family, beside the comparison one it mirrors and for that block's reasons. A level
// sequence names no engine, so a build with no backend family still spells it; `ToCrossedOrderBy` is
// here where `ToCrossedComparison` is not, because it is blanket-implemented over a map a PERSON
// writes and a reader looking for what a citizen teaches finds both halves in one place.
pub use ordering::{
  FromGraphqlOrderBy, OrderLevel, ToCrossedOrderBy, ToDatabaseOrderBy, ToOrderLeaves,
  TryFromGraphqlOrderBy,
};
// The keyset cursor, under no backend's feature: a position in a written order is not a row, and
// nothing here binds one. What a value's bytes ARE may still be the engine's — a page cursor is
// session-lived state rather than a durable id, so [`DialectCursor`] lets one value have a dense form
// at one store and another at the next. All of it is what a PERSON writes or names — [`CursorValue`]
// is the row a downstream storage type joins the vocabulary through, [`CursorCodec`] is the seat a
// household mounts its own byte form at, the two mismatches are what a caught refusal is read
// through, and the rest is what a declaration's typed face hands out and takes back.
pub use column::{
  CollectionElement, ColumnEq, ColumnKind, ColumnName, ColumnShape, DeclaredLeaves, OrderLeaves,
  StoredAs, derived, distinct, flattened, joins, leaf_names, leaf_shape, shape, spans,
  stored_column, value_width, width,
};
// The READ half of a column shape, carrying the gate its `sqlx::Row` does — the surface a downstream
// COMPOSITE joins the decode through, exactly as it joins the width through [`ColumnKind`] and the
// bind through [`Carrier`].
#[cfg(feature = "sqlx")]
pub use column::{
  Assemble, NonZeroColumnError, PartialCompositeError, assembled, assembled_flattened, plain_column,
};
// The pattern column's refusal, on both gates: a read is `sqlx`'s and a pattern is `regex`'s.
#[cfg(all(feature = "sqlx", feature = "regex"))]
pub use column::PatternColumnError;
pub use cursor::{
  ArityMismatch, Cursor, CursorCodec, CursorError, CursorValue, DialectCursor, OrderFold,
  OrderLevels, OrderMismatch, OrderSignature, OrderTerm, TermName, TermSubject, Walk, dialect,
  read_member, write_member,
};
pub use document::{BoxWriter, Searchable};
// The DRIVE layer, at the root for the arrangement layer's reason and one more of its own. A
// topology is declared by hand, and so is everything that runs one: an app implements
// [`LifecycleTap`] and registers it, a consumer builds an [`Ack`] and states a [`Lifecycle`], a
// backend implements [`AsyncChanges`] for its own store, and a deployment writes an [`Enablement`].
// Nothing here is emitted, so there is nothing an expansion reaches instead.
//
// Under the LAYER's own word and no backend's: a channel names no database, and the three delivery
// modes are one vocabulary whether or not a build compiles a backend to listen to. The SQLite floor
// and the shipped tap keep a second gate each, because those are a floor for one engine and a tap
// naming one library rather than the protocol — so each carries `runtime` AND its own.
#[cfg(all(feature = "runtime", target_os = "macos"))]
pub use drive::Darwin;
#[cfg(all(feature = "rayon", feature = "runtime"))]
pub use drive::Rayon;
#[cfg(feature = "runtime")]
pub use drive::{
  Ack, AckMode, AckReceiver, AckSender, AfterClock, Answer, Answered, Answers, App, Arm,
  ArrangementError, Arrival, Assembly, AsyncAnswers, AsyncChanges, AsyncConstructor,
  AsyncInitialize, AsyncLands, AsyncServes, AsyncSpawn, AsyncTeardown, AsyncTick, AtMostOne,
  Attached, Attaches, Attributes, Autonomous, AutonomousBody, Awaiting, Backpressure, BareOptions,
  Blueprint, BoxedError, Buffered, CURRENT_TABLE_PREFIX, Cadence, Calendar, CalendarError, CatchUp,
  Cell, ChangeIntake, ChannelOptions, ChannelShelf, Channels, Coalesce, Commit, Concern, Context,
  Creation, Culled, Curator, CuratorBody, CuratorReport, CurrentRow, CurrentTable, Custody,
  DEFAULT_BATCH_MAX_ITEMS, DEFAULT_BATCH_MAX_WAIT, DEFAULT_DEBOUNCE, DEFAULT_FEED_DEPTH,
  DEFAULT_IN_FLIGHT, DEFAULT_KEEP, DEFAULT_RETIRE_DRAIN, DEFAULT_SETTLE, DeadlinePolicy, Deadlines,
  Declared, DeclaredResident, DefaultServe, Delivery, DisabledUpstreamError, Door, Doorbell,
  Downstream, Drained, DriverEngine, Drives, DropNewest, DropOldest, DroppingUnboundedError,
  EdgeTypeError, Effect, Enablement, Enrolled, Evictor, Failure, Fate, FeedContext, FeedPolicy,
  Feeder, FeederAbsentError, Fixed, Flip, Flow, FulltextAsk, FulltextScope, GenerationLedger,
  Generational, GenerationsEngine, GenerationsOptions, GenerationsOverride, GenerationsStore,
  GenerationsStoreError, Goodbye, Grant, GrantsNoStoreError, Group, Habitats, Handover, Harvest,
  Helm, Hint, Ignition, InFlight, Inbox, Initialize, Initializes, Intake, IntakeError, Invoke,
  Invokes, Item, ItemId, Joins, JournalDrain, JournalQueue, JournalRow, JournalTap, JournalWriter,
  Keeper, KeeperBody, KeeperReport, Landing, Lands, LandsNowhereError, LaneMount, LaunchError,
  Ledger, Lifecycle, LifecycleTap, Lineage, Listen, MakesNothing, MandatoryOptionsError,
  MandatoryResourceOptionsError, MemoryAware, MemoryProbe, Missed, MissingResourceError, Mount,
  MountBody, MountedLane, NoDeadline, NoDefaultOptions, NoRetry, NodeAttribution, NodeBody,
  NodeName, NodeSection, NodeWiring, Notified, Nudge, Observation, Occupancy, Onward, Outbound,
  Outbox, OverflowDecision, OverflowPolicy, Owed, Owing, Page, Pairing, Party, Payload,
  PayloadIter, Plan, Policies, PolicyShelf, PollUpstream, PositionKey, Positions, Posted, Pressure,
  ProductSeatError, Pulled, PureLeafError, QueryArm, QueryDeadline, QueryError,
  RETIRED_TABLE_PREFIX, RUN_COLUMN, ReceiptMap, RecordedPositions, RecordingTap, Recurrence,
  Refusal, Registries, Registry, RegistryCounts, RegistryDriver, RegistryOptions, RegistryOverride,
  Reply, Resident, ResourceSourceError, Resources, Responding, RetireOrigin, RetiredEngine,
  RetiredLedger, RetiredMirror, RetiredOptions, RetiredReader, RetiredReaders, RetiredRow,
  RetiredStore, RetiredStoreError, RetiredTable, Retirement, Retries, RetryDecision, RetryPolicy,
  Rings, RootAction, RootAdvance, RootKey, RootProjection, RootState, RunId, Rung, Runs, Schedule,
  Scope, Seats, Serve, Served, Serves, Settled, SettledParts, Share, ShedKey, Sheds, Shutdown,
  Sink, SlotBinding, SlotLane, Socket, Spawn, SplitOriginError, Staging, Stamp, Station, Steady,
  Stopped, StreamBody, StreamLane, StreamOptions, StreamWires, Streamed, Streaming, Streams,
  Sweeper, Swept, TakenInboxError, Tally, Taps, Tasks, Terminal, Thread, Tick, TickDecision,
  TickPolicy, Ticked, Ticker, Ticks, TracingLevel, Track, Turning, UNDIVIDABLE, UnboundCorpus,
  UnboundSlotError, UnbridgedOriginError, UnbuiltTargetError, UncataloguedResourceError,
  Unchanneled, UndeclaredResourceError, UnknownGenerationsEngine, UnknownGrantError,
  UnknownNodeError, UnknownRetiredEngine, UnknownUpstreamError, UnnameableFamily, UnnameableScope,
  UnnameableTable, Unpoliced, Unpolled, Unpressured, Unreceipted, Unruntimed, Unsettled, Untorn,
  Unwritten, Upstream, UpstreamWiring, Upstreams, Vanished, VectorAsk, VectorScope, Wake, Wanted,
  Wired, Wiring, Worn, Written, ack_channel, arm, channel, door, doorbell, drive_awaited_origin,
  drive_origin, journal_queue, open, park_on, prepare, rebuild, reply, select,
};
// The ORIGIN LAYER's launch seam, at the root with the rest of the drive layer: `Lived` is the row a
// declaration's own mode word selects, `Mounted` is what a declared mount hands a deployment back
// and `Bridged` is what one whose feed IS a graph edge hands back instead, and the three aliases are
// the projections a signature over any of them would otherwise spell.
#[cfg(feature = "runtime")]
pub use drive::{Bridged, Died, Lived, Mounted, Ordered, Produced, Tuned};
// The RETIRED LEDGER's ENGINES, gated where their drivers are — the seam itself
// (`RetiredStore`, `Keeper`, `RetiredMirror`) is ungated with the rest of the drive layer, because a
// deployment may write a store of its own for a home this crate ships no driver for.
#[cfg(all(feature = "mongodb", feature = "runtime"))]
pub use drive::MongoRetired;
#[cfg(all(
  feature = "runtime",
  any(feature = "sqlite", feature = "postgres", feature = "mysql")
))]
pub use drive::{RetiredSql, SqlRetired};
// The GENERATIONS SEAT's SQL half, gated exactly where the retirement ledger's is and for its
// reason: the seam itself (`GenerationsStore`, `Curator`) is ungated with the rest of the drive
// layer, because a deployment may write a store of its own for a home this crate ships no driver
// for. There is no `mongodb` row beside it — see `GenerationsEngine`, where the missing fourth word
// is argued.
#[cfg(all(
  feature = "runtime",
  any(feature = "sqlite", feature = "postgres", feature = "mysql")
))]
pub use drive::{GenerationsSql, SqlGenerations, current_filter};
#[cfg(all(feature = "sqlite", feature = "runtime"))]
pub use drive::{SqliteFeed, SqliteFeedError, SqlitePositions, SqlitePositionsError};
// The SHIPPED TAP, at the root under the observation feature — beside the seam it implements, and
// gated where the seam is not, because it is the one tap in this crate that names a library outside
// it. `TracingLevel` above is ungated with the rest of the drive layer: the level is what a
// declaration says and what the model carries, and a word has to be nameable in the build that
// parses it.
#[cfg(all(feature = "tracing", feature = "runtime"))]
pub use drive::TracingTap;

pub use field::FieldName;
// The FLAGS KIND's vocabulary trait and the two types beside it. At the root for the reason every
// marker trait is: a declaration satisfies it, so it has to be nameable without reaching through a
// module a declarer was never told about. The nine free functions stay in `flags` — they are read
// by the wire faces and by a hand-written column, and neither is a root-surface conversation.
#[cfg(feature = "flags")]
pub use flags::{FlagBit, FlagsValue, UnknownFlag};
// The CONFIDENCE KIND's five names are in this list, and each is spelled outside this crate: a
// client writes a `ConfidenceOperand`, a caller building a filter by hand names `ConfidenceFilter`,
// a type that wants that filter implements `ScoreKind` — which is the framework's OPEN axis for the
// confidence family — and the two refusals are read by a person at either end. `ConfidenceWire` is
// the sealed WIDTH half beside it: nobody outside implements it, and a helper generic over the width
// its own confidences measure in still has to name it.
pub use graphql::{
  BooleanFilter, Builtin, BytesFilter, ConfidenceFilter, ConfidenceOperand, ConfidenceOperandError,
  ConfidenceWire, EnumFilter, EqualsFilter, FilterSlot, FixedBytesFilter, GraphqlFilter,
  ListFilter, ManyOperands, NestedFilter, Nullable, OneOperand, OrderDirection, QuantifiedFilter,
  RefFilter, RelatedFilter, ScalarFilter, ScoreKind, SetFilter, Std, SubjectPath, TextFilter,
  ToGraphqlFilter, ToSubjectPath, TryMapFilter, UnrepresentableConfidence,
};
#[cfg(feature = "flags")]
pub use graphql::{FlagsFilter, FlagsInput, FlagsView};
/// The DELEGATION TRAIT a nullable column's wire face is written over — the seam a downstream
/// filter joins `Nullable<F>` through, since neither side can write the impl itself — and the
/// SHORTHAND LAW's own reading, which every filter face in every crate answers by asking it.
///
/// [`SlotFace`] rides here beside them: it is the WIRE half of the composed mode's slot seam, and
/// the emptiness half — [`FilterSlot`] and its three kind markers — is above, where a build with no
/// binding still has it.
///
/// [`FlattenFace`] is the same mode's other field kind — the component a `#[ingraph(flatten)]` field
/// SPLICES into its host — and it is here for [`NullableFace`]'s own reason: it is a reading OF that
/// row, so a face that satisfies one satisfies both and neither is written by hand.
#[cfg(feature = "async-graphql")]
pub use graphql::{FlattenFace, NullableFace, Sent, SlotFace, sent};
// The wire ERROR contract, at the root because both ends of it are spelled outside this crate: a
// refusal implements `ToErrorCode` where it is declared, and a caller's own tests assert the word
// `ErrorCode` renders. Unconditional for the reason the subject vocabulary is — an expansion cannot
// spell a feature of this crate — while the two ATTACHMENTS name async-graphql's own error types
// and ride the binding below.
pub use graphql::{ErrorCode, ToErrorCode};
// The order DECODE, at the root because a client's list arrives through it and a caught refusal is
// read there: `Orderings` is what a resolver's order argument is spelled as, and `RepeatedSubject`
// is what one of them refuses with. Behind the binding's feature, where the decode is.
#[cfg(any(feature = "jiff", feature = "async-graphql"))]
pub use graphql::{DurationFilter, DurationOutOfRange};
// The WIRE CARRIERS, at the root because both ends of one are spelled outside this crate: a filter's
// operand is written by a client and an OUTPUT position returns the carrier itself, so an emitted
// face and a hand-written resolver both name these.
//
// UNCONDITIONAL, where they used to ride the binding. A carrier is a newtype and two total
// conversions; what names a GraphQL library is the `#[Scalar]` CITIZENSHIP, and that is what the
// feature gates. The split is the law the projection seams follow — a map from a domain type to the
// form it crosses as is one thing every binding shares, so nothing on the map's side may demand a
// backend's trait.
pub use graphql::{
  F32, F64, FixedU8Array, HexBytes, HyphenatedUuid, I8, I16, I32, I64, I128, NetIpAddr,
  NetIpv4Addr, NetIpv6Addr, NetSocketAddr, NetSocketAddrV4, NetSocketAddrV6, SmolBytes, U8,
  U8Vector, U16, U32, U64, U128,
};
#[cfg(any(feature = "jiff", feature = "async-graphql"))]
pub use graphql::{JiffCivilDateTime, JiffDuration, JiffZoneOffset};
// The half-precision width, beside the twelve above and behind the vocabulary feature that
// supplies its operand: `half::f16` is a dependency's type, so the carrier and its scalar arrive
// with the word and a build that names no half-precision value compiles neither.
#[cfg(feature = "half")]
pub use graphql::F16;
// The WIDEST float row, beside the thirteenth and behind its own vocabulary feature. Its operand is
// a STAND-IN — `rust_decimal::Decimal` is base-ten and not IEEE binary128 — so the word buys the
// crate and the scalar's description tells a client exactly what it is reading.
#[cfg(feature = "rust_decimal")]
pub use graphql::F128;
// THE COMPILED PATTERN's carrier, behind the word that supplies its operand. It sits with the two
// widths above rather than with the twelve unconditional ones for their reason — `regex::Regex` is a
// dependency's type — and it is the first carrier here whose crossing does WORK: reading one
// compiles the pattern, so a refusal is a real answer and not a formality.
#[cfg(feature = "regex")]
pub use graphql::RegexPattern;
#[cfg(feature = "async-graphql")]
pub use graphql::{
  Orderings, RepeatedSubject, refused, refused_address, refused_filter, refused_input, refused_row,
};
// THE ROOT-KEY REGISTRY'S OWN FACE — `RegistryQueryRoot` and `RegistryMutationRoot` are what an
// application mounts (`Schema::build(<Root>Query::default(), RegistryMutationRoot::default(), …)`,
// exactly as `SqlDoor` is installed rather than emitted); the rest are the wire types its fields and
// arguments answer in. See `graphql::registry`'s own module note.
#[cfg(feature = "async-graphql")]
pub use graphql::{
  RegistryCountsView, RegistryEntry, RegistryFamily, RegistryMutationRoot, RegistryOptionsView,
  RegistryOrigin, RegistryQueryRoot, RegistryState,
};
// `search_slot` and `vector_slot` ride here for the crossings' own reason one paragraph down: an
// emitted resolver reaches them through `__private`, and a HAND-WRITTEN one — which is what a
// deployment writes wherever the emission has not reached — has to be able to spell the same road.
//
// A LINE OF THEIR OWN, because the road they open is the SHARED-RESOURCE layer's: what each looks up
// is a `Shared<R>`, so the pair rides `runtime` on top of the binding where the names above ride the
// binding alone.
#[cfg(all(feature = "async-graphql", feature = "runtime"))]
pub use graphql::{search_slot, vector_slot};
// The TWO CROSSINGS, at the root for the carriers' own reason: a wire face RETURNS through one and
// READS through the other, and a downstream type joins either map by writing its own row — so an
// emitted face, a hand-written resolver and a declaring crate all name these.
//
// Unconditional beside the carriers, and for the same law: a map says which FORM a value crosses as
// and asks nothing about who renders or parses that form. What a backend needs of the form it
// demands where it SPENDS it — at the emitted face, inside its own gate.
//
// The three READINGS ride with them because they are the axis a declaring crate implements to give
// its own type a filter face: the marker is that crate's, and the trait it carries is one of these.
// One per filter kind whose face is written over a carrier — `TextWire` for the substring family,
// `ScalarWire` for the ordering one, `BytesWire` for the byte one — because a reading is written per
// kind and one declarer type may be read under two of them.
//
// `WrongByteWidth` rides with them because it is a `BytesWire::Error` a CLIENT of this crate can be
// handed: the fixed-width row is the framework's own, so its refusal is the framework's to name.
//
// `OutsideTheInterval` rides here for `WrongByteWidth`'s own reason one row over: it is the
// `ToGraphqlInput::Error` of the framework's own confidence, so a client that writes a confidence
// ELEMENT past the interval is handed this crate's sentence and a caller matching on it spells the
// type.
//
// `ZeroOperand` is the third of them and the `NonZero` family's: those ten widths cross on their
// underlying integer's roster scalar, so `0` is a well-formed operand that the CROSSING refuses, and
// the sentence a client reads is this crate's.
pub use graphql::{
  BytesWire, InputCrossing, OutputCrossing, OutsideTheInterval, ScalarWire, TextWire,
  ToGraphqlInput, ToGraphqlOutput, WrongByteWidth, ZeroOperand,
};
// The OUTPUT crossing's HOLDING adapter, one line below the map it spends and behind the binding the
// map is not: `Crossed` is a `#[Object]` resolver's return type, so what it satisfies is one
// library's `&self` contract rather than the neutral fact a form is. At the root because both ends
// of one are spelled outside this crate — an emitted face returns it, and a hand-written resolver in
// the same position (a value it MADE rather than a place it holds) returns it too.
#[cfg(feature = "async-graphql")]
pub use graphql::Crossed;
// The PAGE's wire face, at the root for the order decode's reason one argument over: a resolver
// names `Connection` in its signature and `PageRequest` in its body, and a caught refusal is read
// where the resolver is. `Page` and `Edge` stay at `query::` — see the crate note on the name — and
// this is the OTHER side of that split: what a page becomes on the wire, not what it is.
#[cfg(feature = "async-graphql")]
pub use graphql::{Connection, PageArgument, PageError, PageRequest, UnraisedPage};
// The RETRIEVE ANSWER's wire face, at the root for the page's own reason: a face that answers a
// search names `Match` in its signature and reaches `matches` in its body, and both ends are written
// outside this module. `Ranked` stays where it is — what a retrieve ANSWERS, not what that answer
// becomes on the wire — and this is the other side of that split. ONE of them and not two: the two
// tiers are this type at two INSTANTIATIONS, the node being an address at one road and an entity at
// the other, which is a fact about the declaration and not about the wire face.
#[cfg(all(feature = "async-graphql", feature = "engine"))]
pub use graphql::{Match, matches};
// The FOLDED ANSWER's wire face, beside the pair above and for the same reason at the other arity: a
// set road's face names `FoldedMatch` in its signature and reaches `folded_matches` in its body. The
// slot type rides with them because it is a POSITION in that answer rather than a type anybody builds
// — its only constructor is the crossing from the fold's own slot — and a client selecting
// `streams { score ordinal }` is naming it whether or not this list does.
#[cfg(all(feature = "async-graphql", feature = "engine"))]
pub use graphql::{FoldedMatch, StreamSighting, folded_matches};
// The CURRENCY BOUND those faces name their score seat with, at the root because it appears in
// the SIGNATURE of every one of them: a declaration or an application writing a hit type by hand
// spells `S: WireScore`, and a bound reachable only through a module path would be a bound the
// public types demand and a caller cannot name.
#[cfg(feature = "async-graphql")]
pub use graphql::WireScore;
// The THREE SEAMS A SCHEMA-ASKED RECIPE REACHES ITS MEMBERS THROUGH, at the root because a
// THIRD-PARTY member and a hand-written recipe both spell them: `FusedEngine` names the one engine a
// resolver can be concrete over, `FusedCitizen` mints the asking position out of the citizens a
// schema was built with, and `WireRoot` is what the answered root becomes in each of the two
// published tiers. The RUST road needs none of the three — a caller that holds the handles asks which
// is why they live behind the binding and beside the hit types rather than with `Fusable`.
#[cfg(all(feature = "async-graphql", feature = "engine"))]
pub use graphql::{FusedCitizen, FusedEngine, WireRoot};
// The READ DOOR, at the root because an APPLICATION spells it: the door is what a schema build
// installs and what every emitted resolver then finds by its own type, so both ends of it are
// written outside this crate. Behind the binding AND the SQL family, which is exactly where it is
// reachable — the wall it answers is a resolver's `Send` bound over a sqlx surface, and neither half
// alone has one.
#[cfg(all(feature = "async-graphql", feature = "sqlx"))]
pub use graphql::{SqlDoor, SqlSource};
// THE THIRD DOOR, at the root for the read door's reason and UNCONDITIONAL for the batching seam's:
// an APPLICATION installs it and every emitted locate field finds it by its own type, so both ends
// are written outside this crate — and what its core type names is a store handle behind an `Arc`,
// which neither the wire binding nor any backend is needed to spell. Only `install` reaches
// async-graphql, and it is gated there.
//
// THE SEARCH DOOR IS NOT AMONG THEM ANY MORE. It was `SearchDoor<E, T>` — a per-(engine ×
// declaration) citizen an application installed — and the resource axis retired it: a leg POINTS at
// a `#[ingraph::resource]` declaration rather than naming an engine, so the citizen an emitted
// resolver looks up is the `Shared<R>` the launch already built, and the openness a `SearchSource`
// carried moved into the MOUNT SEAM (`FulltextMount` / `VectorMount`). See `graphql::search`.
pub use graphql::{BlobDoor, BlobSource};
// THE FOLD DOOR, beside the search road and installed by the same act: it carries the POLICY a set
// road's `m` streams are folded by, keyed one grain finer — per (engine × election) rather than per
// (engine × declaration) — because a declaration electing two sets has two sets of query vectors and
// no reason to fold them alike. Under no BINDING for the search door's reason: what it holds is a
// fold behind an `Arc`, and only `install` reaches async-graphql. `installed_fold` is the emitted
// resolver's own lookup and is gated with it.
//
// Under `engine`, because a fold is `FoldSemantics` and that is the query layer's trait: the door's
// own field spells it, so a build with no query road has nothing for the door to hold.
#[cfg(feature = "engine")]
pub use graphql::FoldDoor;
#[cfg(all(feature = "async-graphql", feature = "engine"))]
pub use graphql::installed_fold;
// THE TOWER DOOR, on the fold door's road and under the same tier: it carries the ASSEMBLED question
// road a bound tower is walked over — the mint a deployment installs, and the `<Tower>StepOptions` a
// launch names once, beside the walk BUDGET it may take. `installed_road` is the emitted resolver's
// own lookup and is gated with it, and `InstalledRoad` is what that lookup answers — a name for the
// triple rather than a citizen of its own, at the root because a hand-written caller spelling the
// return type has to be able to say it.
//
// Under `engine`, because what it holds is `AssembledTower`'s two projections and that is the query
// layer's trait: a build with no query road has nothing for the door to hold.
#[cfg(feature = "engine")]
pub use graphql::TowerDoor;
#[cfg(all(feature = "async-graphql", feature = "engine"))]
pub use graphql::{InstalledRoad, installed_road};
// The REQUEST FACE's sentence, at the root because a hand-written tower reads its note to learn the
// one line to write. Behind the binding alone: it is a blanket over `InputType` and holds nothing of
// the query layer.
#[cfg(feature = "async-graphql")]
pub use graphql::SearchOptionsFace;
// The TWO ARTIFACT FIELDS' own walks, behind the wire gate because that is the only half naming
// async-graphql: each emitted field is three acts in one order — the door, the suffix, and then the
// address or the bytes — and an emitter writing them inline would put one copy per artifact position
// into every record's expansion, where a fix to the order or to the refusal is a divergence rather
// than an edit.
#[cfg(feature = "async-graphql")]
pub use graphql::{
  UnwrittenArtifact, artifact_store, locate_artifact, locate_signed_artifact, read_artifact,
  read_signed_artifact,
};
// The BATCHING SEAM, at the root for the read door's reason exactly: an APPLICATION installs the
// door and every emitted resolver finds it by its own type, so both ends are written outside this
// crate. UNCONDITIONAL, where the read door is gated, and the difference is what each one names —
// the read door's surface is a sqlx pool inside an async-graphql schema builder, and this seam's is
// a trait, a Clone-able error and an erased handle. The seam is what a SECOND wire backend or a
// caller with no wire at all would bind, so gating it on the first one would have made the
// neutrality unreachable.
pub use graphql::{AsyncBatchLoad, BatchAnswer, BatchDoor, BatchError, Batched};
// The BINDING and the SHIPPED PROVIDER, each behind exactly what it names: the binding is
// async-graphql's coalescing engine (two crates in this graph, paid by who asks), and the provider is the
// id-gather lane read through the SQL read door.
#[cfg(all(feature = "dataloader", feature = "async-graphql"))]
pub use graphql::AsLoader;
#[cfg(all(feature = "async-graphql", feature = "sqlx"))]
pub use graphql::SqlRows;
// The sealed id vocabulary, at the root because a DECLARATION spells a key field's type and the
// refusal for a non-member has to land where that field is written. The typed id beside it for the
// same reason: it is what a field spells where the id alone would not say which record it addresses.
// And the DELEGATION beside both, because the vocabulary's third admission law is written in a
// downstream crate — the door has to be reachable from wherever a wrapper is declared. The STORAGE
// SEAM joins them one duty down and for the same reason: `IdColumn<Db>` is the row a downstream
// INNER writes so that every id wrapping it reaches a column, and a seam reachable only from inside
// this crate would be no seam.
pub use id::{DelegatesId, Id, IdColumn, TypedId};
// The declaration family, whole — the words a declaration is written in, and the only re-export here
// that reaches past this crate. See the crate note for why the root is where they belong, why the
// feature carrying them is the one default, and why `interface` beside the module of that name is
// two namespaces rather than a collision.
//
// The DERIVES are at the root for the same reason the attributes are: each is a word a person
// writes, and its expansion emits `::ingraph::__private::…` exactly as theirs do, so reaching them
// through this crate is what guarantees the path resolves.
//
// `Enum` gives a declared vocabulary its whole citizenship and `Union` a declared member set its
// own — the two DECLARATION derives, each equipping a type somebody else wrote and rewriting
// nothing, which is the test the family's forms are split on. `Comparison`, `Filter` and `OrderBy`
// are the STANDALONE family: the bare doors of the three per-column emissions `record` composes, so
// a hand-written struct gets the same faces a declaration gets, from the same emitter.
//
// `mutation_error` and `query_error` are the odd pair here, and their oddity is worth naming: they
// are the only words in the family that are OPTIONAL to the framework. Every other one emits
// something this crate then reads back — a record, a row, a face — and those two emit a `Display`
// and an `Error` over somebody else's enum, which a hand-written impl provides exactly as well.
// They are at the root because they are words a person writes; nothing here requires either.
//
// `aggregate` is here on the same terms and one state behind them: its GRAMMAR is built and its
// EMISSION is not, so a declaration that passes every rule is refused with a sentence naming the
// task it is waiting for. It is re-exported anyway, deliberately — withholding the word would make
// `#[ingraph::aggregate]` read as *cannot find attribute*, which is rustc's sentence about a word
// that does not exist, told about one that does.
#[cfg(feature = "derive")]
pub use ingraph_derive::{
  Comparison, Enum, Filter, NewType, OrderBy, Union, aggregate, blob, entity, fields, fulltext,
  graph, interface, journal, mutation, mutation_error, operator, query_error, record, resource,
  search, source, tower, vector,
};
// `flags` is re-exported ON ITS OWN, and the split is not tidiness: this crate also carries a
// `flags` MODULE, and one name in two namespaces is legal — a module lives in the type namespace and
// an attribute macro in the macro namespace — but only where the two `pub use`s are separate items.
// So `ingraph::flags(u32)` is the door and `ingraph::flags::text` is the helper, and neither
// shadows the other.
//
// It rides `derive` like the rest of the family. The `flags` FEATURE is a different question and is
// implied by this one, because the expansion names `__private::bitflags` absolutely.
#[cfg(feature = "derive")]
pub use ingraph_derive::flags;
// `Id` is re-exported ON ITS OWN for `flags`' reason, one namespace pair over: this crate also
// carries an `Id` TRAIT — the sealed key vocabulary — and a trait lives in the type namespace where
// a derive macro lives in the macro namespace. Two separate `pub use` items is what makes the pair
// legal, so `ingraph::Id` is the bound a signature writes AND the word a declaration derives, and
// neither shadows the other.
//
// The name is the TRAIT's on purpose: `#[derive(ingraph::Id)]` reads as *this type is an id*, which
// is the `derive(Clone)` convention and the whole of what the door does. The record's
// `#[ingraph(id)]` FIELD word is untouched and still means which column is the address, so the two
// live in different grammars and no declaration has to disambiguate them by position.
#[cfg(feature = "derive")]
pub use ingraph_derive::Id;
// The interface's own vocabulary, at the root because a DECLARATION spells all of it: an emitted
// discriminant implements the capability and an emitted binding states its arms, so a build with no
// backend family still has to be able to name them. `KIND` stays inside the module, as
// `query::sql`'s `ELEMENT` does — an alias is the ENGINE's name for a position in a statement, and
// a caller never writes one.
pub use interface::{HydrationError, InterfaceArm, InterfaceColumn, InterfaceKind, UnknownKind};
// The INTERPRETATION system, at the root because both ends of it are written by hand: a declaring
// crate says how its own type is read — one `*FilterMarker` row per family it answers, a
// [`DefaultMarker`] row for the reading it takes when a declaration names none — and a declaration
// names a marker directly wherever a column must differ from what its type infers.
//
// Ungated, and one level above the binding that first consumed it. What a column MEANS is asked by
// every consumer of a declaration; what that meaning RESOLVES to is one axis's answer, and the rows
// carrying those answers stay with their axis. A marker under `graphql` would have made a second
// wire binding reach the vocabulary it answers over through the FIRST binding's module.
pub use marker::{
  BoolFilterMarker, BoolMarker, BytesFilterMarker, BytesMarker, CompositeFilterMarker,
  CompositeMarker, DefaultMarker, DefaultVecMarker, DurationFilterMarker, DurationMarker,
  EnumFilterMarker, EnumMarker, ListFilterMarker, ListMarker, Marker, NullableMarker,
  OptionalMarker, QuantifiedFilterMarker, QuantifiedMarker, ScalarFilterMarker, ScalarMarker,
  SetFilterMarker, SetMarker, StringFilterMarker, StringMarker,
};
#[cfg(feature = "flags")]
pub use marker::{FlagsFilterMarker, FlagsMarker};
// The AGGREGATE FOLD, at the root because both ends of it are written by hand — and the second end
// is the point. [`Measure`] is the contract a declaring crate implements for a fold this framework
// ships no word for, named in the declaration as `measure(<field> = "path::to::Fold")` and resolved
// by rustc at the string its author wrote; [`Counting`] and [`Summing`] are the two the bare words
// name, and they are here for `dedup(eq)`'s reason one family over — which one a node uses is
// written in its declaration, so a bare word names a type a declarer has to be able to see.
//
// UNGATED, with the kind it serves: an aggregate is record sugar and `record` is ungated, and the
// open half would otherwise sit behind a feature the kind never uses.
pub use measure::{Counting, Measure, Summing};
// The five VARIANT namespaces, under no feature for [`FieldName`]'s reason and one more: a word
// names no driver, so a build with one backend has to be able to spell the others' names — and what
// a build's features decide is which per-backend impls a vocabulary carries, not which words exist.
pub use name::{GraphqlName, MongoName, MysqlName, PostgresName, SqliteName};
// The compute unit and everything an `accept` body spells: the buffer it emits through, the
// refusal it states, and the standalone edge check. All of it is written by hand — an operator IS
// the app's code — so all of it is at the root. BOTH FACES are here for that reason, and so are the
// two MODES that name them, the shape they share and the bridge a declared mode word crosses into a
// bound on: `type Mode = Block;` is written by hand in every node that is not emitted.
//
// The STREAMING pair rides beside them for that reason and no other: a body whose fan-out grows with
// its input is still the app's code, so the face it writes against is a name a PERSON spells. It
// brings no seats of its own — a `run` names `Feed`, `Fin` and `ShutdownSignal`, which the origin layer
// already publishes at this root — which is the whole of what reusing the endings verbatim costs
// here.
//
// Under `runtime` with the block it belongs to: an operator is a body a DRIVER calls, and the two
// name each other.
#[cfg(feature = "runtime")]
pub use operator::{
  Async, AsyncAutonomousOperator, AsyncOperator, AsyncStreamOperator, AutonomousOperator, Block,
  Driven, Emission, Emits, Emitter, Operator, ProductKind, Products, Receipts, Selected, Selects,
  Skip, SkipLabel, SkipReason, SoleProduct, StreamOperator, Word, subscribe,
};
// The value types this crate DECLARES, at the root for the reason a declaration's own words are: a
// field spells one, and a build with no feature at all has to be able to name it. `Timestamp` is
// under no gate for the second half of that sentence — jiff is a required dependency here, so the
// framework's own instant is not something a build asks for.
// `TimestampPartsError` rides beside the type for the reason every refusal vocabulary in this list
// does: a decode hands one back, so a caller matching on it spells it at the root.
// `ConfidenceCarrier` rides beside `Confidence` for the reason `TimestampPartsError` rides beside
// `Timestamp`: a bound nobody outside this crate can IMPLEMENT is still one a caller has to NAME, to
// write a helper generic over the width its own confidences measure in.
// `Count` is the third value type and the same sentence answers for it: a `counting` measure column
// is DECLARED as one, so it is a name a person writes. `NegativeCount` rides beside it exactly as
// `TimestampPartsError` rides beside `Timestamp` — a decode hands one back.
pub use primitives::{
  Confidence, ConfidenceCarrier, Count, NegativeCount, Score, Timestamp, TimestampPartsError,
};
// THE TIME-RANGE HOUSE, under no gate for `Timestamp`'s reason: its component is the framework's own
// instant, which every build has, so a record the FRAMEWORK ships can carry a stretch without the
// build having asked for anything. `InvertedTimeRange` rides beside the type exactly as
// `TimestampPartsError` rides beside `Timestamp` — a decode, a cursor read and a wire door all hand
// one back. `TimeRangeOperand` is here because a caller BUILDS one to fill a filter slot, and
// `PayloadFilter` because a declaration generic over what it timed has to be able to name the filter
// its payload gets. `Contained` and `ContainedOperand` are here because `contains` takes TWO SHAPES
// and a caller BUILDS the one it means; `ParseTimeRangeError` rides beside them because the half-open
// text form is what that operand's scalar door reads a span through.
pub use primitives::{
  Contained, ContainedOperand, InvertedTimeRange, ParseTimeRangeError, PayloadFilter, TimeRange,
  TimeRangeFilter, TimeRangeOperand, TimeRanged, TimeRangedFilter,
};
// The two SQL comparisons, beside the house for the reason every dialect-facing name in this file
// rides its family: a lowering is reached by the framework, and the ranged one is reached by being
// NAMED — see its own row.
#[cfg(feature = "sqlx")]
pub use primitives::{SqlTimeRangeComparison, SqlTimeRangedComparison};
// The WALL-CLOCK citizen and its faces, behind the two words that make them spellable: `time` for
// the column its local leaf reaches through, `derive` for the declared filter.
#[cfg(all(feature = "time", feature = "derive", feature = "sqlx"))]
pub use primitives::SqlLocalTimestampComparison;
#[cfg(all(feature = "time", feature = "derive"))]
pub use primitives::{
  LocalTimestamp, LocalTimestampFilter, LocalTimestampLeaf, LocalTimestampOperand,
  LocalTimestampPartsError, NoUtcPosition,
};
// And the MongoDB pair, which the lang house has no counterpart to: that family's storage rows are
// this backend's and its comparisons are not, so these two are the first RANGE questions any
// document store here can be asked.
#[cfg(feature = "mongo")]
pub use primitives::{MongoTimeRangeComparison, MongoTimeRangedComparison};
// THE LANGUAGE FAMILY, and it is the one entry in this list that publishes a MODULE beside its
// types. The five names are here for the sentence above — a `LanguageId` column is DECLARED as one,
// so every one of them is a word a person writes — and `lang` itself is here because
// `lang::registry` is a public surface with a job the types cannot do: a fold that a caller can only
// disagree with is a fold with no table to read, so the three rows that folded `ger-Latn-DE` into
// `de-DE` are readable. See `primitives::lang::registry`, where that is argued.
//
// The refusal vocabularies ride beside their types for `TimestampPartsError`'s reason, and the three
// `*Wire` markers ride beside theirs for `ConfidenceCarrier`'s: a filter over a subtag is
// `ScalarFilter<Language, LanguageWire>`, so the marker is a name a declaring crate has to spell even
// though it never constructs one.
#[cfg(feature = "derive")]
pub use primitives::{
  lang,
  lang::{
    DetectedLanguage, DetectedLanguageFilter, Language, LanguageId, LanguageIdColumnError,
    LanguageIdFilter, LanguageIdOperand, LanguageWire, ParseLanguageError, ParseLanguageIdError,
    ParseRegionError, ParseScriptSubtagError, Region, RegionWire, ScriptSubtag, ScriptSubtagWire,
  },
};
// The two SQL comparisons and the crossing refusal between them, beside the family for the reason
// every dialect-facing name in this file rides its family: a lowering is reached by the framework and
// its refusal is matched on by a caller.
#[cfg(all(feature = "derive", feature = "sqlx"))]
pub use primitives::lang::{
  LanguageIdCrossingError, SqlDetectedLanguageComparison, SqlLanguageIdComparison,
};
// THE GEOMETRY FAMILY, the THIRD module published beside its types and the first here that is
// UNGATED — `lang` rides `derive` and `mediatime` rides its own word, and this house has neither a
// dependency to admit nor a tier to need. See `primitives::geometry`, where the measurement is.
//
// Every name is one a person WRITES: the three holders and the coordinate are declared as field
// types, the three filters are what a caller builds to ask about one, and the two refusal
// vocabularies are what a constructor and a column hand back. `RefusedBox` is matched on by whoever
// builds a normalized rectangle, which is every producer of one. `Radians<T>` is the house's second,
// independent citizen — a face's roll, yaw and pitch, a horizon's tilt — declared as a field type
// exactly as the coordinate is, carrying no refusal of its own for a constructor to hand back, and
// generic on the same ruling as the three holders'. `RadianMath` is the small bound its
// `to_degrees`/`from_degrees` need and the seam a downstream carrier joins it through.
pub use primitives::{
  BoundingBox, BoundingBoxFilter, BoundingBoxLeaf, NormCoord, OutsideTheUnitInterval, Point2,
  Point2Filter, Quad, QuadFilter, RadianMath, Radians, RefusedBox, geometry,
};
// The three SQL comparisons, beside the family for the reason every dialect-facing name in this file
// rides its family: a lowering is reached by the framework. NO crossing refusal rides with them, and
// the absence is this house's shape — every operand belongs to a COMPONENT, so every refusal a
// crossing here can make is one the component family already names.
#[cfg(feature = "sqlx")]
pub use primitives::{SqlBoundingBoxComparison, SqlPoint2Comparison, SqlQuadComparison};
// THE DETECT FAMILY, the FOURTH module published beside its types and the second here that is
// UNGATED — see `primitives::detect`, where the measurement is the geometry house's read over a
// second set of facts.
//
// Every name is one a person WRITES: `Label` is minted by whoever has a word, the two composites are
// declared as field types and built by a producer, the two filters are what a caller builds to ask
// about one, and `EmptyLabel` is what a constructor and a column hand back. `LabelWire` is the
// marker a text filter over a label is NAMED by, which is a type a declaration spells wherever it
// spells the filter.
pub use primitives::{
  BarcodeDetection, BarcodeDetectionFilter, BarcodeDetectionLeaf, BarcodePayloadKind, Detection,
  DetectionFilter, DocumentSegment, DocumentSegmentFilter, EmptyLabel, Label, LabelWire,
  LocatedDetection, LocatedDetectionFilter, LocatedDetectionLeaf, Symbology, TextDetection,
  TextDetectionFilter, TextDetectionLeaf, detect,
};
// The two SQL comparisons, beside the family for the reason above. NO crossing refusal rides with
// them either: the classification half's crossing is infallible, and the located one's error is the
// geometry component's own.
#[cfg(feature = "sqlx")]
pub use primitives::{
  SqlBarcodeDetectionComparison, SqlDetectionComparison, SqlDocumentSegmentComparison,
  SqlLocatedDetectionComparison, SqlTextDetectionComparison,
};
// THE MEDIA-TIME FAMILY, the second one here and the second module published beside its types —
// `mediatime` itself is here for `lang`'s reason, that a house whose note carries the argument for
// its own names is a surface a reader has to be able to reach.
//
// Every name is one a person WRITES: `Timebase` and `MediaTimestamp` are declared as field types,
// the operands are BUILT to fill a filter slot, and `MediaContained` is built because `contains`
// takes two shapes and a caller picks the one it means. The refusal vocabularies ride beside their
// types for `TimestampPartsError`'s reason — a decode, a parse door and a wire crossing each hand
// one back.
//
// `MediaInstantBound`, `MediaSpanBound`, `MediaDurationBound` and `MediaContainedOperand` are here
// ungated by any face word, unlike the operands one line down, because they are the CARRIERS the
// filters' own slots hold: `MediaTimestampFilter`'s four bound seats take a `MediaInstantBound`
// whether or not the build has a wire face to parse one through.
#[cfg(feature = "mediatime")]
pub use primitives::{
  mediatime,
  mediatime::{
    InvertedMediaTimeRange, MediaContained, MediaContainedOperand, MediaDurationBound,
    MediaInstantBound, MediaSpanBound, MediaSpanDurationFilter, MediaTimeRange,
    MediaTimeRangeFilter, MediaTimeRangeLeaf, MediaTimeRangeOperand, MediaTimestamp,
    MediaTimestampFilter, MediaTimestampLeaf, MediaTimestampOperand, NanosecondOverflow,
    ParseClockError, ParseRateError, ParseTimebaseError, Rate, RateColumnError, RateFilter,
    Timebase, TimebaseColumnError, TimebaseFilter,
  },
};
// The two OPERAND SCALARS whose only door is the wire, beside the family for the reason the block
// above states in reverse: a `RateOperand` and a `TimebaseOperand` are what a filter's slot holds
// only where there is a face to parse one, so nothing in a build without one can name them.
#[cfg(all(feature = "mediatime", feature = "async-graphql"))]
pub use primitives::mediatime::{RateOperand, TimebaseOperand};
// The four SQL comparisons and the three crossing refusals between them, beside the family for the
// reason every dialect-facing name in this file rides its family: a lowering is reached by the
// framework and its refusal is matched on by a caller.
#[cfg(all(feature = "mediatime", feature = "sqlx"))]
pub use primitives::mediatime::{
  MediaTimeRangeCrossingError, MediaTimestampCrossingError, RateCrossingError,
  SqlMediaTimeRangeComparison, SqlMediaTimestampComparison, SqlRateComparison,
  SqlTimebaseComparison, TimebaseCrossingError,
};
// THE STREAM-DESCRIPTOR FAMILY, the third one here published beside its types and the second gated
// on a VOCABULARY word — `mediaframe` itself is here for `lang`'s and `mediatime`'s reason, that a
// house whose note carries the argument for its own names is a surface a reader has to be able to
// reach. That note is where the FIRST WAVE's scope and the language family's named refusal are.
//
// Every name is one a person WRITES: the three codecs are declared as field types, and the three
// `…Wire` markers are what a filter over one is NAMED by — a type a declaration spells wherever it
// spells the filter, which is `LabelWire`'s own row read over this house.
//
// NO refusal vocabulary rides with them, and the absence is the family's whole shape rather than an
// oversight: the door is TOTAL, so there is no parse error to name, no column error to match on and
// no crossing refusal to hand back. It is the first family here with nothing of the kind.
#[cfg(feature = "mediaframe")]
pub use primitives::{
  mediaframe,
  mediaframe::{
    AudioCodec, AudioCodecWire, SubtitleCodec, SubtitleCodecWire, VideoCodec, VideoCodecWire,
  },
};
pub use project::{Optional, Repeated};
// Beside the compute unit it serves rather than beside the other two names, and for the reason they
// are here: a refusal vocabulary is written by hand at both ends, so the type its two ends agree in
// is a name a person spells.
pub use reason::ReasonName;
pub use record::{
  ArtifactData, ArtifactStore, ArtifactSuffix, BlobArtifact, BlobRecord, BlobTable, FulltextRecord,
  FulltextTable, UnfencedSuffix, VectorRecord,
};
// The RETRIEVE face, at the root because a PERSON writes every name here: the query a caller builds
// (floor included, since a retrieve cannot be asked without one), the ranked item it reads back, the
// store seam a downstream implements for its own system of record, and the refusal it matches on.
//
// The two MECHANISM implementors ride along for the reason the dialect capabilities do: which one a
// node uses is written in its declaration, so `dedup(eq)` names a type a declarer has to be able to
// see. `keyed`, `vector_keyed`, `ranked_keys` and `filled` are the shared core the emitted methods
// delegate to — reached through the shelf by an expansion, and here because the hand-written face
// writes the same calls. The two address reads joined them with A′: the engine seams name no record,
// so reading an engine's own address back into a node's key is the emission's act and these are the
// lines it writes — one per engine family, since the two faces are two traits.
//
// The BY-KEY READ's own three names joined them one direction on, and for the same reason:
// `VectorRead::get` takes an address a KEY was written into, so `vector_addressed` is that write
// walk beside the two reads, `ranked_keys_excluding` is the pipeline with the example already seen,
// and `OwnReadError` is what a by-key door hands back when the KEY's own stored vector rather than
// the engine is the problem — a vocabulary a caller matches on, and ONE type because the emitted
// `get_<field>` makes those judgments and `retrieve_similar_by_<field>` reports them unchanged.
//
// The FUSION half is here for the same reason, one layer up: a client picks the fold and the grain,
// fills in the two per-member limit specs and reads the fused rows back. `Rooted` and `Join` are the
// seam an emitted graph-root face will reach through — at the root rather than behind the shelf,
// because the fold is callable by hand today and there is no emitted face to reach it through until
// a declaration can name the engine it is stored in.
//
// The MULTI-VECTOR road joins the same list for the same reasons, one name at a time. `FoldedQuery`
// is what a set-similarity question is written on and `Deferred` is what stands in its floor's place
// while the number is still the declaration's; `FoldSemantics` is the contract a fold satisfies and
// `Sum`, `Max` and `Weighted` are the three implementations shipped with it, all four written by a
// PERSON — the trait by a downstream with its own arithmetic, the citizens at a call. `Folded` is
// what a set retrieve answers with and `StreamBest` is one of its slots — what ONE query vector's
// stream said, carried out of the fold rather than left to be recomputed; `Bests` with its two
// implementors is the fold's mechanism, chosen by the same `dedup(…)` word that chooses `Seen`'s;
// `Sightings` is the row that mechanism accumulates, named at an instantiation and built by nobody
// outside the fold; `owner_best` / `set_scored` are the shared core the emitted set door delegates
// to, and `folded_filled` is `filled` at that answer's arity.
//
// The FUSION TREE's own vocabulary rides the same list for the same reason. `Fusable` is implemented
// per retrieving member — by the emission for a declaration, BY HAND for a third-party one, which is
// the whole of what makes the tree open; `Route` is what a parent wraps a child's package in and is
// spelled in every emitted tier package; `FusionOptions` and `RrfOptions` are what a client builds
// to pick a tier's fold; `asked` / `participates` are the question chain's law and `route_depth` is
// the depth chain's, all three callable by hand wherever a route has to be resolved.
//
// The EXPAND STEP's own vocabulary joins them, and every name on it is written by a party outside
// this crate. `QueryExpander` / `AsyncQueryExpander` are the two faces a deployment's own expander
// wears and `Expansion` is the seat one is mounted into — a hook, assembled, so the handle is what a
// road holds; `TextualQuestion` is the contract a tower's QUESTION type implements so that one
// text-class expander serves every textual tower; `Expanded` and `ExpandOrigin` are what a road is
// spelled in, and the origin is what a per-arm weighting reads.
//
// The ANNOTATION STAGE's one name joins them for the same reason and from one stage earlier:
// `AnnotatedQuestion` is what a tower's QUESTION type implements so a ⟂ step can ask it whether the
// caller already filled the seat — written by the question's author, read by the walk and by every
// stage after it.
//
// The ASSEMBLY ROW joins them from the far end of the same road, and every name on it is written by
// a party outside this crate too: `AssembledTower` is what a DEPLOYMENT's filled steps satisfy — the
// gate a launch is read by and the uniform `run` a resolver calls — and `SeatsUnfilled` /
// `UnfilledSeat` are what the gate refuses with when a declared word found no instance.
//
// The BUDGET HOUSEHOLD joins them from the same far end, and it is shelved HERE rather than beside
// the drive layer's deadline policies because of which law it belongs to: `tightened_budget` is the
// PROTECTIVE half of the three-tier numbers law whose preference half — `route_depth` — is already
// on this list, and the seat it composes for is a search tower's walk. `SearchBudget` is the number
// two tiers speak, `WalkClock` is the seam a deployment names its own runtime's sleep at,
// `WalkBudget` is the pair a launch installs, `walk_within` is the one place a budget bites and
// `BudgetSpent` is what it refuses with. Every one of them is written or read by a party outside
// this crate.
//
// Under `engine`, the whole face at once: this is the tier, and there is no half of it a build
// without the query road could spell.
#[cfg(feature = "engine")]
pub use retrieve::{
  AnnotatedQuestion, ArmWeights, AssembledTower, AsyncFusedRead, AsyncGather, AsyncQueryExpander,
  Bests, Binding, Bridge, BudgetSpent, DEFAULT_SNAPSHOT_CAPACITY, DEFAULT_SNAPSHOT_DEPTH,
  DEFAULT_SNAPSHOT_TTL, DeclaredSearch, DeclaredTower, Deferred, EqBests, EqJoin, EqSeen,
  ExpandOrigin, Expanded, Expansion, FanStream, FloorSpec, FoldSemantics, FoldVisitor, Folded,
  FoldedQuery, FulltextQuery, Fusable, Fused, FusedScore, Fusion, FusionOptions, Grain, HashBests,
  HashJoin, HashSeen, Held, Join, Max, Member, OwnReadError, PageToken, PageTokenRefusal,
  QueryExpander, Ranked, RankedStream, RetrieveError, Rooted, Route, RrfOptions, SearchBudget,
  SearchTower, Seat, SeatsUnfilled, Seen, SharedQuestion, Sighting, Sightings, SnapshotKeeper,
  Step, StreamBest, Stretch, Sum, TextualQuestion, TrySharedQuestion, UnfilledSeat, VectorQuery,
  WalkBudget, WalkClock, Weighted, asked, filled, folded_filled, fuse, fuse_fanned, fuse_weighted,
  keyed, owner_best, owner_best_excluding, participates, ranked_keys, ranked_keys_excluding,
  route_depth, set_scored, tightened_budget, vector_addressed, vector_keyed, walk_within,
};
// The paging LOOKUP, beside `installed_road` for its reason: it is the act an emitted resolver
// performs, and it needs the wire tier compiled to have a context to perform it on.
#[cfg(all(feature = "engine", feature = "async-graphql"))]
pub use retrieve::installed_keeper;
// The SHAREABLE-RESOURCE layer, at the root for the drive layer's reason: every name here is one a
// PERSON writes. A resource's author implements [`AsyncResource`] by hand, a declaration reaches the
// citizenship through the macro or writes it out, a unit spells `Shared<R>` as a field type, a
// launch drives a [`ResourceVisitor`] and a plan states a [`ResourceDemand`] per demanding node.
// Nothing here is emitted except the one marker impl the macro writes, which reaches it through the
// shelf.
//
// Under the LAYER's own word and no backend's: a resource names no database and no engine, and
// sharing a model is a fact about units rather than about storage — but a unit is what shares one,
// so the vocabulary arrives with the tier the units are in.
#[cfg(feature = "runtime")]
pub use resource::{
  AsyncResource, DeclaredResource, ResourceCatalog, ResourceDemand, ResourceKind, ResourceKinds,
  ResourceName, ResourceSource, ResourceVisitor, Shared,
};
// The SQL family's own bindings of that seam, under the family's feature — a backend implementation
// where the names above are the seam. TWO of them: the connection-borrowing one a Rust caller
// brackets its own read with, and the pool-backed one a `Send` resolver future can hold.
#[cfg(all(feature = "engine", feature = "sqlx"))]
pub use retrieve::{SqlGather, SqlPooledGather};
// The storage DESCRIPTION, at the root under no backend's feature — for the reason the storage forms
// are, one module over: a table's name, its columns and the type each is stored at are a
// declaration's facts, and the dialect that brackets them is the SQL family's. A
// `#[ingraph::record(…)]` now EMITS its `Describe<Db>` out of these, so what a person writes by hand
// is a graph node the macros do not declare — and the const audit rides along because both roads
// state it beside the record they describe.
pub use schema::{
  Column, CompositeUnique, Describe, EdgeShape, EdgeTable, ElementColumns, Shadow, SideTable,
  Table, TableColumns, describes,
};
// THE SCRIPT LAYER, at the root under NO feature and no backend's word — the one placement its two
// consumers leave open. A per-script fan cuts a transcript on the WRITE path and cuts a question on
// the READ path, and those two roads sit on opposite sides of the tier chain: gating this at the
// query tier would put it out of reach of the write side's own store layer, and gating it at the
// drive tier would put it out of reach of the question road it was built for. What they share is
// that it belongs to neither — it is UAX #24, which is a standard rather than a stage, and the
// closed book's own division is that the standard is infrastructure and the policy is downstream.
//
// It costs a build that never mentions a script exactly the lines it does not compile: no
// dependency rides here, the table is this crate's own, and the vocabulary's fold is `name`'s, which
// every build already has. That is the same measurement the `engine` tier's empty right-hand side is
// argued from, applied to something too small to be a tier.
//
// Every name is one a PERSON writes: a declaration names a script, a hand-written router matches one,
// and a fan calls the segmenter directly.
pub use script::{ScriptRun, ScriptRuns, WritingSystem, script_runs};
// THE LANE LAYER, at the root under NO feature — the script layer's own placement argument, and for
// the same two consumers on opposite sides of the tier chain. A fan cuts a corpus on the WRITE path
// and reaches one partition of it on the READ path, and what both spend is the roster and the gate.
//
// It is the NEUTRAL LAYER'S WHOLE SHARE of the fan, which is the ruling's own division rather than a
// stopping place: a lane exists because one engine has a physics, so the vocabulary lives in that
// engine's block and what crosses to everybody else is an opaque key. `Lanes` is the seam that
// crossing goes through; `lane_for` is the one road to a lane; `lane_collisions` is the audit a
// declaration, a boot walk and a downstream test all spend rather than each writing their own.
//
// Every name is one a PERSON writes: a hand-written slot implements `Lanes`, a router calls the
// gate, and a deployment's test calls the audit.
pub use lane::{
  Claimed, Lane, LaneCollision, LaneIdent, LanedStore, Lanes, LanguageTag, UnknownLane,
  lane_catch_all_repeats, lane_claim, lane_claim_repeats, lane_claims, lane_collisions, lane_for,
};
// THE ROUTING LAYER, at the root under NO feature — the script and lane layers' own placement
// argument, one road further on. A router is what turns ONE question into one probe per lane, and
// its two ends are the same two the segmenter and the gate already straddle.
//
// It is a CROSSING where the expand step is an endomorphism, and the taxonomy is the ruling's own:
// a router changes the type on its way through, so it mounts as a TYPED seat whose wiring is checked
// by equality, where an expander mounts erased because a deployment picks it at launch. Neither
// follows the other, which is why nothing here names anything of that road's.
//
// Every name is one a PERSON writes: a third party implements `LaneRouter`, a deployment mounts one
// of the two shipped routers on a `LaneFan`, and a boot walk spends `check`.
pub use route::{
  FanAll, FanError, LaneFan, LaneRouter, RoutedProbe, RouterMissing, ScriptRouter,
  ScriptWeightedFan, UnroutableLane,
};
pub use slot::SlotName;
// The order-preserving collection form, at the root under no feature — for the reason the storage
// forms below are there: the bytes a `sortable` collection's companion column holds name no
// database, and the trait one element type joins them by is implemented by a DECLARING crate.
pub use sort::{SortKey, collection_sort_key, push_collection_sort_key, push_escaped};
// The ORIGIN layer, at the root for the compute unit's reason exactly: a source IS the app's code,
// so every name here is one a PERSON writes. Both faces, because a body is written one way and the
// pair is what says which; the three seats a `run` body spends and the two endings it answers with;
// the mutation seat a controllable origin names and the `()` row that is the absence of one; the
// EXCHANGE one field of such a node is, which an author writes as a pair or implements on a type of
// their own; and the three MINTS with the framework-side halves they hand back, because a hand-wired
// arrangement and a test build a source's lines the same way a launch does.
//
// The DECLARATION RECORD rides along — `DeclaredMutation` and the two types its table is built from
// — for `Declared`'s reason exactly: a source's own expansion cannot read the mutation
// declaration's tokens, so the node states its facts here and whoever needs them names a projection.
// It is hand-writable, so its names are names a PERSON writes.
//
// Under the drive layer's own word and no backend's: an origin names no database and no wire
// binding, and the tier it rides is the one that drives it.
// `DeclaredOrigin` is the SOURCE's own half of the same arrangement: a launch walk that mounts an
// origin sees a type, so the origin states its face and its mounted node and the walk names them
// through a projection. Hand-writable for the same reason and on the same terms.
#[cfg(feature = "runtime")]
pub use source::{
  AckRefusal, Acked, AsyncSource, Commands, Control, DeclaredMutation, DeclaredOrigin, Exchange,
  Fallibility, Feed, Fin, Mutation, MutationNode, ShutdownSignal, Source, Stopper, Unacked, Unfed,
  Yielded, control, feed, shutdown_signal,
};
// The type-level projection layer, at the ROOT rather than inside `graphql`: what a `Vec` holds is
// not a wire fact, and `marker` is the layer's first consumer rather than its subject.
pub use state::{Extracted, Identity, Inner, State};
// The storage forms, under no backend's feature — see the module note for the split that put them
// here. `Temporal` keeps the gate its CONTENT needs, which is the temporal vocabulary and not a
// family: without `jiff` nothing implements `TemporalStorage` and the wrapper has no way to be
// built.
#[cfg(all(feature = "jiff", feature = "time"))]
pub use storage::Temporal;
pub use storage::{Anon, BeI128, BeU64, BeU128, Embedding};
// The ELECTION family, at the root because a DECLARATION is what spends it: a downstream carrier
// implements `EmbeddingMarker` by hand to make its own type electable, an emission projects every
// fact about an elected field through these, and the two audits are what a label's claim is stated
// as. The two multiplicity markers ride along because a carrier's impl names one of them.
pub use election::{
  ElectsOne, ElectsSet, EmbeddingMarker, EmbeddingShape, Multiplicity, One, Set, elects_a_set,
  elects_one,
};
// The storage seams, at the root because a BACKEND is the party that writes one and a backend is
// hand-written — this crate implements none of them for anybody. `Connected`, `Scored` and `Hits`
// ride along because a backend spells all three in signatures of its own: the resources an op
// takes, the hit a search returns, and the list it returns them in. None belongs to a family,
// which is why none is reached through one.
//
// `Slot` and `Refused` ride along as the ENGINE GRAMMAR's own two, and for the same reason: a
// deployment NAMES a slot when it opens a handle, and a caller of a `fanout` write MATCHES on which
// leg refused. Both are spelled by hand at a call site, so both are root names.
//
// The EIGHT VERB FACES ride along for the same reason the engine traits do, and it is the sharper
// half of it: a face is what a CALLER binds — a retrieve names a read face, a drainer a write one,
// and each picks its mode — so these are the names a bound is written with rather than only the
// ones a backend implements.
//
// The CONFORMANCE WALK is a root name for the sharpest form of that reason: `round_trip_vector` and
// `round_trip_fulltext` are what a backend author RUNS, over their own key types, from their own
// crate, and a factory part reached through a private module is a factory part nobody finds.
// `ConformanceError` and `ColumnDoor` ride along because a caller matches on the first and reads
// the second inside it. `ColumnDoor` and not `ColumnKind`: that name is taken by the storage-schema
// trait above, and the two ask unrelated questions.
pub use store::{
  AsyncBlobEngine, AsyncBlobStore, AsyncFulltextRead, AsyncFulltextStore, AsyncFulltextWrite,
  AsyncLocate, AsyncVectorRead, AsyncVectorStore, AsyncVectorWrite, BlobEngine, BlobLocation,
  BlobStore, Bound, ColumnDoor, ColumnError, ColumnReader, ColumnWriter, ConformanceError,
  Connected, Elected, Field, FulltextColumn, FulltextEngine, FulltextLane, FulltextMount,
  FulltextRead, FulltextRoad, FulltextStore, FulltextSubset, FulltextWrite, Hits, IndexRefusal,
  KeySegments, LocalFsBlob, LocalFsBlobError, LocalFsBlobRecord, LocalFsStore, Locate,
  MAX_PATH_LEN, MAX_SEGMENT_LEN, NoColumns, Noop, PathTooLong, Refused, Scored, Segment,
  SegmentTooLong, Segments, Slot, SlotHandle, Utf8Bytes, VectorColumn, VectorEngine, VectorMount,
  VectorRead, VectorStore, VectorWrite, blob_address, round_trip_fulltext, round_trip_vector,
};
// The Tantivy backend, at the root under its ENGINE's feature — where the filesystem blob backend is
// at the root under none, a backend that needs no feature having no gate to carry. Every name here
// is one a PERSON spells: the manager and its handle, the write capability a keyed replace is
// serialized by, the entry an emission builds and the address vocabulary its values cross into.
//
// There is no per-search knob type among them any more. The one this backend had held `k` and
// nothing else, and `k` is a positional parameter of the verb now — so the read scope is `()` and
// the name went with the room.
//
// `TantivyTerms` and `TantivyColumns` are the ADDRESS LIFECYCLE's two phases at this backend, and
// they are root names for the reason the address is: a caller that spells `E::buffer()` or
// `E::open(…)` by hand holds one, and a third-party engine reads them as the reference shape of a
// `ColumnWriter` / `ColumnReader` pair.
//
// There is no per-slot SCHEMA type among them any more either. The one this backend had carried the
// `stored` posture and nothing else, and the posture is now one member of the framework's own
// `SlotSchema` — the FULL-TEXT KIND's blueprint, which a declaration writes and a slot maker
// creates from. What tantivy's own doors take is the posture itself.
#[cfg(feature = "tantivy")]
pub use store::{
  KeyDecodeError, LaneAnalyzers, SlotMismatch, SlotWriter, TantivyAddress, TantivyColumns,
  TantivyDoc, TantivyFulltext, TantivyFulltextError, TantivyStore, TantivyTerms, UnknownAnalyzer,
};
// The SLOT MAKER, one word further in than the rest of the backend: it is a LAUNCH's machine, and
// what it walks is a `Shared<R>` — so it takes `runtime` on top of the engine's own feature where
// the doors above take the engine's alone.
#[cfg(all(feature = "runtime", feature = "tantivy"))]
pub use store::TantivySlotMaker;
// The entity binding, the two vocabularies its record and wire members answer, the order capability
// beside them and the relation half after that — at the root for the reason the record faces are: a
// declaration implements all of it, and neither an address, a row form, an order, a wire face nor a
// relation names an engine, so a build with no backend family has to be able to spell them. The
// wire family in particular is library-neutral: it names which types a face has, never what any
// GraphQL library does with them. The three AUDITS ride along because a declaration is what spells
// one: they are what a derive emits per `ref` and per reverse position, and a hand-written
// declaration writes the same lines.
// The HABITAT VOCABULARY rides along, and it is the sharpest form of that reason: a target's
// blueprint is what a DEPLOYMENT's own resource declares (`impl Habitat for MyQdrant`), and the
// three descriptors are what an emission and a hand-written declaration both spell.
// `AsyncTypeVisitor` is beside its twin because a slot maker is written by whoever owns the engine.
pub use transform::{
  AsyncTypeVisitor, Graphql, GraphqlInput, GraphqlOutput, Habitat, Hydrates, Identifiable,
  Implements, Layout, OneReference, Record, Reference, Related, SlotColumn, SlotSchema, SlotSpec,
  Transformer, TypeVisitor, has_a_wire_face, ids_are_keys, implements, one_field_points_back,
  refers_through, refers_to, stores_rows,
};

/// The names generated code refers to — **not** part of this crate's API.
///
/// Every framework name an expansion writes is rooted here and nowhere else, as
/// `#krate::__private::<module>::<item>` with no exception, so emitted code depends on this shelf
/// rather than on where an item actually LIVES. The framework can move or rename one without
/// regenerating anyone's expansion. The public paths are unaffected and are what a human writes:
/// `impl ingraph::ScalarFilterMarker for MyType` satisfies a bound the macro wrote through
/// `ingraph::__private::marker::ScalarFilterMarker`, because the two names are the SAME trait —
/// one re-exported from the other.
///
/// It MIRRORS this crate's module structure, one glob re-export per module, rather than flattening
/// every emitted name into one namespace. Two properties come from that:
///
/// - **It needs no maintenance as the crate grows.** A glob picks up a module's new public items
///   on its own, so adding an emitted reference means touching the emitter and nothing here.
/// - **Nothing collides.** Two modules may each define a `Column` or an `Error`; mirroring keeps
///   them apart, where a flat namespace would force renames inside this module and let the emitted
///   path drift away from the real one.
///
/// What it carries is this crate's own names PLUS the VENDORED crates it re-exports, and no wider
/// than that. A vendored crate earns a place here when the emitter controls EVERY path in the
/// emitted code that names it, which happens two ways: its derive can be TOLD where the crate lives
/// (`serde`, through `#[serde(crate = "…")]`), or there is no derive to tell because the emitter
/// writes the impl itself (`sqlx`, whose own derive names `::sqlx` absolutely and cannot be
/// redirected). What does NOT earn a place is a re-export that only resolves a macro whose output
/// still names the crate absolutely — that buys a consumer nothing while implying otherwise. A
/// vendored crate keeps its own name as its segment, so it mirrors just as a module does.
///
/// `#[doc(hidden)]` keeps it out of the documentation, and the name says the rest. Nothing here is
/// covered by this crate's stability promises.
#[doc(hidden)]
pub mod __private {
  /// Mirrors [`crate::graphql`].
  ///
  /// The segment is the crate-level module, which is not always where an item is DECLARED:
  /// [`ToGraphqlFilter`](crate::ToGraphqlFilter) is written in `graphql::lower`, a module private
  /// to `graphql`, and arrives here through `graphql`'s own re-export. Mirroring per crate-level
  /// module is what the glob can reach — a mirror of `lower` could not name it — and it is what
  /// keeps the shelf's shape the crate's shape.
  pub mod graphql {
    pub use crate::graphql::*;
  }

  /// Mirrors [`crate::flags`].
  ///
  /// Gated where the module is. An expansion writes no `#[cfg]` over its own paths, so what makes
  /// this segment safe to name unconditionally from emitted code is the `derive` ⇒ `flags`
  /// implication: a build that can expand `#[ingraph::flags(…)]` has the module.
  #[cfg(feature = "flags")]
  pub mod flags {
    pub use crate::flags::*;
  }

  /// Mirrors [`crate::comparison`].
  ///
  /// The crossing traits and the temporal storage map sit at this level, where the module declares
  /// them. A backend FAMILY keeps its own segment below, because that is where the crate keeps it —
  /// mirroring the structure is the whole rule, and a family flattened to here would be the one
  /// place the shelf stopped matching the crate.
  pub mod comparison {
    pub use crate::comparison::*;

    /// Mirrors [`crate::comparison::sql`].
    ///
    /// Spelled out rather than left to the glob above — which reaches the module either way, as
    /// `__private::graphql::filter` shows — because the three dialect segments below have to hang
    /// off a module this shelf OWNS.
    #[cfg(feature = "sqlx")]
    pub mod sql {
      pub use crate::comparison::sql::*;

      /// Reserved for SQLite-scoped items.
      ///
      /// Empty, and the emptiness is this crate's SHAPE rather than an omission: the family is
      /// KIND-first, so a dialect's code is `sql/text/sqlite.rs` and its siblings, and every public
      /// type there is per-kind and generic over its `Db`. What a per-dialect file holds is one
      /// impl and the private render functions it calls — plus, in the collection kind, an inherent
      /// `try_from_filter_with` on the kind's own type, which is reached THROUGH that type and is
      /// therefore not a module-namespace item any glob here could carry.
      ///
      /// The segment exists so that the first dialect-scoped public item to appear has a shelf path
      /// already mirroring where it lives. Nothing is manufactured to fill it, and its presence is
      /// not a plan to make the crate dialect-first.
      ///
      /// # It now SHADOWS a module of the same name, and the shadowing is what the shelf offers
      ///
      /// `comparison::sql::sqlite` exists and is public: it holds the family's types with the
      /// dialect fixed, for HAND-WRITTEN code. An explicitly declared module beats a glob import, so
      /// this empty one is what `__private::comparison::sql::sqlite` denotes and the aliases are
      /// unreachable through the shelf. That is the ruling rather than an accident — an expansion
      /// names the full form, which the shelf's promise covers and which the emitter already holds
      /// the `Db` to write. `ingraph-codegen`'s
      /// `tests::no_emitted_path_names_a_per_dialect_alias_module` states the rule; this is what
      /// makes breaking it a resolution failure as well.
      #[cfg(feature = "sqlite")]
      pub mod sqlite {}

      /// Reserved for Postgres-scoped items, empty and shadowing for the reasons the `sqlite`
      /// segment is.
      ///
      /// Each dialect rides its own feature, so the three cannot refer to one another: a build with
      /// this one on and that one off would have the reference and not its target.
      #[cfg(feature = "postgres")]
      pub mod postgres {}

      /// Reserved for MySQL-scoped items, empty and shadowing for the reasons the `sqlite` segment
      /// is.
      #[cfg(feature = "mysql")]
      pub mod mysql {}
    }
  }

  /// Mirrors [`crate::cursor`].
  ///
  /// A generated order-by builds an [`OrderTerm`](crate::OrderTerm) per database — its identity,
  /// the column this database spells it, its direction and its nullability — and a generated row
  /// projects into a [`CursorValue`](crate::CursorValue). Both are names an expansion writes, so
  /// both are reached the one way emitted code reaches anything.
  ///
  /// Ungated, as the module is: a position in a written order names no database.
  pub mod cursor {
    pub use crate::cursor::*;
  }

  /// Mirrors [`crate::ordering`].
  ///
  /// The STORAGE side of an order. A record's expansion binds
  /// [`Record::OrderBy`](crate::Record::OrderBy) and writes the
  /// [`FromGraphqlOrderBy`](crate::FromGraphqlOrderBy) row that crosses its completed wire order
  /// into that type, so both names are an expansion's and both are reached the one way emitted code
  /// reaches anything.
  ///
  /// Ungated, as the module is: a level sequence names no database, and the map that carries one
  /// takes its dialect as a parameter rather than a feature.
  pub mod ordering {
    pub use crate::ordering::*;
  }

  /// Mirrors [`crate::id`].
  ///
  /// The vocabulary's DELEGATION door — [`DelegatesId`](crate::DelegatesId) — is a row the `NewType`
  /// and `Enum` devices write for every declaration they equip, which is what puts the trait on this
  /// shelf beside its root re-export. A hand author names `ingraph::DelegatesId`; an expansion names
  /// this, because an expansion reaches every framework name from a root and this segment is that
  /// root's mirror of where the trait lives.
  ///
  /// Ungated, as the module is: an id names no backend.
  pub mod id {
    pub use crate::id::*;
  }

  /// Mirrors [`crate::query`].
  ///
  /// The engine's public seam: an emitted binding implements its traits and an emitted entry point
  /// names its builder. Ungated at this level for the reason the module is — a page names no
  /// database — with the SQL family's own segment below carrying the family's gate.
  pub mod query {
    pub use crate::query::*;

    /// Mirrors [`crate::query::sql`].
    ///
    /// Spelled out rather than left to the glob above, for the reason
    /// [`comparison::sql`](super::comparison::sql) is: the segment has to be a module this shelf
    /// OWNS, so that what an expansion names cannot be moved by a re-export changing shape.
    #[cfg(feature = "sqlx")]
    pub mod sql {
      pub use crate::query::sql::*;
    }

    /// Mirrors [`crate::query::mongo`].
    ///
    /// Spelled out for the reason [`sql`](self::sql) is, and carrying the family's own gate: an
    /// emitted extraction names [`field`](crate::query::mongo::field) once per column, so a
    /// declaration storing MongoDB documents reaches the decode the one way emitted code reaches
    /// anything.
    #[cfg(feature = "mongo")]
    pub mod mongo {
      pub use crate::query::mongo::*;
    }
  }

  /// Mirrors [`crate::gate`].
  ///
  /// The four CONDITIONAL-EXPANSION macros, which are PUBLIC — [`if_sqlite!`](crate::if_sqlite) and
  /// its three siblings — and are reached here for the reason every framework name is: an emission
  /// names the shelf and never where an item lives. The two paths are the same macro, exactly as
  /// `ingraph::ScalarFilterMarker` and `__private::marker::ScalarFilterMarker` are the same trait,
  /// so a hand-written per-backend half and the emission beside it ride ONE gate.
  ///
  /// What each expands to is decided HERE, against this crate's feature table — see the crate note's
  /// [four gates](crate#the-four-gates) for why a `#[cfg]` asks a different question in the crate an
  /// expansion lands in.
  ///
  /// Ungated at this level, and it has to be: a gate's whole job is to be nameable in a build that
  /// does not have its backend, which is exactly where an empty expansion is the answer. A `#[cfg]`
  /// here would leave a build with no backend family unable to resolve the path it is meant to
  /// silence.
  ///
  /// The glob carries MACROS as well as types. `crate::gate` re-exports four `#[macro_export]`ed
  /// `macro_rules!`, and a glob re-export picks up the macro namespace as it does the type one —
  /// `gate::tests::the_shelf_path_reaches_the_same_gate` is what holds that here, since it is not
  /// what a glob obviously does.
  pub mod gate {
    pub use crate::gate::*;
  }

  /// Mirrors [`crate::column`].
  ///
  /// One item, and an emitted QUERY BINDING is what needs it: `SqlQuery::COLUMNS` is a list of
  /// [`ColumnShape`](crate::ColumnShape), so an impl written by the emitter spells that type in the
  /// const's own annotation — an associated const has no type to elide.
  ///
  /// The shapes themselves are not built here. Each entry is
  /// [`shape`](crate::shape)`::<FieldTy, Db>(…)`, the field's TYPE answering, and that lives on the
  /// SQL family's shelf beside [`Carrier`](crate::Carrier) because the answer is per-dialect and
  /// that is where the dialect vocabulary is.
  pub mod column {
    pub use crate::column::*;
  }

  /// Mirrors [`crate::field`].
  ///
  /// One item, and an emitted LOWERING is what needs it: `ComplexComparison::apply` takes a
  /// [`FieldName`](crate::FieldName), so an impl written by the emitter has to spell that type in
  /// its own signature — there is no eliding a parameter type in a trait impl — and again at each
  /// column, where a derived part name is viewed as one.
  ///
  /// The module is private and the item is re-exported at the root, which is the same shape
  /// [`graphql`](self::graphql) has: the shelf mirrors the crate's MODULES, and where an item is
  /// declared is not where the crate publishes it.
  pub mod field {
    pub use crate::field::*;
  }

  /// Mirrors [`crate::interface`].
  ///
  /// An interface's expansion names three of these and a fourth arrives with the statement: the
  /// discriminant vocabulary its `<I>Kind` implements, and the arm list its query binding states —
  /// one [`InterfaceArm`](crate::InterfaceArm) per member over
  /// [`InterfaceColumn`](crate::InterfaceColumn)s, plus the alias the projection rides.
  ///
  /// Ungated, as the module is: a discriminant names no database, and a build compiling one backend
  /// still expands a declaration about another's.
  pub mod interface {
    pub use crate::interface::*;
  }

  /// Mirrors [`crate::marker`].
  ///
  /// The INTERPRETATION vocabulary, which every filterable field's expansion projects through: the
  /// inference row a declaration reaches when it names no marker, the marker a declaration names
  /// when it does, and the family traits a registration writes. The module is private and its items
  /// are re-exported at the root, which is [`field`](self::field)'s shape.
  ///
  /// A SEGMENT of its own rather than a name borrowed from [`graphql`](self::graphql), because the
  /// shelf mirrors the crate's MODULES and the interpretation layer is no longer inside that one.
  /// The map an interpretation resolves THROUGH stays there — an expansion writes
  /// `<<T as marker::DefaultMarker>::Marker as graphql::ToGraphqlFilter>::Filter`, one segment per
  /// half, which is the boundary the crate itself carves.
  ///
  /// Ungated, as the module is: a reading names no wire library and no backend.
  pub mod marker {
    pub use crate::marker::*;
  }

  /// Mirrors [`crate::name`].
  ///
  /// The five VARIANT namespaces, which a vocabulary's expansion names twice over: once in the
  /// return type of each `as_<namespace>_str` it writes, and once per conversion in the
  /// `TryFrom<&…Name>` family. The module is private and its types are re-exported at the root,
  /// which is [`field`](self::field)'s shape — the shelf mirrors MODULES, and where an item is
  /// declared is not where the crate publishes it.
  ///
  /// Ungated, as the module is. A build compiling one backend still expands a declaration naming
  /// another's face, and a name that vanished with a feature would make that expansion fail to
  /// resolve rather than fail to satisfy — which is the difference [`gate`](self::gate) exists to
  /// keep.
  pub mod name {
    pub use crate::name::*;
  }

  /// Mirrors [`crate::lane`].
  ///
  /// A fanned declaration's expansion writes four of them: the roster row ([`Lane`](crate::Lane))
  /// and its key ([`LaneIdent`](crate::LaneIdent)) in a `const` position, the seam that publishes
  /// the roster ([`Lanes`](crate::Lanes)) and the probe seat a router is wired against
  /// ([`LanedStore`](crate::LanedStore)) as impls. Beside them ride the two `const` halves of the
  /// collision audit — [`lane_claim_repeats`](crate::lane_claim_repeats) and
  /// [`lane_catch_all_repeats`](crate::lane_catch_all_repeats) — which an expansion spends in a
  /// `const` item, so a roster claiming one word twice is refused where it was written.
  ///
  /// The module is private and its items are re-exported at the root, which is
  /// [`name`](self::name)'s shape: the shelf mirrors the crate's MODULES, and where an item is
  /// declared is not where the crate publishes it.
  ///
  /// Ungated, as the module is: a lane's EXISTENCE is a fact of the declaration, and a build
  /// compiling no backend at all still expands the declaration that cut its corpus up.
  pub mod lane {
    pub use crate::lane::*;
  }

  /// Mirrors [`crate::project`].
  ///
  /// Ungated, as the module is: an accessor's qualification is written for every field a
  /// declaration marks, and no feature decides whether a field is many-valued.
  pub mod project {
    pub use crate::project::*;
  }

  /// Mirrors [`crate::state`].
  ///
  /// The projection layer an expansion walks when a declaration's label names a collection's
  /// ELEMENT: what the collection holds is `<C as State<Extracted<Inner>>>::Output` and never a
  /// token read off the declaration, which is what keeps an alias transparent one level in as well
  /// as at the field.
  pub mod state {
    pub use crate::state::*;
  }

  /// Mirrors [`crate::resource`].
  ///
  /// ONE item is named by an expansion — [`DeclaredResource`](crate::DeclaredResource), the
  /// citizenship `#[ingraph::resource]` emits an impl of — and the trait it takes as a supertrait
  /// is what makes that impl assert the contract, so a declaration with no `AsyncResource` impl is
  /// refused at the declaration rather than at the first unit that reached for it.
  ///
  /// Behind `runtime`, as the module is — and reachable from every expansion regardless, because
  /// the `derive` feature implies that tier. See [the tiers](crate#the-tiers) for why the
  /// implication is what keeps an emitted path resolving rather than a gate around each one.
  #[cfg(feature = "runtime")]
  pub mod resource {
    pub use crate::resource::*;
  }

  /// Mirrors [`crate::source`].
  ///
  /// The ORIGIN layer's shelf, opened by `#[ingraph::mutation]`. Four items are named by an
  /// expansion — [`Mutation`](crate::Mutation), whose `Request` projection is the payload each
  /// minted command variant carries and whose bound is what refuses a field type that is not an
  /// exchange; [`MutationNode`](crate::MutationNode), the row that hands a source its command type;
  /// and [`DeclaredMutation`](crate::DeclaredMutation) with the [`Exchange`](crate::Exchange) /
  /// [`Fallibility`](crate::Fallibility) pair its table is built from, which is the record a source's
  /// own expansion reads the declaration through.
  ///
  /// Behind `runtime`, as the module is, and reachable from every expansion for
  /// [`resource`](self::resource)'s reason: the `derive` feature implies the tier.
  #[cfg(feature = "runtime")]
  pub mod source {
    pub use crate::source::*;
  }

  /// Mirrors [`crate::record`].
  ///
  /// ONE item is named by an expansion today — [`VectorRecord`](crate::VectorRecord), whose impl an
  /// embedding index's expansion writes off every field its `embedding(<field>)` words elected. The
  /// other three faces here are still hand-written, and they arrive through the glob rather than
  /// being listed, which is every segment's shape: a shelf mirrors a module, not a use list.
  ///
  /// Ungated, as the module is: what a record IS names no database and no engine.
  pub mod record {
    pub use crate::record::*;
  }

  /// Mirrors [`crate::election`].
  ///
  /// The family an elected field's every fact is projected through, and the two audits an emission
  /// writes beside an election to state what its label claimed. Ungated, as the module is: an
  /// election names no engine, and a declaration must expand in a build with no backend at all.
  pub mod election {
    pub use crate::election::*;
  }

  /// Mirrors [`crate::measure`].
  ///
  /// The fold contract an aggregate's recompute calls, and the two citizens its bare words name.
  /// The expansion spends all three: it constructs the citizen a `measure(…)` entry selected and
  /// calls [`Measure::fold`](crate::Measure::fold) on it in fully qualified form, so the item type
  /// is stated rather than inferred.
  ///
  /// Ungated, as the module is: an aggregate is record sugar, `record` is ungated, and a downstream
  /// crate writing its own fold must be able to in a build with every optional face off.
  pub mod measure {
    pub use crate::measure::*;
  }

  /// Mirrors [`crate::retrieve`].
  ///
  /// The whole of what a retrieve-capable node's expansion writes: the query type its inherent
  /// methods take, the wrapper they answer with, the store seam tier B crosses, the refusal that
  /// carries either backend's, and — the reason this segment exists at all — the shared core
  /// functions (one address read per engine family) and the dedup MECHANISM the declaration's
  /// `dedup(…)` word selects between.
  ///
  /// Behind `engine`, as the module is, and reachable from every expansion for
  /// [`resource`](self::resource)'s reason: `derive` implies `runtime` and `runtime` implies this
  /// tier. Under no BACKEND's feature, as the module's own surface is under none: the pipeline
  /// names no database, and a declaration retrievable through a third-party store must expand in a
  /// build that compiled neither family.
  #[cfg(feature = "engine")]
  pub mod retrieve {
    pub use crate::retrieve::*;
  }

  /// Mirrors [`crate::route`].
  ///
  /// A fanned tower's CROSSING is emitted code: the `route(…)` word mounts a router at a step, and
  /// the walk that spends the segment names the seat it is mounted in, the dispatch it answers with
  /// and the refusal it carries. Those three are what this segment is for, and a declaration reaches
  /// them the one way emitted code reaches anything.
  ///
  /// Ungated, as the module is: a router names no engine and no database, so a tower that crosses
  /// into lanes must expand in a build that compiled neither.
  pub mod route {
    pub use crate::route::*;
  }

  /// Mirrors [`crate::schema`].
  ///
  /// The storage description a node's expansion states, and the trait carrying it: a graph root's
  /// emitted walk names [`Describe`](crate::Describe) once per field — as the bound the walk site
  /// has to prove — so the trait has to be reachable the one way emitted code reaches anything. The
  /// descriptor types arrive the same way, one `const` per declared database.
  ///
  /// Ungated, as the module is: a column list names no driver, and a build compiling one backend
  /// still expands a declaration describing another's.
  pub mod schema {
    pub use crate::schema::*;
  }

  /// Mirrors [`crate::sort`].
  ///
  /// One function and one trait, and an emitted WRITE PLAN is what needs them: a `sortable`
  /// collection's companion column is bound from
  /// [`collection_sort_key`](crate::collection_sort_key) over the row's own field, and the bound the
  /// emitted plan states about the element type is [`SortKey`](crate::SortKey).
  ///
  /// Ungated, as the module is: the bytes name no database, and the plan that spends them is
  /// emitted under the SQL family's own gate one layer out.
  pub mod sort {
    pub use crate::sort::*;
  }

  /// Mirrors [`crate::storage`].
  ///
  /// The CARRIERS a declaration's own fields are spelled in — [`Embedding`](crate::Embedding) and
  /// the space markers beside it. One emission names them today: the `ask` road's last hop answers
  /// coordinates, and the type it must answer with is this one at the election's own width and
  /// space, so the chain's final bound spells it here.
  ///
  /// Ungated, as the module is: a carrier names no engine and no database, and a declaration
  /// electing an embedding expands in a build with neither.
  pub mod storage {
    pub use crate::storage::*;
  }

  /// Mirrors [`crate::store`].
  ///
  /// One item is named by an expansion today — [`KeySegments`](crate::KeySegments), the filesystem
  /// backend's own key requirement, which a declaration's key answers by walking its columns in
  /// lineage order — and it spells [`Segments`](crate::Segments) in the signature, so the sink
  /// arrives through the same segment.
  ///
  /// The other seams here are a BACKEND's to implement and no expansion writes one. They ride the
  /// glob because mirroring is the rule; a module trimmed to the item an emission happens to name
  /// today would need editing the next time one is added.
  ///
  /// Ungated, as the module is: the two names above belong to a backend that needs no feature, and
  /// every key has an address whatever else a build compiles.
  pub mod store {
    pub use crate::store::*;
  }

  /// Mirrors [`crate::document`].
  ///
  /// Two items, and a derived index's expansion writes both: [`BoxWriter`](crate::BoxWriter), the
  /// sink one full-text slot's road pushes its segments into, and [`Searchable`](crate::Searchable),
  /// the identity road a slot takes when its engine's block names none. The module is private and
  /// its items are re-exported at the root, which is [`operator`](self::operator)'s shape — the
  /// shelf mirrors the crate's MODULES, and where an item is declared is not where the crate
  /// publishes it.
  ///
  /// Ungated, as the module is: a road names no engine, and a declaration electing a searchable
  /// field expands in a build that compiled no backend at all.
  pub mod document {
    pub use crate::document::*;
  }

  /// Mirrors [`crate::slot`].
  ///
  /// One item, and an expansion writes it in a `const` position: a derived index mints one
  /// [`SlotName`](crate::SlotName) per `(elected field × declared engine)`, so the name reaches the
  /// emission as `SlotName::new("…")` and a malformed one is `E0080` at the declaration that wrote
  /// it.
  ///
  /// A segment of its own rather than a name borrowed from [`store`](self::store), because the shelf
  /// mirrors the crate's MODULES and `slot` is one of them. Ungated, as the module is: what a slot
  /// is called is a fact of the declaration, and no feature decides it.
  pub mod slot {
    pub use crate::slot::*;
  }

  /// Mirrors [`crate::transform`].
  ///
  /// The entity binding an expansion writes an impl of, and the vocabulary its record member
  /// answers: a declaration's address types are the derive's own emission, so the trait tying them
  /// to the record is named from inside that emission and has to be reachable the one way emitted
  /// code reaches anything. The vocabulary arrives the same way, one impl per declared database.
  ///
  /// Ungated, as the module is: every record has an address, and no feature decides that.
  pub mod transform {
    pub use crate::transform::*;
  }

  /// Mirrors [`crate::operator`].
  ///
  /// The TOPOLOGY words' expansion is what needs it. A node that declares several products emits
  /// the vocabulary naming them ([`Products`](crate::Products), [`ProductKind`](crate::ProductKind))
  /// and the row per product a downstream projects through ([`Emits`](crate::Emits)); a node with
  /// one emits [`SoleProduct`](crate::SoleProduct), the marker a subscription that left the product
  /// unsaid discharges. All four are named from inside an expansion, so they have to be reachable
  /// the one way emitted code reaches anything.
  ///
  /// The module is private and its items are re-exported at the root, which is
  /// [`drive`](self::drive)'s shape: the shelf mirrors the crate's MODULES, and where an item is
  /// declared is not where the crate publishes it.
  ///
  /// Behind `runtime`, as the module is, and reachable from every expansion for
  /// [`resource`](self::resource)'s reason: the `derive` feature implies the tier.
  #[cfg(feature = "runtime")]
  pub mod operator {
    pub use crate::operator::*;
  }

  /// Mirrors [`crate::drive`].
  ///
  /// The JOURNAL word's expansion is what needs it, and it needs the organ's whole contract:
  /// [`JournalRow`](crate::JournalRow) is the trait a mounted journal implements, and
  /// [`NodeName`](crate::NodeName), [`Observation`](crate::Observation) and
  /// [`Station`](crate::Station) are the three types its `of` reads its columns out of. A hand-written
  /// journal names the same four at the root; this is the same four where an emission can reach them.
  ///
  /// The module is private and its items are re-exported at the root, which is
  /// [`field`](self::field)'s shape: the shelf mirrors the crate's MODULES, and where an item is
  /// declared is not where the crate publishes it.
  ///
  /// Behind `runtime`, as the layer is, and under no BACKEND's feature: a journal row names no
  /// database, and which store one lands in is the declaration's `persist(…)` rather than anything
  /// here. It is the segment an expansion names most — which is exactly why the `derive` feature
  /// implies the tier rather than the emitter gating each path; see
  /// [the tiers](crate#the-tiers).
  #[cfg(feature = "runtime")]
  pub mod drive {
    pub use crate::drive::*;
  }

  /// Mirrors [`crate::primitives`].
  ///
  /// ONE item is named by an expansion today — [`Timestamp`](crate::Timestamp), which a mounted
  /// journal's `at` column is DECLARED as. It is the one canonical column whose type the framework
  /// chooses rather than reads off a declaration, so it is the one the emission has to spell.
  ///
  /// Ungated, as the type is: jiff is a required dependency here, so the framework's own instant is
  /// not something a build asks for.
  pub mod primitives {
    pub use crate::primitives::*;
  }

  /// `serde` itself, whole — the crate rather than a module of this one.
  ///
  /// A generated MongoDB document derives `Serialize`/`Deserialize` through this path AND carries
  /// `#[serde(crate = "…::__private::serde")]`, which is what makes serde's OWN expansion bind its
  /// internal `_serde` here too. Both halves are needed: the derive path alone resolves the macro,
  /// and the code it writes still opens with `extern crate serde as _serde`.
  ///
  /// The whole crate, not a module of globs. A glob module compiles — serde's `__private` module and
  /// its marker macro both survive the re-export — but it is a snapshot of what serde makes public
  /// today, and everything serde's expansion reaches through `_serde` has to keep resolving.
  /// Re-exporting the crate makes this path denote exactly what `::serde` denotes, so there is
  /// nothing to keep in step. The mirroring rule above is about this crate's own modules, and a
  /// vendored crate has none here to mirror.
  ///
  /// Gated on the `serde` FEATURE, which is exactly "this build has serde": that feature owns
  /// `dep:serde` and is the only way the crate enters, so the crate and this item can never arrive
  /// separately. A declaration that stores mongo documents therefore needs `ingraph` with `serde`,
  /// and needs serde nowhere in its own manifest.
  #[cfg(feature = "serde")]
  pub use ::serde;

  /// `jiff` itself, whole — the crate rather than a module of this one, for the reason `serde` is.
  ///
  /// An emitted tower states `AssembledTower::asked_budget`, whose answer is an
  /// `Option<jiff::SignedDuration>`, so the SIGNATURE names a foreign type in a crate that names no
  /// jiff. This path is how it says so.
  ///
  /// UNGATED, where every other vendored re-export here rides its own feature: jiff is a STRUCTURAL
  /// dependency of this crate — `primitives::Timestamp` is a newtype over `jiff::Timestamp` and
  /// names it in every build — so there is no configuration in which this segment could be missing.
  /// The `jiff` FEATURE means the five declarable field types and their registrations, which is a
  /// different question and gates a different set of items.
  pub use ::jiff;
  /// `smol-bytes` itself, whole — the crate rather than a module of this one, for the reason `serde`
  /// is.
  ///
  /// UNGATED, because the dependency is: this crate's text member is `Utf8Bytes` and the manifest
  /// carries the crate with no feature in front of it. One name is reached through here —
  /// `Utf8Bytes`, as the id a `#[derive(ingraph::Enum)]` vocabulary delegates to, one `static` per
  /// variant holding that variant's canonical word. A declaring crate therefore needs `smol-bytes`
  /// nowhere in its own manifest, which is the whole point of the shelf.
  pub use ::smol_bytes;

  /// `sqlx` itself, whole — the crate rather than a module of this one, for the reason `serde` is.
  ///
  /// A generated SQL row's `FromRow` impl is WRITTEN by the emitter, not derived, and every sqlx
  /// name in it — `FromRow`, `Row`, `ColumnIndex`, `Decode`, `Type`, `Result` — is reached through
  /// this path. What that buys is the point: a declaration that stores SQL rows needs sqlx nowhere
  /// in its own manifest. `ingraph-codegen`'s `emit::sql` writes the impl.
  ///
  /// Shelving sqlx's OWN derive instead was never available. `sqlx-macros-core` 0.9's
  /// `derives/attributes.rs` declares no crate-path key, so there is nothing to redirect it with,
  /// and its `derives/row.rs` writes `::sqlx::…` absolutely — 32 such templates, of which any one
  /// expansion reaches a number that scales with the struct's fields. Writing the impl is what makes
  /// every path in it the emitter's.
  ///
  /// Gated on the `sqlx` FEATURE, which is exactly "this build has sqlx": it is the family root that
  /// owns `dep:sqlx`, and every dialect feature names it rather than the dependency, so the crate
  /// and this item can never arrive separately.
  ///
  /// Beside [`comparison::sql`](self::comparison::sql) rather than inside it, because the two are
  /// different things under one feature: that segment mirrors a module of THIS crate, and this one
  /// is the vendored crate the emitter reaches past it for.
  #[cfg(feature = "sqlx")]
  pub use ::sqlx;

  /// `bson` itself, whole — the crate rather than a module of this one, for the reason `serde` and
  /// `sqlx` are.
  ///
  /// A generated MongoDB document's EXTRACTION names `bson::Document` in its own signature, and
  /// there is no eliding a parameter type — so the type has to be reachable the one way emitted code
  /// reaches anything. `ingraph-codegen`'s `emit::mongo` writes the method.
  ///
  /// Gated on the `mongo` FEATURE, which is exactly "this build has bson": that feature owns
  /// `dep:bson` and is the only way the crate enters, so the crate and this item can never arrive
  /// separately.
  ///
  /// Beside [`comparison::mongo`](self::comparison) and [`query::mongo`](self::query) rather than
  /// inside either, because it is a different thing under one feature: those segments mirror modules
  /// of THIS crate, and this one is the vendored crate the emitter reaches past them for.
  #[cfg(feature = "mongo")]
  pub use ::bson;

  /// `async-graphql` itself, whole — the crate rather than a module of this one, for the reason
  /// `serde`, `sqlx` and `bson` are.
  ///
  /// A record's WIRE FACE is written by the emitter — the `#[Object]` attribute an output object's
  /// accessor face carries, and the hand-written `InputType` impls its filter and order-by carry —
  /// and every async-graphql name in any of them is reached through this path. What that buys is
  /// what the other three buy: a declaration that renders a wire face needs async-graphql nowhere in
  /// its own manifest.
  ///
  /// The one shelved crate whose own derive is REDIRECTED rather than replaced. async-graphql's
  /// attribute family takes a `crate = "…"` key (`async-graphql-derive`'s `get_crate_path`), so an
  /// emitted `#[…::Object(crate = "…::async_graphql")]` makes every path that expansion writes land
  /// back here — where sqlx's derive, having no such key, forced the row's `FromRow` to be written
  /// out by hand.
  ///
  /// Gated on the `async-graphql` FEATURE, which is exactly "this build has async-graphql": that
  /// feature owns `dep:async-graphql` and is the only way the crate enters, so the crate and this
  /// item can never arrive separately.
  ///
  /// Beside [`graphql`](self::graphql) rather than inside it, for the reason `sqlx` sits beside
  /// [`comparison::sql`](self::comparison::sql): that segment mirrors a module of THIS crate, and
  /// this one is the vendored crate the emitter reaches past it for.
  #[cfg(feature = "async-graphql")]
  pub use ::async_graphql;

  /// `tracing` itself, whole — the crate rather than a module of this one, for the reason `serde`,
  /// `sqlx`, `bson` and `async-graphql` are.
  ///
  /// An emitted query entry opens a SPAN, and every name that takes — `span!`, `Level`, `Instrument`
  /// — is reached through this path, so a declaration that is observed needs tracing nowhere in its
  /// own manifest.
  ///
  /// The `#[instrument]` ATTRIBUTE is the one thing not reached this way, and the reason is sqlx's
  /// rather than async-graphql's: `tracing-attributes` 0.1 declares no crate-path key, and its
  /// `expand.rs` writes `::tracing::span!`, `::tracing::event!` and `::tracing::field::debug`
  /// absolutely — fourteen such templates. Those paths resolve in the DECLARING crate, which names
  /// no tracing, so the attribute cannot be shelved and the emitted half opens its span by hand. The
  /// `macro_rules!` family is what survives the re-export: `span!` writes `$crate::…`, and `$crate`
  /// follows the definition rather than the invocation, so it lands here whatever path reached it.
  ///
  /// Gated on the `tracing` FEATURE, which is exactly "this build has tracing": that feature owns
  /// `dep:tracing` and is the only way the crate enters, so the crate and this item can never arrive
  /// separately — which is also why the emitted span rides `gate::if_tracing!` and not a `#[cfg]`.
  #[cfg(feature = "tracing")]
  pub use ::tracing;

  /// `bitflags` itself, whole — the crate rather than a module of this one, for the reason `serde`,
  /// `sqlx`, `bson`, `async-graphql` and `tracing` are.
  ///
  /// It is the FLAGS KIND's engine: `#[ingraph::flags(u32)]` expands to a
  /// `#krate::__private::bitflags::bitflags! { … }` invocation carrying the declaration's bits, so
  /// the whole flags type — its consts, its operators, its `Flags` impl and its text grammar — is
  /// that crate's output rather than tokens written here.
  ///
  /// It passes this shelf's own test the way `tracing`'s `span!` does and `tracing-attributes`'s
  /// `#[instrument]` does not: `bitflags!` is a `macro_rules!` whose body writes `$crate::…`, and
  /// `$crate` follows the DEFINITION site rather than the invocation, so an invocation reached
  /// through this path resolves back into the real crate whatever path found it. A declaring crate
  /// therefore names `bitflags` nowhere in its own manifest.
  ///
  /// It is also the ONE vendored crate here that this crate SPENDS as well as re-exports:
  /// [`FlagsValue`](crate::FlagsValue) sits on `bitflags::Flags`, which is what makes the bit table
  /// a wire face walks and the operators a filter lowers the vendored crate's own rather than a
  /// second table able to disagree with the first.
  ///
  /// Gated on the `flags` FEATURE, which is exactly "this build has the flags kind": that feature
  /// owns `dep:bitflags` and is the only way the crate enters, so the crate and this item can never
  /// arrive separately. `derive` implies it, which is what lets the emitted path be unconditional.
  #[cfg(feature = "flags")]
  pub use ::bitflags;
}