Commitment · Structural

One engine, and a second runtime of it is a port under proof

adopted a build gate proves it

Binding a pattern is one function. Where it has to run somewhere the build cannot reach, the second copy is a port of the first and never a second design, and a proof that both find the same bindings runs before the site is built. A second implementation without that proof is two models of one thing, which is the drift this ground exists to refuse.

What goes wrong without it

Everything a reader could see had been bound while the graph was built, so a reader standing on a term could only ever be shown a shape somebody had already written a page for. That is the whole of what the surface could do: render what was found. A person composing from the term in front of them, and an agent arriving with nothing but the published graph, both need to ask for a shape nobody declared, and neither can wait for a rebuild. The engine is short enough to port honestly and too important to port on trust.

What proves it — 1

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.

eval:enginethe engine agrees with itself
The binder that runs while the graph is built and the binder that runs in a reader's browser find the same bindings: every pattern bound against the whole model to the same instances and the same rows in every role, the published example among them, and every view bound again from every row it answers from, row for row, and the port of the pattern law beside the browser's engine refuses every way a declared pattern can be broken exactly as the law does, and every question bound again from every row of its root kind finds an answer exactly where the build published one and nothing where it did not.

Derived from — 2

Reproducible Builds project, reproducible-builds.orgReproducible Builds: definition
Martin Fowler, martinfowler.com, revised 2024Continuous Integration

Where this model stands

scripts/ground/patterns.py binds while the graph is built and its answers are what the pages show; site/src/lib/bind.ts is the same function in the reader's browser and in anything that fetches the published graph.

site/scripts/binder_agrees.mjs binds every declared pattern again with the second engine and holds it to the artifact the first wrote: the same instances, the same rows in every role, the published example among the bindings found, and every view bound again from every row it answers from, row for row. It runs before the site builds and fails it on any disagreement.

The second engine needs nothing the reader does not already have: the published graph carries every assertion and every kind, so binding in a browser and binding in an agent are the same act on the same two files.

What it does not claim

Nothing generates one engine from the other. They are held identical by their answers rather than by their source, which is the weaker guarantee but the only one available across two languages.

The proof binds what this model declares and every row it answers from. A pattern nobody has declared is not bound by either engine, so agreement on it is untested until it exists.

RUL-039