Everything composed is a composition of known parts, at every level
A pattern is composed of kinds and relationships; a view of patterns; a deliverable of views; the hub of every family of application. Each level is declared, has an address, and reads down to the ground through the level beneath it; none holds a fact of its own. A deliverable is plural and declared, never a singleton written into the manifest, the addresses or the checks; and one mechanism binds, draws and addresses a pattern, a view and a deliverable alike, so what distinguishes them on the surface is the application and not the machinery.
What goes wrong without it
The Measurement Plan was the only deliverable this model had, and it was written as a singleton into six places: the manifest named one projection, the address template carried the plan's own slug, the view law refused any other name, the build chose an address by whether the field was set, the reader kept a constant for it, and the header singled it out beside the questions and the jobs. A second deliverable could not have existed without touching all six. Meanwhile the job that builds a measurement plan belonged to nothing, though it is named after the plan. The private platforms this descends from settled long ago that everything is a node, patterns and hubs included, and that a node may be a composition of known nodes; this is that determination, made public and held by gates. The public backing is older: a pattern language is a network of patterns each composed of smaller ones, and the composite pattern treats a leaf and a composition uniformly. The hub as the one call to action is this product's own synthesis, and claims no source.
What proves it — 2
Each is a gate the build runs: a check inside a ring, a whole ring, or an eval beside them. A build stops at the first that refuses.
- Every view binds declared patterns from one kindViews compose
Every view names declared patterns, all asked from one kind, drawn in a way the law's pattern vocabulary declares, belonging to a declared deliverable, a table as one of its tabs and a job as work that produces it; and some row of that kind answers at least one of them. What a view touches is derived from its patterns, never listed beside them. - registry integrityaddress integrity
Every page address is made once from a label by the law's own scheme and is distinct from every other; every top-level name the site answers is derived from what declares it, and no kind, endpoint or frame name takes another's; every address the site once answered to, a former label's or a retired identifier's, is distinct from every live address and from every other former one, and no row names its own label as a former one; every projection answers at a declared name, once, and is cut from fields the artifact carries; every operation reads a projection; and every endpoint answers only what its direction allows.
Derived from — 2
- Alexander, Ishikawa and Silverstein, Oxford University Press, 1977A Pattern Language: Towns, Buildings, Construction
- Gamma, Helm, Johnson and Vlissides, Addison-Wesley, 1994Design Patterns: Elements of Reusable Object-Oriented Software
Where this model stands
registry/deliverables.json declares each deliverable: its name, what it is, what a reader leaves with. Five stand in the order the loop is walked: the Measurement Plan, the Campaign Brief, the Instrumentation Plan, the Lifecycle Map and the Evidence Plan. A view names the deliverable it belongs to; a table is one of its tabs, a job is work that produces it, and every view belongs to one.
FND-028 refuses a view that names an undeclared deliverable, a view that belongs to none, and a deliverable that nothing belongs to. FND-025 holds the deliverables door to opening that whole registry, and the plan's former addresses are moved in the law so the host redirects them.
The standards export carries the composed layer as individuals: every pattern, view and deliverable has an IRI and a class, and `composes` and `touches` relate each level to the one beneath it and to the kinds. An agent reading the triples reaches the ground from the hub the way a reader does.
The hub is a door of its own, the header's one call to action, and the family doors it gathers are placed in it by the law rather than in the header. The map already drew one row of the layer per deliverable; nothing there changed.
A shape composed at runtime is a pill of the layer under the family 'composed here', lit over the kinds it touches, for as long as the reader is composing it. The map does not know whether a pill was authored or composed a moment ago.
Every pattern is drawn as a flow across the bands by one rule, the law’s `flow` fragment: a role in the band of its kind, in the governed order, a road the way the model stores it, a road that runs back beneath the others, which is how a loop shows itself; the same drawing appears in the blank place as a shape is built.
The map’s arrangements are declared in the law, kinds by band, entities as hubs and walk from here, each drawn by the files that name it, offered by the layout with the law’s mark and remembered under the law’s key; and on the compose door the kinds arrangement is the board: a kind pressed becomes a role, a lit road pressed becomes an edge, and the roads offered are the specifications the grammar declares between the kinds on the board. The site ring holds all of it.
What it does not claim
Several deliverables lit against one another on the map, each in a colour of its own, is not drawn; the board lights one composed shape, and the layer lights a deliverable’s tabs.
RUL-042