Expensive derived reads are a modelling defect: every rule needs an owner, and once ownership is computed the derivation gatherer is unearned and meta_materialize has no subject

The entry migration done

The two hierarchies, one mechanism at two grains done

The macro arc’s consumer, the first this arc retired done

The route family done

The reference decode on the field sites done

The argument and input-field sides done

The register itself done, by R955, because the gatherer it compensated for stopped existing

The materialization targets done by being moot: the subject was the unkeyed relations, and the six stored intent_ tables that remain are all keyed

The declaration pass open. A relation with no meta_relation row has been made nobody’s, and writing one forces a grain to be named. Not a pass that waits its turn but a precondition on every move, because a relation whose owner is undeclared is cleared by whatever clear still stands and, once its old writer is gone, is not written back. The mechanism is R877’s. The declaration is a build-time gate and not a runtime one: nothing that runs reads meta_relation, and what the gate buys is that a new relation cannot arrive without an owner.

Directive applications collapse onto the coordinate done. Ten relations became two; the five sites keyed one fact five ways because each carried its own decomposed key and none carried the coordinate.

graphql_element is a table a foreign key can name done. A supertype is a table carrying a primary key its subtypes reference; a union standing in for one buys the vocabulary and none of the integrity.

The schema block has a coordinate done. $schema is ours rather than the specification’s, and a dollar sign is illegal in a GraphQL name, so it cannot collide with a type an author declares.

The enclosing declaration is a fact done. graphql_ast_element_declaration walks the parent chain once, where the ordering it supplies was about to be a join per site.

code_ reads the classpath it is allowed to read done

code_ holds every fact a reader of the census read done

The census is gone done. Six relations, their gatherer, their roster rows and their fixtures, and with them the gatherer ordering constraint that existed only to keep a code_ arm from reading a jvm_ row.

The chain resolution is a walk in the catalog done, where it was a loop in Java invisible to every instrument that parses a rule body.

The resolution keeps its losers done. A link with no reading is a chain that does not resolve and one with several resolves ambiguously, and neither was a fact anybody could read.

The defects reach the surface open, waits on the second child below. They are stored, because the read that matters is the editor’s and a per-file predicate cannot push into a recursion behind a view boundary. Storing them did not reach the goal: the resolution they read was a view, so the stage re-walked every chain once per chain it drove and on a consumer-size schema did not finish. Evidence in roadmap/audits/2026-09-28-chain-resolution-storage.md.

The resolution is stored once, at the reading grain done. Three arm tables by key shape under the existing name, filled from one walk, with which walks reached a reading as payload so neither reader regroups. The arm tables are the hop relations' shape, which is this branch’s vote in the survivor question below.

The rule is examined, not only its storage open. broken drives a correlated NOT EXISTS over routes; restate it as an anti-join and record the figure beside the storage ones.

The reading’s KEY arm is an equi-join open. A three-way OR against sql_constraint is most of the reading’s cost; a UNION ALL of two equi-joins matched it by EXCEPT on a schema that never exercised the jOOQ-name branch.

The defects agree with the generator on a consumer schema open. On sis the four chain codes report 161 coordinates the generator accepts. Each child is a reading that is wrong rather than a rule that is, and evidence is in roadmap/audits/2026-10-01-sis-entry-defect-false-positives.md.

A departure is inherited through a type with no table of its own open. The endpoints take the departure from the enclosing type’s own binding only, so a nested type departs from nowhere and its chains report NO_ROUTE_FROM_DEPARTURE.

A scalar @reference has a target open. The path’s last table is where a column read through a chain arrives, and with no target basis for it CHAIN_WITHOUT_TARGET fires. Shares its question with "a routine resolving to nothing says so" below.

A named self-referencing key reads one way done. Both hops of a self-reference depart and arrive at one table, so the reading keeps the one the field’s cardinality names, which is the generator’s rule: along the key on a single-valued field, against it on a list.

A condition-only element resolves from its method done. The method row was the missing one, CodeCapture admitting only a Condition return where the generator checks none; a Field<Boolean> return is admitted beside it, read off the signature’s type argument. The manual still documents Condition alone, deliberately.

A routine resolving to nothing says so open. CHAIN_WITHOUT_TARGET declines that case on purpose, a @reference-only chain taking its target from the return binding where a routine chain takes it from the catalog, so the same silence means two different faults and only one has an arm.

