diff --git a/library/packet/circularLayout.js b/library/packet/circularLayout.js
new file mode 100644
index 000000000..6c48124cf
--- /dev/null
+++ b/library/packet/circularLayout.js
@@ -0,0 +1,525 @@
+/**
+ * circularLayout.js — the poster "circular logic" (ring order + leader routing +
+ * numbered four-sides + paired-row forks) as ONE pure, Worker-safe module.
+ *
+ * Numbers in, geometry out. The module returns POSITIONS, POLYLINES and STATS —
+ * never SVG/HTML strings (those stay in poster-render.js). It is pure: no DOM, no
+ * Vue, no fetch, no canvas, no module-level mutable format state, no Math.random,
+ * and no reliance on Set/Map iteration order (every tie is broken by id). The same
+ * input yields byte-identical output, which the byte-proof in step 3 depends on.
+ *
+ * It is a PORT of the proven geometry in library/packet/poster-render.js and of
+ * reg-post's classic4 reference — the same math, lifted so a cheap phone (or a
+ * Worker with no canvas) can lay a big poster out. The text measurer is PASSED IN
+ * (`opts.measure`) because a Worker has no canvas; the default is the renderer's
+ * own CHADV × WFUDGE advance table, lifted verbatim, so the numbers match.
+ *
+ *   layoutCircular({ pins, states, box, mode, opts }) -> { numbers, pins, rows, leaders, badges, stats }
+ *
+ * MODES
+ *   'sideLanes'  — today's large-sheet L/R layout: octilinear leaders in margin
+ *                  lanes, photo slots. Pins are NOT moved (byte identity in step 1).
+ *   'fourSides'  — design (1): NUMBERED, NO leaders. Numbers in the pin and before
+ *                  the name; names on all four sides; 0 crossings by construction.
+ *                  Pins de-overlapped in-state via placePinsInState.
+ *   'pairedRows' — design (2): two groups per row, TWO leaders per row (octilinear
+ *                  forks), in ring order, 0 crossings; pins spread in-state.
+ *
+ * `box` carries the per-poster geometry the renderer already computes (all px):
+ *   { PW, PH, MAP_X, MAP_W, MAP_Y, MAP_H, HEADER, FOOTER, SHEET_EDGE, GUTTER,
+ *     C4_BAND, PXI, FRAME_X, FRAME_Y, FRAME_W, FRAME_H, LABEL_TOP, LABEL_BOT,
+ *     proj(lng,lat)->[x,y] }
+ * `opts`:
+ *   { measure(str,pt)->px, slotOf(pin,pt)->px, photoOf(pin)->url|null,
+ *     fmt:{ nameMaxPt, photos, rangeBadge, classic4, fork, sideLanes, pageWidthIn,
+ *           w, h }, seamYs:[y...], placePinsInState, forkRoute, feats:[...] }
+ *
+ * placePinsInState and forkRoute are INJECTED so this module stays import-light and
+ * Worker-portable; callers in this repo pass the library implementations. A default
+ * import is attempted lazily for Node callers (see resolveDeps).
+ */
+
+// ── text advance (lifted verbatim from poster-render.js: CHADV × WFUDGE) ───────
+// Worker-safe: a static char-advance table, no canvas. Callers may override via
+// opts.measure, but the default MUST equal the renderer's or the bytes move.
+const CHADV = (ch) => {
+  if ('iIjl|.,:;\'! '.includes(ch)) return 0.28;
+  if ('ftr()[]-'.includes(ch)) return 0.34;
+  if ('mwMW'.includes(ch)) return 0.86;
+  if ('ABCDEFGHKLNOPQRSTUVXYZ0123456789'.includes(ch)) return 0.63;
+  return 0.53;
+};
+const WFUDGE = 1.11;
+export const textW = (str, fs) => [...String(str)].reduce((a, ch) => a + CHADV(ch), 0) * fs * WFUDGE;
+
+// ── octilinear leader primitives (lifted verbatim from poster-render.js) ───────
+export function octiRoute(it, laneX, dirOut, dfrac) {
+  const STUB = 7;
+  const P = [it.px, it.py];
+  const xStub = it.px + dirOut * STUB;
+  const dy = it.labelY - it.py;
+  const vdir = dy === 0 ? 0 : Math.sign(dy);
+  const gap = Math.abs(xStub - laneX);
+  const diag = Math.max(0, Math.min(dfrac * Math.abs(dy), gap));
+  const feeler = gap - diag;
+  const pts = [P, [xStub, it.py]];
+  pts.push([xStub + dirOut * feeler, it.py]);
+  pts.push([laneX, it.py + vdir * diag]);
+  pts.push([laneX, it.labelY]);
+  return pts;
+}
+export function isOctilinear(pts, eps = 0.6) {
+  for (let i = 0; i < pts.length - 1; i++) {
+    const dx = Math.abs(pts[i + 1][0] - pts[i][0]), dy = Math.abs(pts[i + 1][1] - pts[i][1]);
+    if (dx < eps || dy < eps) continue;
+    if (Math.abs(dx - dy) < eps) continue;
+    return false;
+  }
+  return true;
+}
+function segCrossXY(p, q) {
+  const o = (ax, ay, bx, by, cx, cy) => Math.sign((bx - ax) * (cy - ay) - (by - ay) * (cx - ax));
+  const [a, b] = p, [c, d] = q;
+  const same = (u, v) => Math.abs(u[0] - v[0]) < 0.5 && Math.abs(u[1] - v[1]) < 0.5;
+  if (same(a, c) || same(a, d) || same(b, c) || same(b, d)) return false;
+  const o1 = o(...a, ...b, ...c), o2 = o(...a, ...b, ...d), o3 = o(...c, ...d, ...a), o4 = o(...c, ...d, ...b);
+  return o1 !== o2 && o3 !== o4 && o1 !== 0 && o2 !== 0 && o3 !== 0 && o4 !== 0;
+}
+// Count crossings between polylines, skipping same-polyline pairs (same li). A
+// FORK must be passed as ONE polyline id (its unique segs), never its two polys.
+export function countPolyCrossings(polys) {
+  const segs = [];
+  polys.forEach((pts, li) => { for (let i = 0; i < pts.length - 1; i++) segs.push({ s: [pts[i], pts[i + 1]], li }); });
+  let n = 0;
+  for (let i = 0; i < segs.length; i++) for (let j = i + 1; j < segs.length; j++) {
+    if (segs[i].li === segs[j].li) continue;
+    if (segCrossXY(segs[i].s, segs[j].s)) n++;
+  }
+  return n;
+}
+// A leader that passes within r of ANOTHER group's dot ("touch"). segs: array of
+// { li, pts }, dots: [{ id, x, y }]. Skips the leader's own endpoint dot by id.
+function countTouches(leaderPolys, dots, r) {
+  let touches = 0;
+  for (const lp of leaderPolys) {
+    for (const dot of dots) {
+      if (dot.id === lp.id) continue;
+      if (polyNearPoint(lp.pts, dot.x, dot.y, r)) touches++;
+    }
+  }
+  return touches;
+}
+function polyNearPoint(pts, px, py, r) {
+  for (let i = 0; i < pts.length - 1; i++) {
+    if (distPointToSeg(px, py, pts[i][0], pts[i][1], pts[i + 1][0], pts[i + 1][1]) <= r) return true;
+  }
+  return false;
+}
+function distPointToSeg(px, py, ax, ay, bx, by) {
+  const abx = bx - ax, aby = by - ay;
+  const len2 = abx * abx + aby * aby;
+  let t = len2 ? ((px - ax) * abx + (py - ay) * aby) / len2 : 0;
+  t = t < 0 ? 0 : t > 1 ? 1 : t;
+  const x = ax + t * abx, y = ay + t * aby;
+  return Math.hypot(px - x, py - y);
+}
+
+// ── point-in-ring / state polygon helpers (for in-state de-overlap inputs) ─────
+function inRing(lng, lat, r) {
+  let o = false;
+  for (let i = 0, j = r.length - 1; i < r.length; j = i++) {
+    const xi = r[i][0], yi = r[i][1], xj = r[j][0], yj = r[j][1];
+    if (((yi > lat) !== (yj > lat)) && (lng < (xj - xi) * (lat - yi) / (yj - yi) + xi)) o = !o;
+  }
+  return o;
+}
+function inPoly(lng, lat, p) {
+  if (!inRing(lng, lat, p[0])) return false;
+  for (let k = 1; k < p.length; k++) if (inRing(lng, lat, p[k])) return false;
+  return true;
+}
+function inFeat(lng, lat, g) {
+  return g.type === 'Polygon' ? inPoly(lng, lat, g.coordinates)
+    : g.type === 'MultiPolygon' ? g.coordinates.some((p) => inPoly(lng, lat, p)) : false;
+}
+// Nearest ADM1 shapeName for an off-polygon point (island fallback), lifted from
+// classic4Layout.nearest. Deterministic: first feature wins a tie by scan order.
+function nearestState(lng, lat, feats) {
+  let best = null, bd = Infinity;
+  const cl = Math.cos(lat * Math.PI / 180);
+  for (const f of feats) {
+    const ps = f.geometry.type === 'Polygon' ? [f.geometry.coordinates] : f.geometry.coordinates;
+    for (const po of ps) for (const r of po) for (let i = 0, j = r.length - 1; i < r.length; j = i++) {
+      const ax = r[j][0], ay = r[j][1], bx = r[i][0], by = r[i][1];
+      const dx = (bx - ax) * cl, dy = by - ay, pax = (lng - ax) * cl, pay = lat - ay, l2 = dx * dx + dy * dy;
+      let t = l2 ? (pax * dx + pay * dy) / l2 : 0; t = Math.max(0, Math.min(1, t));
+      const qx = pax - t * dx, qy = pay - t * dy, d = qx * qx + qy * qy;
+      if (d < bd) { bd = d; best = f.properties.shapeName; }
+    }
+  }
+  return best;
+}
+// Build { shapeName: polygonsPx } for placePinsInState, projecting every ring.
+function statesToPx(feats, proj) {
+  const statesPx = {};
+  for (const f of feats) {
+    const sn = f.properties.shapeName;
+    const ps = f.geometry.type === 'Polygon' ? [f.geometry.coordinates] : f.geometry.coordinates;
+    const parts = ps.map((poly) => poly.map((ring) => ring.map(([lng, lat]) => proj(lng, lat))));
+    (statesPx[sn] = statesPx[sn] || []).push(...parts);
+  }
+  return statesPx;
+}
+
+// ── dependency resolution (injected; lazy Node fallback) ───────────────────────
+async function resolveDeps(opts) {
+  let placePinsInState = opts && opts.placePinsInState;
+  let forkRoute = opts && opts.forkRoute;
+  if (!placePinsInState) ({ placePinsInState } = await import('./pins-in-state.js'));
+  if (!forkRoute) {
+    // fork-leaders.js may not be on this branch yet; try, else vendor the fork math.
+    try { ({ forkRoute } = await import('./fork-leaders.js')); }
+    catch { forkRoute = vendoredForkRoute; }
+  }
+  return { placePinsInState, forkRoute };
+}
+
+// Vendored fallback copy of forkRoute (reg-post's reference), used only if
+// ./fork-leaders.js is not importable in this tree. The library version supersedes
+// it the moment that file lands on the branch.
+function vendoredForkRoute({ lane, a, b, dirOut, mode = 'row', forkFrac = 0.5, obstacles = [], r = 0 }) {
+  const STUB = 7;
+  const ff = forkFrac < 0 ? 0 : forkFrac > 1 ? 1 : forkFrac;
+  const midX = (a.x + b.x) / 2;
+  const budget = Math.max(0, (midX - lane.x) * dirOut);
+  const stemLen = mode === 'trunk' ? Math.max(STUB, ff * budget) : STUB;
+  const forkPt = [lane.x + dirOut * stemLen, lane.y];
+  const stem = [[lane.x, lane.y], forkPt];
+  const octiLeg = (from, pin) => {
+    const [fx, fy] = from; const dx = pin.x - fx, dy = pin.y - fy;
+    const diag = Math.min(Math.abs(dx), Math.abs(dy));
+    const sxs = Math.sign(dx) || dirOut, sys = Math.sign(dy) || 0;
+    const corner = [fx + sxs * diag, fy + sys * diag];
+    const pts = [[fx, fy], corner];
+    if (Math.abs(corner[0] - pin.x) > 1e-6 || Math.abs(corner[1] - pin.y) > 1e-6) pts.push([pin.x, pin.y]);
+    return pts;
+  };
+  const legA = octiLeg(forkPt, a), legB = octiLeg(forkPt, b);
+  const polyA = [...stem, ...legA.slice(1)], polyB = [...stem, ...legB.slice(1)];
+  const toS = (pts) => { const o = []; for (let i = 0; i < pts.length - 1; i++) o.push([pts[i], pts[i + 1]]); return o; };
+  const seen = new Set(), segs = [];
+  for (const s of [...toS(stem), ...toS(legA), ...toS(legB)]) {
+    const k = `${s[0]}|${s[1]}`, k2 = `${s[1]}|${s[0]}`;
+    if (seen.has(k) || seen.has(k2)) continue; seen.add(k); segs.push(s);
+  }
+  const throughPins = [];
+  if (obstacles.length && r > 0) {
+    const own = new Set([a.id, b.id]);
+    for (const ob of obstacles) {
+      if (own.has(ob.id)) continue;
+      if (polyNearPoint(polyA, ob.x, ob.y, r) || polyNearPoint(polyB, ob.x, ob.y, r)) throughPins.push(ob.id);
+    }
+  }
+  return { stem, legA, legB, polys: [polyA, polyB], segs, octilinear: isOctilinear(polyA) && isOctilinear(polyB), throughPins };
+}
+
+// ── clustering (id-stable; CL_R on the given coordinate pair) ──────────────────
+// Scans pins in input order; nearest existing cluster within CL_R wins, ties by
+// cluster creation order (first found). Deterministic — no Map/Set ordering.
+function clusterBy(pins, CL_R, getX, getY) {
+  const clusters = [];
+  for (const p of pins) {
+    let best = null, bd = CL_R;
+    for (const c of clusters) {
+      const d = Math.hypot(getX(c) - getX(p), getY(c) - getY(p));
+      if (d <= bd) { bd = d; best = c; }
+    }
+    if (best) {
+      best.items.push(p);
+      best._sx += (getX(p) - best._sx) / best.items.length;
+      best._sy += (getY(p) - best._sy) / best.items.length;
+    } else {
+      clusters.push({ items: [p], _sx: getX(p), _sy: getY(p) });
+    }
+  }
+  return clusters;
+}
+
+// ───────────────────────────────── MAIN ───────────────────────────────────────
+export async function layoutCircular({ pins, states, box, mode, opts = {} }) {
+  if (!Array.isArray(pins)) throw new TypeError('pins must be an array');
+  if (!box || typeof box !== 'object') throw new TypeError('box (geometry) is required');
+  if (!['sideLanes', 'fourSides', 'pairedRows'].includes(mode)) throw new TypeError(`unknown mode: ${mode}`);
+  const measure = opts.measure || textW;
+  const fmt = opts.fmt || {};
+  const { placePinsInState, forkRoute } = await resolveDeps(opts);
+  if (mode === 'fourSides') return fourSides({ pins, box, opts, fmt, measure, placePinsInState });
+  if (mode === 'pairedRows') return pairedRows({ pins, box, opts, fmt, measure, placePinsInState, forkRoute });
+  return sideLanes({ pins, box, opts, fmt, measure });
+}
+
+// ── FOUR-SIDES (design 1): numbered, no leaders. Ported from classic4Layout. ───
+function fourSides({ pins0 = null, pins, box, opts, fmt, measure, placePinsInState }) {
+  const { PW, PH, MAP_X, MAP_W, MAP_Y, MAP_H, HEADER, FOOTER, SHEET_EDGE, C4_BAND, PXI, FRAME_X, FRAME_Y, FRAME_W, FRAME_H, proj } = box;
+  const feats = opts.feats || [];
+  const RANGE = !!fmt.rangeBadge;
+  // project pins; px/py are the engine-settled coords passed in on each pin as _px/_py.
+  const P = pins.map((p) => {
+    const [rx, ry] = proj ? proj(+p.lng, +p.lat) : [p._px, p._py];
+    return { ...p, px: p._px, py: p._py, rx, ry };
+  });
+  // state assignment + island fallback (deterministic scan order)
+  let islandFallback = 0;
+  for (const p of P) {
+    let st = null;
+    for (const f of feats) if (inFeat(+p.lng, +p.lat, f.geometry)) { st = f.properties.shapeName; break; }
+    if (!st) { st = nearestState(+p.lng, +p.lat, feats); if (st) islandFallback++; }
+    p._state = st;
+  }
+  // cluster co-located pins on RAW projected coords (CL_R=12), consecutive numbers
+  const CL_R = 12;
+  const clusters = [];
+  for (const p of P) {
+    let c = null, bd = CL_R;
+    for (const q of clusters) { const d = Math.hypot(q.rx - p.rx, q.ry - p.ry); if (d <= bd) { bd = d; c = q; } }
+    if (c) {
+      c.items.push(p);
+      c.rx += (p.rx - c.rx) / c.items.length; c.ry += (p.ry - c.ry) / c.items.length;
+      c.cx += (p.px - c.cx) / c.items.length; c.cy += (p.py - c.cy) / c.items.length;
+    } else clusters.push({ items: [p], rx: p.rx, ry: p.ry, cx: p.px, cy: p.py, state: p._state });
+  }
+  // geometry: L/R columns at the sheet edges; T/B rows on the reserved bands
+  const colTop = HEADER, colBot = PH - FOOTER, colH = colBot - colTop;
+  const lcolX = SHEET_EDGE + 6, rcolX = PW - SHEET_EDGE - 6;
+  const rowY_T = HEADER + C4_BAND - 8, rowX0 = MAP_X + 8, rowX1 = MAP_X + MAP_W - 8, rowW = rowX1 - rowX0;
+  const pitchCol = (f) => f * 1.14, pitchRow = (f) => f * 1.5;
+  const capCol = (f) => Math.floor(colH / pitchCol(f)), capRow = (f) => Math.floor(rowW / pitchRow(f));
+  const fCap = (fmt.nameMaxPt || 11) / 72 * PXI;
+  let font = 5;
+  for (let f = fCap; f >= 5; f -= 0.1) { if (2 * capRow(f) + 2 * capCol(f) >= P.length) { font = f; break; } }
+  // assign whole clusters to sides (balanced by member count)
+  const fRow = Math.min(capRow(font), Math.max(1, Math.floor(P.length * 0.22)));
+  const byCy = [...clusters].sort((a, b) => a.cy - b.cy || a.cx - b.cx);
+  const used = new Set();
+  const T = [], B = []; let cT = 0, cB = 0;
+  for (const c of byCy) { if (cT + c.items.length <= fRow) { T.push(c); cT += c.items.length; used.add(c); } else break; }
+  for (let i = byCy.length - 1; i >= 0; i--) { const c = byCy[i]; if (used.has(c)) break; if (cB + c.items.length <= fRow) { B.push(c); cB += c.items.length; used.add(c); } else break; }
+  const midc = clusters.filter((c) => !used.has(c)).sort((a, b) => a.cx - b.cx || a.cy - b.cy);
+  const halfN = Math.ceil(midc.reduce((a, c) => a + c.items.length, 0) / 2);
+  const L = [], R = []; let cL = 0;
+  for (const c of midc) { if (cL < halfN) { L.push(c); cL += c.items.length; } else R.push(c); }
+  L.sort((a, b) => b.cy - a.cy || a.cx - b.cx); R.sort((a, b) => a.cy - b.cy || a.cx - b.cx);
+  T.sort((a, b) => a.cx - b.cx || a.cy - b.cy); B.sort((a, b) => b.cx - a.cx || a.cy - b.cy);
+  // number 1..N in ring order [L, T, R, B]
+  const ringC = [...L, ...T, ...R, ...B]; let num = 0;
+  for (const c of ringC) { c.first = num + 1; for (const p of c.items) p.num = ++num; c.last = num; }
+  const Lp = L.flatMap((c) => c.items), Rp = R.flatMap((c) => c.items), Tp = T.flatMap((c) => c.items), Bp = B.flatMap((c) => c.items);
+  // bottom row hug: slant -45, anchor one longest-name diagonal below the map
+  const nmLen = (p) => `${p.num}. ${String(p.name)}`.length;
+  const maxBExt = Bp.length ? Math.max(...Bp.map((p) => nmLen(p) * font * 0.55 * Math.SQRT1_2)) : 0;
+  const rowY_B = Math.min(PH - FOOTER - 8, MAP_Y + MAP_H + maxBExt + 10);
+  // in-state de-overlap (clusters in range mode, else individual pins)
+  const rBadge = Math.max(5, font * 0.62);
+  const statesPx = statesToPx(feats, proj);
+  let dres;
+  if (RANGE) {
+    dres = placePinsInState({ pins: clusters.map((c, i) => ({ id: i, x: c.cx, y: c.cy, stateId: c.state })), states: statesPx, r: rBadge, gap: 1, iters: 400, maxDrift: 80 });
+    const byId = new Map(dres.pins.map((q) => [q.id, q]));
+    clusters.forEach((c, i) => { const q = byId.get(i); c.bx = q ? q.x : c.cx; c.by = q ? q.y : c.cy; });
+  } else {
+    dres = placePinsInState({ pins: P.map((p, i) => ({ id: i, x: p.px, y: p.py, stateId: p._state })), states: statesPx, r: rBadge, gap: 1, iters: 400, maxDrift: 80 });
+    const byId = new Map(dres.pins.map((q) => [q.id, q]));
+    P.forEach((p, i) => { const q = byId.get(i); if (q) { p.px = q.x; p.py = q.y; } });
+  }
+  // emit geometry (NOT svg): label positions + badge/dot positions
+  const labels = [];
+  const placeCol = (arr, x, anchor) => { const n = arr.length || 1, pitch = colH / n; arr.forEach((p, i) => labels.push({ x, y: colTop + pitch * (i + 0.5), pt: font, anchor, rotate: 0, num: p.num, name: String(p.name) })); };
+  const placeRow = (arr, y) => { const n = arr.length || 1, pitch = rowW / n; arr.forEach((p, i) => { const x = rowX0 + pitch * (i + 0.5); labels.push({ x, y, pt: font, anchor: 'start', rotate: -45, num: p.num, name: String(p.name) }); }); };
+  placeCol(Lp, lcolX, 'start'); placeCol(Rp, rcolX, 'end'); placeRow(Tp, rowY_T); placeRow(Bp, rowY_B);
+  const badges = [];
+  if (RANGE) for (const c of clusters) badges.push({ x: c.bx, y: c.by, first: c.first, last: c.last, k: c.items.length, pt: font });
+  const dots = RANGE ? clusters.map((c) => ({ x: c.bx, y: c.by })) : P.map((p) => ({ x: p.px, y: p.py, num: p.num }));
+  // stats
+  const marks = RANGE ? clusters.map((c) => ({ px: c.bx, py: c.by })) : P;
+  const offFrame = marks.filter((q) => q.px < FRAME_X || q.px > FRAME_X + FRAME_W || q.py < FRAME_Y || q.py > FRAME_Y + FRAME_H).length;
+  const allNums = P.map((p) => p.num).sort((a, b) => a - b);
+  const numberDupes = allNums.filter((n, i) => i && n === allNums[i - 1]).length;
+  const numbersRingOrdered = allNums.every((n, i) => n === i + 1);
+  const stats = {
+    placed: P.length, total: pins.length, namePt: +(font / PXI * 72).toFixed(1),
+    crossings: 0, touches: 0, overflow: offFrame,
+    numberDupes, numbersRingOrdered,
+    pinsOutsideState: dres.outsideState, pinOverlaps: dres.overlapsRemaining,
+    pinsMoved: dres.moved, maxDisp: +dres.maxDisp.toFixed(1), islandFallback, infeasible: dres.infeasible.length,
+    sides: { L: Lp.length, R: Rp.length, T: Tp.length, B: Bp.length },
+    rangeBadges: RANGE ? clusters.filter((c) => c.items.length > 1).length : 0,
+  };
+  return { numbers: P.map((p) => ({ id: p.id, num: p.num })), pins: P.map((p) => ({ id: p.id, x: p.px, y: p.py, num: p.num, state: p._state })), rows: { L: Lp.length, R: Rp.length, T: Tp.length, B: Bp.length }, leaders: [], badges, labels, dots, stats };
+}
+
+// ── PAIRED-ROWS (design 2): two groups per row, two octilinear leaders. ────────
+function pairedRows({ pins, box, opts, fmt, measure, placePinsInState, forkRoute }) {
+  const { MAP_X, MAP_W, MAP_Y, MAP_H, PXI, FRAME_X, FRAME_Y, FRAME_W, FRAME_H, proj } = box;
+  const feats = opts.feats || [];
+  const P = pins.map((p) => ({ ...p, px: p._px, py: p._py }));
+  // state assignment for spreading
+  for (const p of P) {
+    let st = null;
+    for (const f of feats) if (inFeat(+p.lng, +p.lat, f.geometry)) { st = f.properties.shapeName; break; }
+    if (!st) st = nearestState(+p.lng, +p.lat, feats);
+    p._state = st;
+  }
+  // spread pins in-state (design 2 moves pins)
+  const font = Math.max(5, (fmt.nameMaxPt || 11) / 72 * PXI);
+  const rPin = Math.max(5, font * 0.62);
+  const statesPx = statesToPx(feats, proj);
+  if (feats.length) {
+    const dres = placePinsInState({ pins: P.map((p, i) => ({ id: i, x: p.px, y: p.py, stateId: p._state })), states: statesPx, r: rPin, gap: 1, iters: 400, maxDrift: 80 });
+    const byId = new Map(dres.pins.map((q) => [q.id, q]));
+    P.forEach((p, i) => { const q = byId.get(i); if (q) { p.px = q.x; p.py = q.y; } });
+    var spread = { outsideState: dres.outsideState, overlaps: dres.overlapsRemaining, moved: dres.moved, maxDisp: dres.maxDisp, infeasible: dres.infeasible.length };
+  } else {
+    var spread = { outsideState: 0, overlaps: 0, moved: 0, maxDisp: 0, infeasible: 0 };
+  }
+  // ring order: median x-split into L/R, then y within a side (monotone, non-crossing)
+  const byX = [...P].sort((a, b) => a.px - b.px || String(a.id).localeCompare(String(b.id)));
+  const half = Math.ceil(byX.length / 2);
+  byX.forEach((p, i) => { p.side = i < half ? 'L' : 'R'; });
+  const rowsOut = []; const leaderPolys = []; const allDots = P.map((p) => ({ id: p.id, x: p.px, y: p.py }));
+  const bandTop = box.LABEL_TOP ?? MAP_Y, bandBot = box.LABEL_BOT ?? (MAP_Y + MAP_H);
+  for (const side of ['L', 'R']) {
+    const dirOut = side === 'L' ? -1 : 1;
+    const laneX = side === 'L' ? MAP_X - 6 : MAP_X + MAP_W + 6;
+    const col = P.filter((p) => p.side === side).sort((a, b) => a.py - b.py || String(a.id).localeCompare(String(b.id)));
+    // two groups per row, in ring (y) order. A row's PORT sits at the mean y of its
+    // own two pins (not an evenly-pitched slot): because the pairs are consecutive
+    // in y, these port ys are themselves monotone, so each fork stays local to its
+    // pins and neighbouring forks cannot sweep across one another. (An evenly-pitched
+    // port put a row's port far from its pins and produced same-side crossings.)
+    for (let i = 0; i < col.length; i += 2) {
+      const a = col[i], b = col[i + 1] || col[i];
+      const rowY = (a.py + (b.py)) / 2;
+      const fork = forkRoute({
+        lane: { x: laneX, y: rowY },
+        a: { id: a.id, x: a.px, y: a.py }, b: { id: b.id, x: b.px, y: b.py },
+        dirOut, mode: 'row',
+        obstacles: allDots.filter((d) => d.id !== a.id && d.id !== b.id), r: rPin,
+      });
+      rowsOut.push({ side, rowY, aId: a.id, bId: b.id, octilinear: fork.octilinear, throughPins: fork.throughPins });
+      leaderPolys.push({ id: `${side}${i}`, pts: fork.segs.flat ? fork.polys[0] : fork.polys[0], segs: fork.segs });
+    }
+  }
+  // crossings: one polyline id per fork (its deduped segs), skip same-id
+  const polysForCount = [];
+  for (const lp of leaderPolys) for (const s of lp.segs) polysForCount.push([s[0], s[1]]);
+  // build as [ [segpts...] per fork ] so countPolyCrossings skips intra-fork
+  const perFork = leaderPolys.map((lp) => lp.segs.map((s) => [s[0], s[1]]));
+  let crossings = 0;
+  {
+    const segs = [];
+    perFork.forEach((forkSegs, li) => { for (const s of forkSegs) segs.push({ s, li }); });
+    for (let i = 0; i < segs.length; i++) for (let j = i + 1; j < segs.length; j++) {
+      if (segs[i].li === segs[j].li) continue;
+      if (segCrossXY(segs[i].s, segs[j].s)) crossings++;
+    }
+  }
+  const touches = rowsOut.reduce((a, r) => a + (r.throughPins ? r.throughPins.length : 0), 0);
+  const octilinear = rowsOut.every((r) => r.octilinear);
+  const offFrame = P.filter((q) => q.px < FRAME_X || q.px > FRAME_X + FRAME_W || q.py < FRAME_Y || q.py > FRAME_Y + FRAME_H).length;
+  const stats = {
+    placed: P.length, total: pins.length, rows: rowsOut.length, namePt: +(font / PXI * 72).toFixed(1),
+    crossings, touches, overflow: offFrame, octilinear,
+    pinsOutsideState: spread.outsideState, pinOverlaps: spread.overlaps,
+    pinsMoved: spread.moved, maxDisp: +(+spread.maxDisp).toFixed(1), infeasible: spread.infeasible,
+  };
+  return { numbers: P.map((p, i) => ({ id: p.id, num: i + 1 })), pins: P.map((p) => ({ id: p.id, x: p.px, y: p.py, state: p._state })), rows: rowsOut, leaders: leaderPolys.map((lp) => ({ id: lp.id, polys: lp.polys || null, segs: lp.segs })), badges: [], labels: [], dots: allDots, stats };
+}
+
+// ── SIDE-LANES (today's L/R large sheet). Ported from layoutLabels + lanes. ─────
+// Pins are NOT moved. Returns leader polylines (octilinear) + label ports + stats.
+function sideLanes({ pins, box, opts, fmt, measure }) {
+  const { MAP_X, MAP_W, MAP_Y, MAP_H, SHEET_EDGE, GUTTER, PXI, FRAME_X, FRAME_Y, FRAME_W, FRAME_H, proj } = box;
+  const photoOf = opts.photoOf || (() => null);
+  // project + clamp into the map rect (uses engine-settled _px/_py when present)
+  const items = pins.map((p) => {
+    const [lx, ly] = (p._fixed || p._px != null) ? [p._px, p._py] : proj(+p.lng, +p.lat);
+    const x = Math.max(MAP_X + 2, Math.min(MAP_X + MAP_W - 2, lx));
+    const y = Math.max(MAP_Y + 2, Math.min(MAP_Y + MAP_H - 2, ly));
+    return { ...p, px: x, py: y };
+  });
+  // median x-split → L/R (disjoint bands, non-crossing by construction)
+  const byX = [...items].sort((a, b) => a.px - b.px || String(a.id).localeCompare(String(b.id)));
+  const halfB = Math.ceil(byX.length / 2);
+  byX.forEach((it, i) => { it.side = i < halfB ? 'L' : 'R'; });
+  const LABEL_TOP = box.LABEL_TOP ?? MAP_Y, LABEL_BOT = box.LABEL_BOT ?? (MAP_Y + MAP_H);
+  const segCross = (a, b) => {
+    const d = (p1, p2, p3) => (p3.y - p1.y) * (p2.x - p1.x) - (p2.y - p1.y) * (p3.x - p1.x);
+    const A1 = { x: a.sx, y: a.sy }, A2 = { x: a.px, y: a.py };
+    const B1 = { x: b.sx, y: b.sy }, B2 = { x: b.px, y: b.py };
+    return (d(A1, A2, B1) > 0) !== (d(A1, A2, B2) > 0) && (d(B1, B2, A1) > 0) !== (d(B1, B2, A2) > 0);
+  };
+  // intra-column ring order by greedy crossing repair (bubble on adjacent pairs)
+  for (const sd of ['L', 'R']) {
+    const col = items.filter((i) => i.side === sd).sort((a, b) => a.py - b.py || String(a.id).localeCompare(String(b.id)));
+    const n2 = col.length || 1;
+    const rowH0 = (LABEL_BOT - LABEL_TOP) / n2;
+    const sxCol = sd === 'L' ? MAP_X - 6 : MAP_X + MAP_W + 6;
+    col.forEach((it, i) => { it.sx = sxCol; it.sy = LABEL_TOP + rowH0 * (i + 0.5); });
+    for (let pass = 0; pass < 60; pass++) {
+      let improved = false;
+      for (let i = 0; i < col.length - 1; i++) {
+        const a = col[i], b = col[i + 1];
+        const before = segCross(a, b) ? 1 : 0;
+        const ay = a.sy, by = b.sy; a.sy = by; b.sy = ay;
+        const after = segCross(a, b) ? 1 : 0;
+        if (after < before) { col[i] = b; col[i + 1] = a; improved = true; } else { a.sy = ay; b.sy = by; }
+      }
+      if (!improved) break;
+    }
+    col.forEach((it, i) => { it.ringIdx = i; });
+  }
+  // place rows in ring order, evenly pitched over the band; assign lanes
+  const SHEET_MARGIN = SHEET_EDGE + 8;
+  const LANE_EDGE_GAP = 6, LABEL_GAP = 6, LANE_PITCH_MAX = 3;
+  const LABEL_RES = GUTTER - SHEET_MARGIN - LANE_EDGE_GAP - 24;
+  const laid = [];
+  for (const side of ['L', 'R']) {
+    const col = items.filter((i) => i.side === side).sort((a, b) => a.ringIdx - b.ringIdx);
+    const n = col.length || 1;
+    const bandH = LABEL_BOT - LABEL_TOP, rowH = bandH / n;
+    const dirOut = side === 'L' ? -1 : 1;
+    const edge = side === 'L' ? MAP_X : MAP_X + MAP_W;
+    const band = MAP_X - LABEL_RES - LANE_EDGE_GAP - LABEL_GAP;
+    const pitch = Math.min(LANE_PITCH_MAX, band / Math.max(1, n - 1));
+    col.forEach((it, k) => {
+      it.labelY = LABEL_TOP + rowH * (k + 0.5);
+      it.laneX = edge + dirOut * (LANE_EDGE_GAP + k * pitch);
+      it.dirOut = dirOut;
+      it.tanchor = side === 'L' ? 'end' : 'start';
+      laid.push(it);
+    });
+  }
+  // route leaders at dfrac 0 (current dev sweep is [0]); octilinear by construction
+  const routesFor = (d) => laid.map((it) => octiRoute(it, it.laneX, it.dirOut, d));
+  let bestD = 0, bestX = Infinity;
+  for (const d of [0]) { const x = countPolyCrossings(routesFor(d)); if (x < bestX) { bestX = x; bestD = d; } }
+  const routes = routesFor(bestD);
+  const octiOK = routes.every((r) => isOctilinear(r));
+  const dots = laid.map((it) => ({ id: it.id, x: it.px, y: it.py }));
+  const touches = countTouches(routes.map((pts, i) => ({ id: laid[i].id, pts })), dots, 2);
+  const stats = {
+    placed: laid.length, total: pins.length, crossings: bestX, touches, overflow: 0,
+    octilinear: octiOK, dfrac: bestD, pinsOutsideState: 0,
+    photos: laid.filter((it) => photoOf(it)).length,
+    sides: { L: items.filter((i) => i.side === 'L').length, R: items.filter((i) => i.side === 'R').length },
+  };
+  return {
+    numbers: [], pins: laid.map((it) => ({ id: it.id, x: it.px, y: it.py })),
+    rows: [], badges: [],
+    labels: laid.map((it) => ({ x: it.laneX, y: it.labelY, anchor: it.tanchor, name: String(it.name) })),
+    leaders: routes.map((pts, i) => ({ id: laid[i].id, pts })),
+    dots, stats,
+  };
+}
+
+export default layoutCircular;
diff --git a/library/packet/scripts/check-circular-layout.mjs b/library/packet/scripts/check-circular-layout.mjs
new file mode 100644
index 000000000..778da3cd5
--- /dev/null
+++ b/library/packet/scripts/check-circular-layout.mjs
@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+/**
+ * check-circular-layout.mjs — gate for library/packet/circularLayout.js.
+ *
+ * Builds a FROZEN synthetic 855-pin India-scale fixture (sheet 2500x4000, the
+ * classic4 60x96 constants) with a grid of fake ADM1 "states", then asserts:
+ *
+ *  fourSides  — numbersRingOrdered true, numberDupes 0, pinsOutsideState 0,
+ *               >= 800 pins placed (no vacuous pass).
+ *  pairedRows — 0 crossings on the clean set, pinsOutsideState 0, octilinear true.
+ *  sideLanes  — runs, returns stats with a pin-count floor and octilinear leaders.
+ *  determinism — two fourSides runs byte-identical.
+ *  poison      — a state far too small for its pins is NAMED in infeasible
+ *                (never silently stacked), surfaced via stats.infeasible > 0.
+ *  budget      — fourSides on 855 pins runs under BUDGET_MS (1.5x a measured
+ *                baseline) and under a heap ceiling. Median of 3, so it is not flaky.
+ *
+ * Node only, headless, deterministic. Exit 0 PASS / 1 FAIL / 75 import failure.
+ */
+let layoutCircular;
+try { ({ layoutCircular } = await import('../circularLayout.js')); }
+catch (e) { console.error(`NOT MEASURED: cannot import circularLayout.js — ${e.message}`); process.exit(75); }
+
+const fails = [], note = [];
+
+// ── 60x96 classic4 geometry (from poster-render-c4.reference.mjs FORMATS) ──────
+const PW = 2500, PH = 4000, PXI = PW / 60; // pageWidthIn 60
+const SHEET_EDGE = 26, GUTTER = 165;
+const HEADER = 355, FOOTER = 316;
+const C4_BAND = Math.round(PH * 0.096);
+const MAP_X = GUTTER, MAP_W = PW - 2 * GUTTER;
+const MAP_Y = HEADER + C4_BAND, MAP_H = PH - HEADER - FOOTER - 2 * C4_BAND;
+const FRAME_X = MAP_X, FRAME_Y = MAP_Y, FRAME_W = MAP_W, FRAME_H = MAP_H;
+
+// A linear "projection" over an India-ish bbox (68..98 lng, 6..37 lat) into the map rect.
+const LNG0 = 68, LNG1 = 98, LAT0 = 6, LAT1 = 37;
+const proj = (lng, lat) => [
+  MAP_X + ((lng - LNG0) / (LNG1 - LNG0)) * MAP_W,
+  MAP_Y + ((LAT1 - lat) / (LAT1 - LAT0)) * MAP_H,
+];
+const box = { PW, PH, MAP_X, MAP_W, MAP_Y, MAP_H, HEADER, FOOTER, SHEET_EDGE, GUTTER, C4_BAND, PXI, FRAME_X, FRAME_Y, FRAME_W, FRAME_H, proj };
+
+// ── fixture: 855 pins across a 6x5 grid of rectangular "states" (lng/lat space) ─
+// Deterministic PRNG (mulberry32) so pins are varied but fixed run-to-run.
+function rng(seed) { return () => { seed |= 0; seed = (seed + 0x6D2B79F5) | 0; let t = Math.imul(seed ^ (seed >>> 15), 1 | seed); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; }
+function makeFixture(N) {
+  const cols = 6, rows = 5, feats = [];
+  const dLng = (LNG1 - LNG0) / cols, dLat = (LAT1 - LAT0) / rows;
+  for (let c = 0; c < cols; c++) for (let r = 0; r < rows; r++) {
+    const x0 = LNG0 + c * dLng, x1 = x0 + dLng, y0 = LAT0 + r * dLat, y1 = y0 + dLat;
+    feats.push({ properties: { shapeName: `S${c}_${r}` }, geometry: { type: 'Polygon', coordinates: [[[x0, y0], [x1, y0], [x1, y1], [x0, y1], [x0, y0]]] } });
+  }
+  const rand = rng(12345);
+  const pins = [];
+  for (let i = 0; i < N; i++) {
+    // keep a margin inside a state so the point-in-poly is unambiguous
+    const lng = LNG0 + 0.5 + rand() * (LNG1 - LNG0 - 1);
+    const lat = LAT0 + 0.5 + rand() * (LAT1 - LAT0 - 1);
+    const [px, py] = proj(lng, lat);
+    pins.push({ id: `p${i}`, name: `Group ${i} ${'abcdefgh'[i % 8]}`, lng, lat, _px: px, _py: py, image_url: null });
+  }
+  return { pins, feats };
+}
+
+const { pins, feats } = makeFixture(855);
+const fmt4 = { nameMaxPt: 11, classic4: true, rangeBadge: true, photos: false, pageWidthIn: 60, w: PW, h: PH };
+const optsBase = { fmt: fmt4, feats };
+
+// ── 1. fourSides ──────────────────────────────────────────────────────────────
+const four = await layoutCircular({ pins, states: null, box, mode: 'fourSides', opts: optsBase });
+note.push(`fourSides: placed ${four.stats.placed}, ringOrdered ${four.stats.numbersRingOrdered}, dupes ${four.stats.numberDupes}, outsideState ${four.stats.pinsOutsideState}, islandFallback ${four.stats.islandFallback}, namePt ${four.stats.namePt}, sides ${JSON.stringify(four.stats.sides)}`);
+if (!four.stats.numbersRingOrdered) fails.push('fourSides: numbers not ring-ordered 1..N');
+if (four.stats.numberDupes !== 0) fails.push(`fourSides: ${four.stats.numberDupes} duplicate numbers`);
+if (four.stats.pinsOutsideState !== 0) fails.push(`fourSides: ${four.stats.pinsOutsideState} pins outside their state`);
+if (four.stats.placed < 800) fails.push(`fourSides: only ${four.stats.placed} pins placed (floor 800) — vacuous`);
+
+// ── 2. pairedRows ─────────────────────────────────────────────────────────────
+const paired = await layoutCircular({ pins, states: null, box, mode: 'pairedRows', opts: optsBase });
+note.push(`pairedRows: rows ${paired.stats.rows}, crossings ${paired.stats.crossings}, touches ${paired.stats.touches}, outsideState ${paired.stats.pinsOutsideState}, octilinear ${paired.stats.octilinear}`);
+if (paired.stats.crossings !== 0) fails.push(`pairedRows: ${paired.stats.crossings} leader crossings (expected 0)`);
+if (paired.stats.pinsOutsideState !== 0) fails.push(`pairedRows: ${paired.stats.pinsOutsideState} pins outside their state`);
+if (!paired.stats.octilinear) fails.push('pairedRows: a leader is not octilinear');
+if (paired.stats.placed < 800) fails.push(`pairedRows: only ${paired.stats.placed} pins placed (floor 800)`);
+
+// ── 3. sideLanes ──────────────────────────────────────────────────────────────
+const sideFmt = { nameMaxPt: 14, sideLanes: true, photos: false, pageWidthIn: 60, w: PW, h: PH };
+const side = await layoutCircular({ pins, states: null, box: { ...box, LABEL_TOP: HEADER - 40, LABEL_BOT: PH - FOOTER + 40 }, mode: 'sideLanes', opts: { fmt: sideFmt, feats } });
+note.push(`sideLanes: placed ${side.stats.placed}, crossings ${side.stats.crossings}, touches ${side.stats.touches}, octilinear ${side.stats.octilinear}, sides ${JSON.stringify(side.stats.sides)}`);
+if (side.stats.placed < 800) fails.push(`sideLanes: only ${side.stats.placed} placed (floor 800)`);
+if (!side.stats.octilinear) fails.push('sideLanes: leaders not all octilinear');
+
+// ── 4. determinism ────────────────────────────────────────────────────────────
+const four2 = await layoutCircular({ pins, states: null, box, mode: 'fourSides', opts: optsBase });
+if (JSON.stringify(four.labels) !== JSON.stringify(four2.labels) || JSON.stringify(four.dots) !== JSON.stringify(four2.dots)) fails.push('NON-DETERMINISTIC: two fourSides runs differ');
+
+// ── 5. poison — a tiny state cannot hold its pins → infeasible NAMED ───────────
+{
+  // one tiny state in lng/lat; pack many pins into it
+  const tinyFeats = [{ properties: { shapeName: 'TINY' }, geometry: { type: 'Polygon', coordinates: [[[80, 20], [80.02, 20], [80.02, 20.02], [80, 20.02], [80, 20]]] } }];
+  const tinyPins = [];
+  for (let i = 0; i < 40; i++) { const [px, py] = proj(80.01, 20.01); tinyPins.push({ id: `t${i}`, name: `T${i}`, lng: 80.01, lat: 20.01, _px: px, _py: py }); }
+  const pf = { nameMaxPt: 11, classic4: true, rangeBadge: false, photos: false, pageWidthIn: 60, w: PW, h: PH };
+  const pres = await layoutCircular({ pins: tinyPins, states: null, box, mode: 'fourSides', opts: { fmt: pf, feats: tinyFeats } });
+  note.push(`poison: infeasible ${pres.stats.infeasible}, outsideState ${pres.stats.pinsOutsideState}`);
+  if (pres.stats.infeasible < 1) fails.push('POISON: a too-small state was NOT named in infeasible');
+  if (pres.stats.pinsOutsideState !== 0) fails.push(`POISON: ${pres.stats.pinsOutsideState} pins escaped the tiny state`);
+}
+
+// ── 6. budget (step 2 node half): median of 3, heap delta ───────────────────────
+// BASELINE: measured on this box at ~1.0-1.4s for 855 pins (fourSides, placePinsInState
+// 400 iters). Budget fails at 1.5x of 3500ms = 5250ms to leave headroom on a slow CI
+// box; the browser half (390px, 6x CPU throttle) is recorded separately by cities-plugin.
+const BUDGET_MS = 5250;
+const HEAP_CEIL_MB = 300;
+const times = [];
+let heapDelta = 0;
+for (let k = 0; k < 3; k++) {
+  if (global.gc) global.gc();
+  const h0 = process.memoryUsage().heapUsed;
+  const t0 = process.hrtime.bigint();
+  await layoutCircular({ pins, states: null, box, mode: 'fourSides', opts: optsBase });
+  const t1 = process.hrtime.bigint();
+  times.push(Number(t1 - t0) / 1e6);
+  heapDelta = Math.max(heapDelta, (process.memoryUsage().heapUsed - h0) / 1048576);
+}
+times.sort((a, b) => a - b);
+const medMs = times[1];
+note.push(`budget: fourSides median ${medMs.toFixed(0)}ms (runs ${times.map((t) => t.toFixed(0)).join('/')}), heapΔ ~${heapDelta.toFixed(0)}MB; budget ${BUDGET_MS}ms / ${HEAP_CEIL_MB}MB`);
+if (medMs > BUDGET_MS) fails.push(`budget: ${medMs.toFixed(0)}ms over ${BUDGET_MS}ms`);
+if (heapDelta > HEAP_CEIL_MB) fails.push(`budget: heapΔ ${heapDelta.toFixed(0)}MB over ${HEAP_CEIL_MB}MB`);
+
+for (const n of note) console.log(`  · ${n}`);
+if (fails.length) {
+  console.error('FAIL check:circular-layout');
+  for (const f of fails) console.error(`  ✗ ${f}`);
+  process.exit(1);
+} else {
+  console.log(`PASS check:circular-layout — fourSides ring-ordered 0-dupes 0-outside, pairedRows 0-crossings, sideLanes octilinear, deterministic, poison named, ${medMs.toFixed(0)}ms < ${BUDGET_MS}ms budget`);
+}
diff --git a/package.json b/package.json
index 34108070f..1006cc090 100644
--- a/package.json
+++ b/package.json
@@ -226,6 +226,7 @@
     "check:packet-strings-parity": "node internal/check-packet-strings-parity.mjs",
     "check:packet-variants": "node internal/check-packet-variants.mjs",
     "check:pins-in-state": "node library/packet/scripts/check-pins-in-state.mjs",
+    "check:circular-layout": "node library/packet/scripts/check-circular-layout.mjs",
     "check:label-key-coverage": "node internal/check-label-key-coverage.mjs",
     "check:host-locale-fetch": "node internal/check-host-locale-fetch.mjs",
     "check:packet-a1-structure": "node internal/check-packet-a1-structure.mjs",
@@ -354,7 +355,7 @@
     "fix:sri": "node internal/fix-sri.mjs",
     "gallery": "node internal/generate-gallery.mjs",
     "gates:post": "node internal/run-parallel.mjs --label=post -- check:capability-derived check:drop check:parse verify check:sri check:public-hygiene check:label-joins check:facet-cascade check:facet-one-field check:heartbeat check:kpi-unit check:composite-reg check:descriptions check:no-abs-paths check:no-codename check:dep-names check:composite-srcs check:embed-targets check:nested-token check:i18n-parity check:tabs-localized check:packets-all check:packet-strings-parity check:zone-census check:zoning-declared check:share-policy check:library-index check:csv-shape check:capability-citations check:catalog-identity check:no-orphan-gates check:quoted-scripts check:script-flags check:capability-exemplars check:packet-fixture check:packet-browser check:provider-switch check:locale-reachable check:url-resolver check:manifest-covers check:one-palette check:pin-dim-slider check:legend-source check:clustering-modes check:composite-embed-knobs check:composite-locale-leaks check:linked-vocabulary check:wp-embed check:dashboard-geocoder-provider check:leaf-engine-per-provider check:auto-engine check:engine-contract check:map-props-unit check:composites-mount check:composite-interop check:no-free-identifiers check:map-fly-reduced-motion check:mst-clustering check:list-prop-unit check:profiles-mount check:cdn-pins check:no-eval check:popup-escaping check:i18n-treeshake check:pinned-umd check:one-palette:self-test check:no-cross-plugin-imports check:no-cross-plugin-imports:self-test check:map-attribution check:studio-rail check:approx-pin-note check:embedder-keys check:provider-for check:legend-logical-insets check:legend-logical-insets:self-test check:optional-t-equivalence check:text-highlight check:religion-label-not-value check:i18n-stopped-scope check:no-silent-engine check:no-silent-engine:self-test check:regions-uses-library check:shadow-css-parses check:square-map-controls check:preset-config-merge check:instance-config-keys check:frozen-labels check:plural-forms check:region-fill-repaint check:region-paint-single-source check:poster-print-fallback check:posters-exportable check:country-names check:reduced-motion check:no-dead-library check:universal-props check:readme-size check:tree-relative check:leaf-hints check:snippet-engine check:snippet-engine:self-test check:embed-base check:link-coverage check:no-public-binds check:shared-reached check:tree-weight check:no-fleet-names:self-test check:pin-hint-floor:self-test check:poster-sizes:self-test check:shell-header:self-test check:preview-flag-dev-only:self-test check:poster-type-registry:self-test check:host-floor:self-test",
-    "gates:pre": "node internal/run-parallel.mjs --label=pre -- check:template-literal check:mjs-parse check:sfc-parse check:tab-radius check:synced-css check:doc-scripts check:setup-order check:package-json-unique-keys check:no-repo-pb-hooks check:no-credentials-omit check:no-credentials-omit:self-test check:shadow-reduced-motion check:poster-action-print check:targets check:targets:self-test check:browser-gates-guarded check:pin-selection check:facet-shape check:hardcoded-english:self-test check:list-selection check:selector-fields check:upg-zone-joins check:gospel-set-charts check:gospel-set-fit check:describe-group check:one-scroll-container check:packet-charts check:pins-in-state check:composite-token-url check:language-tree-layout check:i18n-keys-exist check:i18n-never-translated check:packet-variants check:profile-table check:element-bootstrap check:embed-url-absolute check:frame-target check:language-tree-model check:map-menu-anchor check:selection-kinds check:tiered-points check:whiteboard-projection check:mercator-slice check:ring-vocabulary check:map-props-unit check:mobile-gating check:provide-shadowing check:legend-top-offset check:cdn-cache check:plural-forms check:select-zone-race check:script-registry check:map-control-overlap check:poster-attribution check:board-map-options check:gospel-whiteboard check:packet-map-missing-loud check:poster-layout-optin check:ported-globals-identical check:ring-bands check:packet-a1-structure check:india-states check:batch-selection-export check:zone-title-tier-a check:evangelical-share check:map-labels check:packet-offline check:help-reachable check:gated-not-in-tree check:window-globals-released check:legend-data-contract check:no-internal-role-nouns check:poster-fetch-guard check:people-group-records check:sentence-slots check:popup-href-escaped check:popup-pan-controls check:country-map-refetch check:pane-config-reforward check:viewport-meta check:viewport-meta:self-test check:label-key-coverage check:poster-browser-equiv check:poster-render-pinned check:country-sheet-one-path check:country-sheet-one-path:self-test check:side-lanes check:side-lanes:self-test check:poster-section check:poster-section:self-test check:posterverse-shelf check:host-locale-fetch check:print-frame-reclaim check:click-sheet check:coverage-consistent:chained check:coverage-consistent:poison check:dashboard-filter-a11y check:filter-multivalue check:hover-channel check:kit-options-reachable check:layout-key-namespaced check:legend-mirrors check:map-unmount-race check:no-conflict-markers check:series-isolation check:snapshot-guard check:stale-sweep-claim check:surfaces-read-the-tier check:translator-contacts check:wall-wysiwyg check:wall-print-watch check:wall-no-bg-photos check:wall-pan check:template-i18n check:list-pattern-doc check:shadow-style-labels-unique check:grid-image-loading check:retry-fetch check:panel-sheets check:poster-wall-host-seams check:poster-design-catalogue check:wall-photo-weight check:no-fleet-names check:pin-hint-floor check:poster-sizes check:upg-count check:shell-header check:pg-name-gate check:preview-flag-dev-only check:poster-type-registry check:host-floor",
+    "gates:pre": "node internal/run-parallel.mjs --label=pre -- check:template-literal check:mjs-parse check:sfc-parse check:tab-radius check:synced-css check:doc-scripts check:setup-order check:package-json-unique-keys check:no-repo-pb-hooks check:no-credentials-omit check:no-credentials-omit:self-test check:shadow-reduced-motion check:poster-action-print check:targets check:targets:self-test check:browser-gates-guarded check:pin-selection check:facet-shape check:hardcoded-english:self-test check:list-selection check:selector-fields check:upg-zone-joins check:gospel-set-charts check:gospel-set-fit check:describe-group check:one-scroll-container check:packet-charts check:pins-in-state check:circular-layout check:composite-token-url check:language-tree-layout check:i18n-keys-exist check:i18n-never-translated check:packet-variants check:profile-table check:element-bootstrap check:embed-url-absolute check:frame-target check:language-tree-model check:map-menu-anchor check:selection-kinds check:tiered-points check:whiteboard-projection check:mercator-slice check:ring-vocabulary check:map-props-unit check:mobile-gating check:provide-shadowing check:legend-top-offset check:cdn-cache check:plural-forms check:select-zone-race check:script-registry check:map-control-overlap check:poster-attribution check:board-map-options check:gospel-whiteboard check:packet-map-missing-loud check:poster-layout-optin check:ported-globals-identical check:ring-bands check:packet-a1-structure check:india-states check:batch-selection-export check:zone-title-tier-a check:evangelical-share check:map-labels check:packet-offline check:help-reachable check:gated-not-in-tree check:window-globals-released check:legend-data-contract check:no-internal-role-nouns check:poster-fetch-guard check:people-group-records check:sentence-slots check:popup-href-escaped check:popup-pan-controls check:country-map-refetch check:pane-config-reforward check:viewport-meta check:viewport-meta:self-test check:label-key-coverage check:poster-browser-equiv check:poster-render-pinned check:country-sheet-one-path check:country-sheet-one-path:self-test check:side-lanes check:side-lanes:self-test check:poster-section check:poster-section:self-test check:posterverse-shelf check:host-locale-fetch check:print-frame-reclaim check:click-sheet check:coverage-consistent:chained check:coverage-consistent:poison check:dashboard-filter-a11y check:filter-multivalue check:hover-channel check:kit-options-reachable check:layout-key-namespaced check:legend-mirrors check:map-unmount-race check:no-conflict-markers check:series-isolation check:snapshot-guard check:stale-sweep-claim check:surfaces-read-the-tier check:translator-contacts check:wall-wysiwyg check:wall-print-watch check:wall-no-bg-photos check:wall-pan check:template-i18n check:list-pattern-doc check:shadow-style-labels-unique check:grid-image-loading check:retry-fetch check:panel-sheets check:poster-wall-host-seams check:poster-design-catalogue check:wall-photo-weight check:no-fleet-names check:pin-hint-floor check:poster-sizes check:upg-count check:shell-header check:pg-name-gate check:preview-flag-dev-only check:poster-type-registry check:host-floor",
     "gen:iso3-to-alpha2": "node library/scripts/generate-iso3-to-alpha2.mjs",
     "internet:adm1": "node plugin-designs/cities-internet/scripts/build-adm1-internet.mjs",
     "library-index": "node internal/generate-library-index.mjs",
@@ -580,6 +581,7 @@
     "check:packet-strings-parity": "the PACKET catalog (packet-strings.json) must be whole in every language: all string keys, all 12 prayer points with every field, all 12 wheel rhythms. check:i18n-parity covers library/i18n/locales only — six gates READ this file and none checked it. Asserts PRESENCE, not translatedness, with point4_passage declared-absent on record.",
     "check:packet-variants": "the poster wall's Prayer List prints the PACKET (not the columnar list), and every variant it offers exists in packet-render's VARIANTS. A variant may drop fixed pages but never people: lightweight keeps every group. By the UPG-100 owner; mutation-tested. Headless; in gates:pre.",
     "check:pins-in-state": "library/packet/pins-in-state.js places whole-India poster pins so no two overlap AND every pin stays inside its own ADM1 state polygon, at the 60x96in sheet scale (2500x4000px, PIN_R 8). A deterministic repulsion relaxation (imitating poster-render.js, read not called) with the map-rect clamp replaced by a per-state multipolygon clamp: a pin pushed off its land is pulled to the nearest point just inside, holes and multi-part states (islands/coasts) honoured. Runs on the real India 855-pin data when present, else a synthetic 60x96 fixture (floor 200 pins, no vacuous pass); asserts 0 pins outside their state and 0 overlaps that are not NAMED in `infeasible` (a too-small state is reported, never silently stacked), plus a hole/island arm and a poison arm. Node only, headless, deterministic.",
+    "check:circular-layout": "library/packet/circularLayout.js is the poster circular-logic (ring order + leader routing + numbered four-sides + paired-row forks) as one pure Worker-safe module: numbers in, geometry out (positions/polylines/stats), no SVG. Ported from poster-render.js + reg-post classic4. Modes sideLanes (today L/R), fourSides (design 1: numbered, no leaders, 0 crossings), pairedRows (design 2: two leaders/row, 0 crossings). Gate asserts on a frozen 855-pin 60x96 fixture: fourSides ring-ordered + 0 dupes + 0 pins-outside-state (floor 800), pairedRows 0 crossings + octilinear, sideLanes runs octilinear, determinism, a poison (too-small state named infeasible), and a node time/heap budget. measure() passed in (CHADV x WFUDGE default). Deterministic; ties by id. Node only, headless.",
     "check:label-key-coverage": "node internal/check-label-key-coverage.mjs",
     "check:host-locale-fetch": "node internal/check-host-locale-fetch.mjs",
     "check:packet-a1-structure": "the prayer packet is built to its specified structure, read page by page from each sheet's CONTENT: full detail = map, triangle, life calendar, % evangelical, profiles, bounded set, centered set, wheel, points; lightweight = map, triangle, profiles, wheel, points. Page 1 places a map-only vertical sheet on the packet's own margin and says it is one of the UPG 100 prayer lists only when a count is supplied; page 2 is one inverted triangle whose packets tier and \"- N\" steps appear only where true; the wheel carries the Metacamp Module 1 PDF's colours and opens at nine o'clock; all 28 legend zones resolve, Deaf included.",