DETERMINISTIC SYSTEM MAP
System map
The application boundary with its navigation pages inside, the one transport core that owns the pool, lock and socket every page competes for, the client extensions that route through it, the namespaces it dispatches at the gateway, the on-device engines, the event bus and its subscribers, and the external systems orbiting the application. Every node deep-links to its source; the constructions the map assumes are declared as invariants and checked on every build.
System flows
Invariants
THE EXTRACTOR AS A PROJECTION
Extraction map
The system map is the output of a function over the source tree: each compiler pass reads every Swift file and emits what its grammar recognises. This page shows the projection itself. On the left is the implementation's file schema, the directories and files as they sit in the repository. On the right is every construction the map drew, grouped by kind. Each wire is one extraction: it runs from the file and line a rule fired on to the entity that rule produced, coloured by the family of the rule. Files no wire leaves were read by every pass and cited by none. Whatever the grammar does not know does not exist on the map, so those files are exactly the region the invariants do not cover.
Coverage by file
The same projection as area: every analysed file is a cell sized by its lines; the fill is the share of its declarations a mechanical pass cited; hatched cells were read and cited by nothing.
DETERMINISTIC DISCOVERY
Source inventory
Every Swift source file is assigned to one architectural component. The inventory is reproducible from the repository without an LLM.
| Component | Layer | Files | Lines | Declarations |
|---|
DETERMINISTIC PIPELINE MODEL
CI gates
Every GitHub Actions job drawn as a logic gate: a pull request is the input signal, each job either passes it or blocks it, needs and artifact hand-offs are the wires between jobs, and every gate that runs on pull requests feeds one AND gate, the merge. What runs only after a merge or by hand sits downstream. Beneath the circuit, the gates are sorted by what they defend: ratchets that hold a metric floor, architectural checks that pin the shape of the code, and static compiler checks that fail on drift between the tree and its generated artifacts.