The seat keeps its predicate and loses its vocabulary open, waits on the arm above. Every production reader filters to ADMITTED, three sites in RoutineWriteFacts and one arm of intent_field_unlowerable_ordering, so the thirteen refusals have no consumer and one moved to graphitron_entry_defect gains a reader rather than changing one; its MutationRoutineSeatTest case travels with it, being the only cover those thirteen have.

The chain is stated at the argument and input-field grains open. @reference is written at three coordinates and only the field grain has a chain relation.

One resolution of an authored element stands, not two blocked, on the two grains above. graphitron_field_reference_step_hop resolves the same elements as graphitron_field_chain_link_reading from a decode its own comment calls deprecated; measured on a fixture reaching every arm the two agree exactly, so what is left is choosing which survives. The stored resolution is keyed in the hop’s own arm shapes and adds the routine arm and the target grain the hop lacks, which is a vote for retiring the hop.

The read-time chain relations are gone blocked, on the node above. intent_field_chain_start, _node and _terminus retire as one and graphitron_field_chain_application falls out with them, its only reader being _node; graphitron_condition_method_route is not among them, having been rehomed rather than retired.

The assembly pass is inside the stage-order gate blocked, on R969. StageOrderGateTest models the derivation stratum only, so the three chain stages run in a hand-kept order nothing checks.

The graphitron anchor runs after what it resolves against done. GraphitronAstCapture runs after CodeCapture, and graphitron-ast declares graphql-ast, jooq and code. The anchor is placed to resolve and does not yet; its tables still copy strings, which is what the nodes below and every step DerivationStratum gives back to it change.

Four of the eleven go done. intent_condition_context_parameter, intent_external_field_contract_defect, intent_producer_cardinality_conflict and intent_scalar_java_type were read by their own tests and by nothing else, and a view nothing uses has not shown it is worth saving, so each went with its tests, the scalar view’s vocabulary gate among them.

The condition route resolves in graphitron_ done. graphitron_condition_method_route, renamed and declared to the gatherer that already read it; declaring it is what cost anything, the comment being reduced to its grain and example with the argument moved into the declaration.

The producer resolution resolves in graphitron_ open. intent_field_producer_method is the resolution the other arms hang on, and four of the eleven read it. graphitron_service_entry and graphitron_external_field_entry are wrong as they stand: keyed by coordinate, holding the authored strings the graphitron_ast_ twins already hold, and joined to nothing.

A code reference is written once open. The signature gate’s roster already holds the set: seven graphitron_ast_ twins and the two coordinate-keyed entries carry one class, method and argMapping under keys of one shape, so the fact nobody wrote is the reference itself. The directive vocabulary is the specification here and the implementation is not, @routine, @service, @externalField and @condition being meant to take one argMapping one way and today sharing no code.

The written reference done. graphitron_ast_code_reference_entry: one Java code reference as written, class and optional method, keyed by the ExternalCodeReference value’s position, or @sourceRow’s directive, and referencing `graphql_ast_entry. Written beside the twins by a walk over the vocabulary’s types, so a site is found rather than listed, and pinned by a fact document stating twelve sites from the vocabulary, a multitable path condition two input types deep among them. @record is declared only so schemas keep parsing and is decoded by nothing, its two relations gone with it.

The argMapping is written once done. graphitron_ast_argmapping_pair_entry: one entry of one argMapping as written, keyed to the string’s own graphql_ast_value_entry row and the entry’s position, for @routine, @service, @externalField and @condition alike. Found by the vocabulary’s name for a mapping through VocabularyWalk, which the code reference now walks on too, and read by ArgMappingSigil.entries, which judges no site; a sigil is a row as written. columnMapping stays @routine’s own. The vocabulary still calls argMapping inert on `@externalField, which its reading and the generator’s rejection follow until changed.

The resolution done. graphitron_code_reference: the one method a written reference names, keyed to it and to code_method, written by the graphitron-ast anchor; no match is no row. graphitron_code_reference_site states once what both it and the defects read: the directive and element a reference sits on, and the method it names, the @externalField default included. One graphitron_entry_defect arm reports every site in three codes, and says a class is absent only where the graph’s classpath was read at all. Pinned by a fact document over the classpath corpus. graphql_element and graphql_element_field are declared to graphql-ast now, their writer.

@enum resolves to a class open, when a consumer asks. A class reference names no method, so its resolution is to code_class and is its own relation.

