An address is a label's, made once

Answers Identity · Nomenclature

Every page address is made once, from a label, by the scheme the law declares: the site reads the path the graph carries and never slugs a label itself, the standards export writes the same path as its IRI, and the build refuses two pages that would share an address or a kind that would answer to a name the site reserves. An address carries a label, never an identifier; the identifier travels in the page's structured data. The doors of the site are declared the same way: a section opens a name the law already reserves, so its address is the reservation rather than a copy of it, and what a reader is told the door is, and which group it falls into, are the law's to say and not the surface's to invent.

What goes wrong without it

Two copies of the rule that turns a label into an address drift the first time one is edited, and the drift is silent: a page still renders, its structured data names one address and the standards export another, and neither build can tell. One scheme, declared as data and filled in one place, makes an address a fact of the ground that everything downstream reads rather than a rule each consumer re-derives.

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.

• 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.
• ring:6the site ring
  The built site is the whole graph and nothing else: every page indexed, addressed by a label, self-contained and free of any private name; every structured-data identifier a subject the standards export wrote; every page unfurling to its own card, and every sitemap entry naming that card as its image; every journey with its SCXML twin; the sitemaps held to the graph; a graph under a megabyte. And the host held to the ground: the Worker serving the build as its assets and running first for every request; the allowlist and the redirect list it carries cut from the graph, every address the graph once answered to in the list with the status the law gives it and none of them a page; every endpoint served by the files it names; and the beacon sending to the collector's endpoint and nowhere else; every projection the law declares in the build, served by the files that say they serve it, and named in llms.txt; and the Worker reading the host's caching rules and owed headers from the law, writing none of its own; every answer a question carries a page where the walk is non-empty and nowhere else, its structured data naming exactly the rows the walk reached.

Derived from — 2

• Berners-Lee, W3C, 1998Cool URIs don't change
• Wilkinson et al., Scientific Data 3, 160018, 2016The FAIR Guiding Principles for scientific data management and stewardship

Where this model stands

registry/law.json `addresses` declares every projection, a page type as a path template drawn by its route or a file served by what serves it, the fragments the structured data uses, each drawn by the files that write it, the doors, and the frame's own names, every other top-level name being derived from what declares it.

The build fills the templates in scripts/ground/addresses.py, carries `path` on every page-bearing object of the graph and `machine` on the machine kind's rows, and FND-025 holds every address distinct and every kind clear of the reserved names.

The site builds every link, route and structured-data identifier from the paths the graph carries; the standards export builds every IRI from the same paths; the site build holds every structured-data identifier it publishes to an IRI the export wrote.

An address the site once answered to stays governed: a former label's and a retired identifier's addresses are made by the same scheme, held distinct by FND-025, carried by the graph as `redirects`, and written into the host config by the site build, which refuses a build where one is a page or its rule is missing; the standards export says which IRI replaced a moved one and marks a retired one deprecated.

law.json `addresses.doors` declares every door: the name it opens, its label, the longer name a page uses for itself where that differs, and its group, which is itself a governed vocabulary. The surface derives all of it and writes none of it; FND-025 holds each door to a name the law reserves and to saying its label once, outright or by pointer where the name is the manifest's to give; and the site ring refuses a declared door with no page and a name anything else declares that answers with a page no door offers.

law.json `addresses.endpoints` declares what the host answers that is neither a page nor a file: one bare segment, a method, the direction it faces, and the files that serve it; `addresses.directions` says what each direction may answer. Ingress lets something in by a method that carries a body, and what enters is counted or answered and never written to the ground by arriving; outbound lets nothing in. FND-025 holds an endpoint apart from every page and reserved name, and to the methods its direction allows. A store the site writes to is never an ingress: the ground changes through the gates.

What it does not claim

What a door's index page says about itself beyond its name is still written by hand. A lede is writing and not data, and nothing yet distinguishes the two well enough to govern one and leave the other alone.

RUL-033