ETHENOTETHAN / PORTAL

Architecture Observatory

Source-backed loading Overview Features Repository ↗

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.

Extracted by static source rules, explained by architecture/interplay/overlay.json, and gated by architecture/interplay/invariants.json. Edges are ownership, lifecycle, and wiring—not runtime topology or live connection counts.

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.

Every wire is a (file, line, rule) the compiled model already carries, joined to the entity whose citation it is, so this page can never disagree with the map. Untouched is a fact about the extractor's grammar, not about the code. Citations written by a person (construct records, flows) are counted separately and never drawn as extraction.

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.

ComponentLayerFilesLinesDeclarations

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.

Jobs, needs, artifacts and triggers are read from .github/workflows; the family of each workflow and what each ratchet measures are declared in architecture/config.json; the numbers are the committed baselines CI compares against. The diagram does not read branch protection: a gate here is a job that runs on pull requests, not a proof that GitHub requires it.