The per-site copies go blocked, on each consumer being answered. The twins lose class_name, method and argmapping, a twin left with nothing goes, and the gate’s set goes with them.

The walk’s unknown-method rejections go blocked, on entry defects failing validate. Rejection.unknownServiceMethod and unknownLifterMethod are the gate until then, and the editor shows a second diagnostic for the one fault until they leave.

The winning application per field open, waits on the resolution. Whether that is a relation of its own or a query over the two is for its first consumer to say.

Each consumer is answered from the new model open, waits on the resolution. The views were designed before the discipline, so none is flipped: a consumer’s query is rewritten against the new relations and the view goes with its tests. The oracle is the consumer’s own test, stated as SDL, which passes before and after; a consumer with none gets one first, and a departure is an edit to that test. One child per consumer, grown as each is tried.

The old shape is gone blocked, on each consumer being answered from the new model. The two producer views, the unused views and their tests, and the coordinate-keyed entries with their writers in GraphitronAnchor.

The type questions follow it blocked, on the producer resolution, because a graphitron_ relation reading intent_ is the same crossing pointed the other way.

Entry defects fail validate blocked, on the defects agreeing with the generator on a consumer schema, without which this fails sis on 161 coordinates that generate. graphitron_entry_defect is read by the diagnostic view alone, so every code in it reaches the editor and none stops a build. Not the producer resolution’s alone: it holds for every arm, and the producer resolution’s rejections wait on it.

The defects are stored where the diagnostic reads them blocked, on the producer resolution. graphitron_entry_defect is the precedent, and the intent_mutation_routine_seat overlap under the chain branch above is the same two-producers shape.

A directory can be compared at all done

The skip asks the store rather than the graph done, because no relation the classpath feeds carries a graph, so the rows are the store’s.

The file is the grain done. store_class_file is keyed by path under an entry, and code_class holds which class a reading found in which file.

A single changed class re-reads only itself blocked, on the node below. The blocker was written here as re-graining code_type, and trying it found the relation rather than its key is what holds this: a row shared across classes by construction has no per-class mark that can decide its fate. Until this lands store_class_file.byte_size and .mtime are written and read by nobody, which is an arm waiting for its reader.

An entry gone from disk can be deleted done. It could not: code_type keyed store_source with no ON DELETE, so reclaim deleting a vanished entry was refused and the whole capture threw. CodeCaptureTest now removes an entry from disk between two readings and holds every classpath relation empty for it afterwards, against a control entry that stays. The dictionary’s key and the positions' keys into it cascade; sql_schema and sql_enum_binding key store_source the same way and are the catalog’s to look at.

Every code_ row hangs off a class open. code_throwable and code_throwable_supertype key the entry, though every throwable is a class the reading read; the dictionary pair is the other two, and is going.

One sweep, at the class file blocked, on both above. CodeCapture sweeps all sixteen relations by instant beside the class-file sweep, whose cascade already reaches every class-keyed one. What only the second sweep reaches is the four above.

Nothing anchors to it done, by inspection. Every reader joins in from a site already holding the spelling and none enumerates the relation, so a row’s existence asserts nothing.

The peel is a function of the spelling and a stored vocabulary done, by inspection. intent_delivery_container supplies the container set, so siting the parse moves columns rather than moving a resolution.

Each column is earned by a named reader done, by tracing them to the queries. The spelling is what an emitter declares a type from. element_class answers which class backs a GraphQL type, through intent_type_backing_seed to five language-server surfaces and TypeBackingRows. delivery answers whether a field declared a list is backed by a method that delivers one, which a cardinality-conflict view stated until it was retired for having no reader, so the column has none now. erased_class is what a binding compares against, at argument mapping and at a @nodeId decode’s landing.

A use site carries its own parse done. code_method and code_method_parameter each hold their own erasure, delivered class and delivery. Nothing new is computed: the reading reached all three at the position already and deduplicated them into the dictionary, so siting them is declining to deduplicate. Held against the dictionary in both directions while both exist, which is an oracle only this order affords.

