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
//! Helper modules for the public graph boundary root.
//!
//! Every registered `#[test]` wrapper lives in `tests/graph.rs`; nothing below
//! declares one, so libtest identities equal the fixed owner inventory.
/// Degree and directed betweenness over the shared selected indexes.
/// Strongly connected components, condensation, and iterative shape.
/// What the derived answers may read, and what the layout proves before it
/// describes anything.
/// The derived evidence answered equally, however the library was written.
/// Equal graphs answered equally, whatever order their files were created in.
/// Cohesion, modularity, affinity, and the cycles that cross a partition.
/// One divergence answer, taken apart so two of them can be compared.
/// Real workspaces, shared analysis views, and comparable analysis text.
/// Coordinate-free metadata projected for a renderer or a ranker.
/// Independent models of every derived answer, taken from the raw graph.
/// What the analysis family holds and publishes.
/// How the analysis family proves a ceiling before it spends against it.
/// The written-down model of what the analysis family publishes.
/// One selection applied once, and who may read what it produced.
/// The declared module partition derived from logical containment.
/// The two ways a corpus is perturbed without changing what it states.
/// One explicit edge selection and the admission ceilings it is bounded by.
/// The published package's manifest, module tree, and registered predicates.
/// Bounded neighborhoods, shortest paths, and induced subgraphs.
/// Cached analysis answered exactly as the direct analysis answers it.
/// What a caller still holds after the cache clears, evicts, or is dropped.
/// The arguments a cached-analysis case asks over, and how the answers read.
/// What one graph's derived state retains, drops first, and counts.
/// One allocation per repeated claim, and what states a different claim.
/// The published counter vocabulary and the exact deltas a case reads by it.
/// Exact graph reuse, ceilings, retention, and equality with direct builds.
/// Real workspaces and the cached and direct builders every case enters by.
/// What the cache boundary publishes, and what it may name.
/// Which owner every graph a caller reuses passes through.
/// The one lock over a graph's derived state, and the one counter owner.
/// Source-unit reuse, the seam that decides it, and bounded retention.
/// Tied definition identities, and what a retained projection joins through.
/// One repository state, one change, the reuse it owes, and the direct graph.
/// The retention surface that stayed Rust's once the assembler became neutral.
/// The published package's dependency closure, inventory, and reading surface.
/// Which declared function reaches which, in one production source.
/// The public reading, identity, and lifecycle surface.
/// The temporary Cargo repositories every case projects, written out.
/// The temporary Cargo repositories the derived-analysis cases project.
/// The temporary Cargo repositories a case states as a rule over a count.
/// The temporary Cargo repositories the revision matrix is read over.
/// Refusals taken before a graph exists.
/// Reference records, candidate edges, and dependency evidence.
/// Real fixtures and the production path to a snapshot-bound resolution.
/// The temporary Go repositories every Go graph case projects, written out.
/// Refusals a Go build takes before a graph exists.
/// Go reference records, candidate edges, and dependency evidence.
/// Real Go fixtures and the production path to a snapshot-bound resolution.
/// The written-down model the Go projection cases are read against.
/// Structural ownership of the Go adapter's own production sources.
/// Go node inventory, source association, and the containment forest.
/// The Go graph's version-1 bytes, determinism, and query consumption.
/// Every source these cases read, beside its compile-time text.
/// Projection after the fixture repository is gone.
/// Structural ownership of this crate's own production sources.
/// The written-down model those ownership cases are read against.
/// The Rust answers themselves, once the assembler became neutral.
/// The one language-neutral projection family, and who may enter it.
/// One syntactic report restated at the semantic tier.
/// Comparable text taken from the public reading surface.
/// Readers over this crate's own production sources.
/// The declared items, derives, fields, and constructors those sources state.
/// Node inventory, source association, and the containment forest.
/// Tier propagation and the exact version-1 serialized contract.