Connector geometry: pure functions from measured rectangles to SVG path data (ADR-0005 decision 10, and the 2026-08-29 amendment to decision 7).

The amendment admits a second JavaScript hook, StatifierBlocksMeasure, whose entire job is to read the boxes the browser laid out and push them. Clause 7b.2 then says where the drawing happens: the connector geometry itself is computed on the server, as pure functions from measured rectangles to path data. That is this module. It is the graduation of the geometry half of the campaign-012/013 spike's spike/js/layout.js, which kept the same split for the same reason and which spike/dev/selftest.html could only assert inside Chrome.

Here it runs in the gate. Nothing below reads the DOM, names a block type, or reaches for the web framework: a rectangle is a rectangle, and that is what keeps decision 13's promise that rendering is testable without a browser. This module therefore lives outside StatifierBlocks.Editor.* and loads in the headless tree, exactly as ViewModel and Shell do.

The three stages

1. measurement/1 decodes the hook's push into %{anchor key => rect}. It is total: the payload arrives from the DOM, which is not a trusted source, and anything malformed is dropped rather than raised on.
2. edges/2 walks a ViewModel.Node tree and, for every edge adjacency and nesting imply, resolves the anchors it needs and emits one Edge. An edge whose anchors were not measured is skipped, which is what makes the whole layer degrade to nothing when the hook is absent.
3. The path functions - flow_path/3, fan_path/3, join_path/3, interrupt_path/4 - turn two points into orthogonal path data with rounded corners. Orthogonal rather than bezier because at nesting depth 7 a curve that passes near a card reads as ambiguous and a right angle never does.

The 7d choices this module records

Clause 7d left four questions to the implementation, each to be answered "with a test rather than by guess". All four are written down here, because a wire has two ends and the record should be readable from the end that is testable in the gate.

Payload shape: whole stage, flat, keyed by the server's own string

One push carries every measured anchor, never a delta:

%{
  "stage" => %{"w" => 1200.0, "h" => 2400.0},
  "anchors" => [%{"k" => "card:blk_a", "x" => 8.0, "y" => 8.0,
                  "w" => 300.0, "h" => 32.0}, ...]
}

A delta needs a shared memory of the previous measurement on both ends, and 7a forbids the hook holding "state that survives a re-render". A whole stage also satisfies 7c's plainest statement of what a measurement is - that the push be reconstructible from the rendering alone - which a delta by construction is not.

The key is the string the server stamped in data-sb-anchor. The hook never composes one and this module never parses one: keys are built by card_anchor/1 and its siblings and compared whole, so a block id may contain any character an id may contain without the wire having an opinion about it.

Coordinate space: the stage's own untransformed space

Every rectangle is relative to the stage's top-left corner, in the stage's untransformed pixels. The hook subtracts the stage origin and divides by the scale it reads off the stage, which is the single arithmetic step the spike's render.js found necessary under zoom: the <svg> these coordinates are written into is a child of the stage, drawn in the stage's own space and sized from scrollWidth, so rendered coordinates would scale twice and detach every line from the card it joins.

The alternative 7d names - push rendered coordinates and a scale, and let the server divide - was rejected because it would put the zoom into the server's geometry, and the property below is what it would have cost: nothing in this module knows a scale or an origin exists. Translating every measured rectangle translates every path by the same amount, and no other transform is applied anywhere.

Push cadence: mount, update, and a stage resize, over two frames

The hook measures on mount, on every updated(), and on a resize of the stage, and each of those is scheduled through TWO animation frames and coalesced into a single push. Two rather than one because the first frame is merely when the DOM is live and the second is after a font swap or a scrollbar has settled - the spike found exactly this, and routing against a pre-swap measurement is the classic way connectors end up a few pixels off the cards they join.

The cadence terminates without the hook remembering anything, which is what 7a's "no state that survives a re-render" costs and why it costs nothing: edges/2 is a pure function of the tree and the measurement, so an unchanged measurement renders unchanged markup, LiveView computes an empty diff, no patch is sent, and updated() is not called again. The loop closes on this module's purity rather than on the client's memory.

Anchor attribute names: one attribute, one opaque value

Decision 7's DOM contract gains exactly one attribute, data-sb-anchor, whose value is the anchor key. One attribute rather than a family of them because the hook's read is then querySelectorAll("[data-sb-anchor]") - one query, no knowledge of block structure, and no key composed on the client. The seven kinds of anchor the shipped markup stamps:

• stage - the canvas root, which is what makes the other boxes comparable to each other (7c names the stage box explicitly);
• node:<block id> - a block's whole box, which is where an interrupt channel is placed relative to;
• card:<block id> - a block's chrome, the box an edge arrives at;
• outlet:<block id> - a zero-height anchor at the bottom of a block, the box flow leaves from;
• slot:<block id>/<slot name> - a slot's header, which is where a fan edge lands. Not the first card inside it: the header carries the slot's name and its guard, and an edge that ran past it would cross the very condition it is subject to;
• fan:<block id> - the ONE OF / ALL OF pill below an arranged container, the point its fan leaves from;
• join:<block id> - the join marker below that container's columns, the point their rejoins arrive at.

The last two are the only anchors that may be absent while the block they name is on the page: a stacked container renders no pill and a type that phrased no join renders no marker. Both fall back to the card and the outlet, which is where every fan left and arrived before campaign 016.