The readers move off the dictionary blocked, on the seeded cases being gathered. Read at the queries rather than the views, what is left reading it through a position is the rendering and nothing else: ClassMemberSlots in the language server, and SchemaQueries.members and CodeQueries’ methods, parameters and components in the MCP server, each joining `code_type on a spelling the row already carries to fetch display_name. Each moves by formatting that spelling, which also retires an inner join that would drop a member whose spelling had no row. The two parameter-side readers of the parse flip cleanly; flipping them turned seventeen @nodeId cases red because SeededStore writes the dictionary half of a claim and not the position half, so a seeded store states that one signature parses two ways. Teaching the seeder both halves is work on a fixture whose conversion makes the question disappear, a capture writing both from one reading. So the flip waits for those cases rather than paying for them twice.

A slot carries its own parse done. code_read_slot and code_write_slot each hold the erasure, delivered class and delivery of their own type, beside the spelling they already had, and CodeCaptureTest holds both against the dictionary as it holds the method positions. The node read the other way round first, the slot reaching its type through its accessor’s code_method row, and inheritance is what turned it: what a member yields is a fact about the class offering it and not about the method behind it. An inherited accessor has no row under the offering class and may sit in an entry the reading did not read; a constructor has no code_method row at all, so a POSITIONAL write slot would have nothing to reach; and a base class declaring K getId() offers Integer to a subclass extending it at Integer, which only the offering class can say. That last case is a known limit rather than a fixed one: the spelling is the accessor’s declared result, type variables unsubstituted, so it reads K. The slot is where the substituted type goes when the reading states it.

The read slot is named for its axis done. code_type_slot became code_read_slot: keyed by the offering class and its accessor, it has no type in its key, and the store already called it the read side of the pair code_write_slot is the other half of.

A delivered class the reading holds is referenced by its key open. element_class is a class name, a part of code_class’s key and not the whole of it, so a reader joining on it can meet the wrong copy or several, and a class that goes takes nothing with it. Where the reading holds the class a position delivers, the position carries that class’s entry beside it and the pair keys `code_class; where it does not, as for java.lang.String or a generated jOOQ class, the entry is NULL and the name is a name for the compiler to resolve. NULL then says the class was not gathered, which a join on names cannot say at all.

A slot’s parse is read by what replaces the accessor hop open. No query reads the new columns. Their reader was intent_field_accessor_hop, which peels slot_type through code_type_element to say which class a member of a class delivers, the edge the type-backing walk steps along, and which is dissolving. Its successor reads element_class off the slot with no peel; if the hop’s dissolution needs no such edge, the columns are unearned and go.

code_construction keys on the class it is about done. It states how a value of one class is made and was keyed by a type spelling, a class fact filed under a type key. It keys into code_class now and code_write_slot follows it, so a class the next reading does not find takes its construction and its write slots with it.

code_type and code_type_element are gone blocked, on the readers moving off them.

The configuration runs first open. Every store_graph_* relation keys store_graph and nothing else, and no gatherer reads them before they are written, so this is a move in ModelCapture and changes no row.

The documents run after the classpath and the catalog open, waits on the node above. The three graphql- gatherers declare no upstream, and the first gatherer reading them after the corpora is graphitron-ast, so this move changes no row either.

The classpath is configuration open. What a module depends on is something its build declares. A reactor dependency is a class directory the build writes. A repository dependency is a jar, a release that cannot change under its coordinate and version or a snapshot that can. The configuration gatherer transcribes one row per dependency per graph, stating which of the three it is as the producer resolved it. The point is the row and not reading it back: the Java already holds what it just wrote, but a graph’s claim on an entry can only reference a dependency that is a row, and that reference is what makes a dependency the build stops declaring release its claim by cascade rather than by a hand-written delete. The producer already knows more than the store keeps: ClasspathEntry.suppliedStamp carries a repository’s identity for a jar it resolved, which the session census trusts and the persisted reading ignores, hashing every jar on every capture. This is also what the version node in the staleness branch below is waiting for.

A claim references the dependency it resolves blocked, on the node above. store_graph_source for a classpath entry keys the dependency row, classpath-source declares store, and the code family has the configuration as its one upstream.

Code does not depend on jOOQ open. The two families are parallel: each reads its own corpus under the configuration, and neither keys the other. The reading skips the generated jOOQ package, and that is right, the generated classes being the catalog’s to describe and no part of the service layer. Two reads cross today, one child each.

The table a parameter is bound to is the graphitron anchor’s open. code_condition_method_parameter_table keys a parameter to the sql_table its class names, so the reading runs after the catalog, and it matches by class name in Java with a hand-kept ambiguity check. The binding crosses two families, so it belongs to the gatherer downstream of both: matched by name once, at graphitron’s anchor, and stored as a table keying both sides, which is the shape the relation already has under the wrong family. Readers join on its keys. `code_method_parameter.role keeps TABLE_CONCRETE, which is a fact about the signature alone.

The reading’s loader comes from the classpath it read open. CodeCapture and ClassAncestry are handed jooq.codegenLoader(), to load scalar constants and to ask whether a position is a Table or an enum. That is a loader and not a family, but reaching it through the catalog makes the catalog look upstream of code when it is not.

The jOOQ exclusion is pinned where services share its package open. Services are commonly written in the module jOOQ generates into, so one directory holds both, and the exclusion is the package and every package under it. A service package beneath the generated one is dropped silently, every arm reading as a classpath that does not carry it. A case first, then either the exclusion stops at the package or the layout is refused out loud.

A gate holds the call order to the roster open. Nothing checks that ModelCapture calls a gatherer after every gatherer it declares, which is how the two drifted apart. java-source and compile run in the dev loop on their own cadence rather than in this sequence, and sdl names a class that writes nothing, so the gate’s population is the gatherers ModelCapture calls.

An entry says what it is done. Both halves of the classpath corpus were handed to capture as this module’s own output, which was false twice, and the lie was load-bearing: it removed the reactor limit the @service arm leans on.

The store records which repository answered done, by consequence.

The version is carried blocked, on the classpath being configuration. store_source.coordinate is groupId:artifactId by design, for naming a module in a refusal, and stops one field short of the identity question. The version is a fact the build declares, so it arrives with the dependency rather than as another column on the entry.

Three kinds get three treatments open, waits on the version. A release jar needs no content stamp, a snapshot jar does, and only a directory needs the stat walk; all three share one path today.

A stale snapshot is detectable open, waits on both above.

A directory’s stamp covers what the reading reads open. The stamp walks every file under the directory, the generated jOOQ files included, so where services share a module with the catalog a migration regenerating jOOQ moves the stamp and every service class is read again though none changed. The stamp covers the class files the reading takes, or the file-grain skip in the capture branch makes the directory’s stamp matter less; either removes the false invalidation.

The model comes first, as tables open. The entry and the candidates relation are declared with their keys, foreign keys and grain sentences before anything writes them, so a document can name them.

The corpus is written against the model open, as fact documents asserting with @expectEquals the rows each schema should give the two new relations: an output field, an argument and an input field, at a node type, an interface and a union, by a written typeName, a bare @nodeId, the id-name forms and @reference. Written before the gatherer, because a document is an example of the model and writing them is where the cases nobody thought of turn up, while no code depends on the answer. Each is committed with the gatherer step that satisfies it, so every commit stays green.

Add: the entry states what was written open. One row per @nodeId application at its site, with typeName where the author wrote one. The existing entry relations are checked against that sentence rather than assumed to meet it.

Add: the candidates relation states what may be legal open, one row per use site and node type. A written typeName is its type. A bare @nodeId is the coordinate’s node type, or each member of an interface or a union that is a node. With @reference it is the one node type over the table the path lands on. The id-name forms are the coordinate’s node type.

Add: an input field’s use site open. A use site is a definition joined to its consumer, and the model holds it today only as an intent_ view, so it is modelled here rather than read.

Flip: the readers depart per candidate blocked, on the three adds. A written candidate departs from every participant of the coordinate and an inferred one from its member’s table. The encode, the decode, the filter and carrier roles, the hops and the coverage census read the new relations.

Subtract blocked, on the flip: graphitron_node_id_instruction, the endpoint that crosses, and whatever in the chain stops being read.

An overload accepts a member by two spellings open: its parameter is the member’s own record, or one of the four types every node’s record is, Object, Record, TableRecord<?> and UpdatableRecord<?>, because a node has a primary key by definition. One method taking UpdatableRecord<?> is the case where one overload accepts every member, and a mix resolves the way javac resolves it, most specific first.

The destination names the overload open. One row per member already stands; it carries which overload that member lands in, and the refusal is a member’s: no overload of the named method accepts it.

The overloads differ only in the polymorphic parameter open. Anything else, another parameter or an argument mapping that differs between them, is refused, so every call is spelled from one argument list.

The generator dispatches from these rows blocked, on R984, which owns the dispatch and the widening of each arm’s result; it reads the three nodes above and waits on them.

The per-member fit goes blocked, on the dispatch: intent_record_slot_assignable, the SLOT_NOT_SUPERTYPE_OF_MEMBER verdict, and sql_table_record_supertype with the capture walk that climbs the record class, which has no other reader.

The corpora are reachable done. All three families have one and two are modules the tests already depend on: the fact documents, graphitron-sakila-db, graphitron-sakila-service.

A document states what a fixture stated done. Seven documents replaced four test classes, at forty fewer @Test methods and no lost coverage.

Deleting coverage cannot be silent done. theDocumentsDeclareBlocks fails if the folder stops resolving, a glob stops matching, or a block declares no rows, which was the one way this arc could have deleted its own coverage without saying so.

The count only falls done. SeedingDissolutionGateTest holds it at 83, because a seeded case is written by copying one and the file it copies never gets opened.

The count counts seeding done. A quarter of it did not: 26 of 109 callers wrote no fabricated row, 22 of them borrowing the fixture as a store factory and four naming it in prose. The only row any of them planted was store_graph, a second spelling of ModelCapture.writeGraph, whose own javadoc asks a fixture to call it instead. They open ThreadConfinedStore and anchor their graph through capture now, so what the gate counts is cases that fabricate facts, plus CodeRows, which is the fixture’s own machinery and goes with it.

The code half converts open, and is the larger half: 54 classes and 717 tests against the SDL half’s 50 and 354. Taken first because the prerequisites are here. A seeded code_method row is a claim about a method; a method in graphitron-sakila-service is one.

The library carries the shapes a conversion needs open, and grows by one shape per conversion attempt. The first attempt wanted an overload and the service module had none across ninety-seven classes, so FilmService.topRated is now a pair. That is the expected cost, a method added to a module that already compiles; what is not knowable in advance is which shape the next attempt wants. The node-id subject enumerated its own once, and they went in together: NodeIdSlotService, an overload whose halves name their parameter alike and a method taking a primitive, and in the catalog a second plain-bigint referrer of converter_org, a composite referrer of converter_campus_term whose first column escapes the converter, and two branch tables that reach one node table through repeated constraint names.

The SDL half converts open. 50 classes, 354 tests.

A case that resists a document may still not need seeding open, and the difference decides the node below. Nine of `FieldProducerMethodTest’s ten cases are a document now; the tenth wants two graphs whose classpath entries differ, which one shared corpus cannot give. That makes it a Java case rather than a seeded one: capture takes the classpath as an argument, so the case hands in two and runs the same gatherers, and the class now seeds nothing. Not being expressible as a document and needing a fixture are two different claims, and only the second is residue.

Conversion goes by subject, not by class open. A hundred and nine classes converted one at a time is not a plan, and the relation is the wrong unit to batch by: they assert on 178 relations and 57 of those have one class each. The subject is the unit that compresses, because one document writes rows into every relation its schema touches at once. Node ids are nine classes and 131 tests, fields nine and 108, mutations eight and 100, nodes six and 77, input fields six and 71: five schema families carry 38 classes and 487 tests. What a subject owes up front is its corpus gaps, enumerated once, rather than one missing shape found per class.

The node-id subject converts blocked, on the candidates branch above: every class in it reads the instruction, and its first conversion crashed capture. Eight classes of nine. Its gaps are one classpath shape and three catalog shapes, and its six sibling-graph cases need no replacement: the runner captures every document into one store as its own graph and compares each block against that graph alone, so a derivation that drops graph_name fails whichever document it leaks into. PolymorphicNodeIdDecodeTest waits on the branch above, because a document written now would pin the rule that branch replaces.

There is no residue, and no partial conversion open. A class converts whole or it has not converted, which is what the caller count measures and why it is the right count. A case that fabricates a state no capture reaches is not a case the fixture has to be kept for: it is either a property test, which is the tool for a pattern nobody writes on purpose, or it is a test of a strange shape nobody cares about and it goes. CarrierDataFieldPopulationTest is the clearest instance and is not an exception to plan around.

A fresh store per test stops being the only shape open, and it is not tidiness: every sql_ and code_ relation is store-wide, so one store holds many graphs against one reading of the catalog and the classpath, and varying which SDL loads into a warm store is the only thing that exercises refresh at all. A fresh store means every refresh runs against an empty one, which is the case where sweeping, re-anchoring and invalidation are all trivially correct.

SeededStore is deleted blocked, on the five above. Not shrunk and not kept for a remainder: the fixture goes. The subtractive commit is what makes this branch done, and until it lands the root is not done either.