@seatlayer/core 0.29.0 → 0.30.1

package/dist/index.cjs

@@ -411,6 +411,7 @@ function transformSectionOutlinePath(path, transform, radiusScale = 1, reflected
     })
   };
 }
+var SAGITTA_TO_CONTROL = 4 / 3;
 
 // src/core/labeling.ts
 var FULL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -503,6 +504,345 @@ function sectionGeometry(section, context = {}) {
   return { height, rake };
 }
 
+// src/core/venueStructure.ts
+var BLOCK_LINK_RATIO = 1.8;
+function probesOf(pts) {
+  const n = pts.length;
+  if (n <= 3) return [...pts];
+  return [pts[Math.floor(n * 0.25)], pts[Math.floor(n * 0.5)], pts[Math.floor(n * 0.75)]];
+}
+function distanceToPolyline(pts, x, y) {
+  if (!pts.length) return Infinity;
+  if (pts.length === 1) return Math.hypot(x - pts[0].x, y - pts[0].y);
+  let best = Infinity;
+  for (let i = 0; i + 1 < pts.length; i++) {
+    const a = pts[i], b = pts[i + 1];
+    const vx = b.x - a.x, vy = b.y - a.y;
+    const len2 = vx * vx + vy * vy;
+    let t2 = len2 > 1e-12 ? ((x - a.x) * vx + (y - a.y) * vy) / len2 : 0;
+    if (t2 < 0) t2 = 0;
+    else if (t2 > 1) t2 = 1;
+    const d = Math.hypot(x - (a.x + t2 * vx), y - (a.y + t2 * vy));
+    if (d < best) best = d;
+  }
+  return best;
+}
+function boundOf(pts) {
+  let cx = 0, cy = 0;
+  for (const p of pts) {
+    cx += p.x;
+    cy += p.y;
+  }
+  const n = pts.length || 1;
+  cx /= n;
+  cy /= n;
+  let r = 0;
+  for (const p of pts) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > r) r = d;
+  }
+  return { cx, cy, r };
+}
+function boundGap(a, b) {
+  return Math.hypot(a.cx - b.cx, a.cy - b.cy) - a.r - b.r;
+}
+function rowGap(a, b) {
+  let best = Infinity;
+  for (const p of probesOf(a)) {
+    const d = distanceToPolyline(b, p.x, p.y);
+    if (d < best) best = d;
+  }
+  for (const p of probesOf(b)) {
+    const d = distanceToPolyline(a, p.x, p.y);
+    if (d < best) best = d;
+  }
+  return best;
+}
+function orderAlongRow(pts, indices) {
+  if (pts.length < 3) return { pts, seatIndices: indices };
+  let cx = 0, cy = 0;
+  for (const p of pts) {
+    cx += p.x;
+    cy += p.y;
+  }
+  cx /= pts.length;
+  cy /= pts.length;
+  let far = -1, ax = pts[0];
+  for (const p of pts) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > far) {
+      far = d;
+      ax = p;
+    }
+  }
+  let dx = ax.x - cx, dy = ax.y - cy;
+  const len = Math.hypot(dx, dy);
+  if (len > 1e-9) {
+    dx /= len;
+    dy /= len;
+  } else {
+    dx = 1;
+    dy = 0;
+  }
+  const order = pts.map((p, i) => ({ p, i, t: (p.x - cx) * dx + (p.y - cy) * dy })).sort((u, v) => u.t - v.t);
+  return { pts: order.map((o) => o.p), seatIndices: order.map((o) => indices[o.i]) };
+}
+function fitCircle(pts) {
+  const n = pts.length;
+  if (n < 3) return null;
+  let mx = 0, my = 0;
+  for (const p of pts) {
+    mx += p.x;
+    my += p.y;
+  }
+  mx /= n;
+  my /= n;
+  let suu = 0, suv = 0, svv = 0, suuu = 0, svvv = 0, suvv = 0, svuu = 0;
+  for (const p of pts) {
+    const u = p.x - mx, v = p.y - my;
+    suu += u * u;
+    svv += v * v;
+    suv += u * v;
+    suuu += u * u * u;
+    svvv += v * v * v;
+    suvv += u * v * v;
+    svuu += v * u * u;
+  }
+  const det = suu * svv - suv * suv;
+  if (Math.abs(det) < 1e-9) return null;
+  const b1 = (suuu + suvv) / 2;
+  const b2 = (svvv + svuu) / 2;
+  const uc = (b1 * svv - b2 * suv) / det;
+  const vc = (b2 * suu - b1 * suv) / det;
+  const cx = uc + mx, cy = vc + my;
+  if (!Number.isFinite(cx) || !Number.isFinite(cy)) return null;
+  return { cx, cy };
+}
+var CIRCLE_ROW_SPREAD_LIMIT = 0.15;
+function fitBlockAxis(group) {
+  if (group.length < 2) return null;
+  const cents = group.map((r) => {
+    let x = 0, y = 0;
+    for (const p of r.pts) {
+      x += p.x;
+      y += p.y;
+    }
+    return { x: x / r.pts.length, y: y / r.pts.length };
+  });
+  let ox = 0, oy = 0;
+  for (const c of cents) {
+    ox += c.x;
+    oy += c.y;
+  }
+  ox /= cents.length;
+  oy /= cents.length;
+  let sxx = 0, sxy = 0, syy = 0;
+  for (const c of cents) {
+    const dx = c.x - ox, dy = c.y - oy;
+    sxx += dx * dx;
+    sxy += dx * dy;
+    syy += dy * dy;
+  }
+  const tr = sxx + syy;
+  const det = sxx * syy - sxy * sxy;
+  const lambda = tr / 2 + Math.sqrt(Math.max(0, tr * tr / 4 - det));
+  let ax, ay;
+  if (Math.abs(sxy) > 1e-12) {
+    ax = lambda - syy;
+    ay = sxy;
+  } else if (sxx >= syy) {
+    ax = 1;
+    ay = 0;
+  } else {
+    ax = 0;
+    ay = 1;
+  }
+  const len = Math.hypot(ax, ay);
+  if (!(len > 1e-12)) return null;
+  ax /= len;
+  ay /= len;
+  let lo = Infinity, hi = -Infinity;
+  const widths = [];
+  for (const r of group) {
+    let rlo = Infinity, rhi = -Infinity;
+    for (const p of r.pts) {
+      const t2 = p.x * ax + p.y * ay;
+      if (t2 < rlo) rlo = t2;
+      if (t2 > rhi) rhi = t2;
+      if (t2 < lo) lo = t2;
+      if (t2 > hi) hi = t2;
+    }
+    widths.push(rhi - rlo);
+  }
+  const range = hi - lo;
+  if (!(range > 1e-9)) return null;
+  widths.sort((a, b) => a - b);
+  const p90 = widths[Math.min(widths.length - 1, Math.floor(widths.length * 0.9))];
+  return p90 / range <= AXIS_ROW_WIDTH_LIMIT ? { x: ax, y: ay } : null;
+}
+var AXIS_ROW_WIDTH_LIMIT = 0.35;
+function resolveSection(sectionId, seats, seatIndices, focal) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const i of seatIndices) {
+    const s = seats[i];
+    const key = s.rowId || `__seat-${i}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { pts: [], idx: [] };
+      groups.set(key, g);
+    }
+    g.pts.push({ x: s.x, y: s.y });
+    g.idx.push(i);
+  }
+  if (!groups.size) return { sectionId, rows: [], blockCount: 0 };
+  const rows = [];
+  for (const [id, g] of groups) {
+    const ordered = orderAlongRow(g.pts, g.idx);
+    let sum = 0;
+    for (const p of ordered.pts) sum += Math.hypot(p.x - focal.x, p.y - focal.y);
+    rows.push({
+      id,
+      pts: ordered.pts,
+      seatIndices: ordered.seatIndices,
+      blockId: -1,
+      ordinal: 0,
+      blockDepth: 0,
+      focalDistance: sum / ordered.pts.length
+    });
+  }
+  const bounds2 = rows.map((r) => boundOf(r.pts));
+  const nearest = [];
+  for (let i = 0; i < rows.length; i++) {
+    let best = Infinity;
+    for (let j = 0; j < rows.length; j++) {
+      if (i === j) continue;
+      if (boundGap(bounds2[i], bounds2[j]) >= best) continue;
+      const d = rowGap(rows[i].pts, rows[j].pts);
+      if (d < best) best = d;
+    }
+    if (Number.isFinite(best)) nearest.push(best);
+  }
+  nearest.sort((a, b) => a - b);
+  const typicalGap = nearest.length ? nearest[Math.floor(nearest.length / 2)] : 1;
+  const linkDistance = Math.max(typicalGap * BLOCK_LINK_RATIO, 1e-6);
+  const adjacency = rows.map(() => []);
+  for (let i = 0; i < rows.length; i++) {
+    for (let j = i + 1; j < rows.length; j++) {
+      if (boundGap(bounds2[i], bounds2[j]) > linkDistance) continue;
+      if (rowGap(rows[i].pts, rows[j].pts) <= linkDistance) {
+        adjacency[i].push(j);
+        adjacency[j].push(i);
+      }
+    }
+  }
+  let blockCount = 0;
+  for (let i = 0; i < rows.length; i++) {
+    if (rows[i].blockId !== -1) continue;
+    const id = blockCount++;
+    const stack = [i];
+    rows[i].blockId = id;
+    while (stack.length) {
+      const k = stack.pop();
+      for (const n of adjacency[k]) {
+        if (rows[n].blockId !== -1) continue;
+        rows[n].blockId = id;
+        stack.push(n);
+      }
+    }
+  }
+  const byBlock = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const a = byBlock.get(r.blockId) ?? [];
+    a.push(r);
+    byBlock.set(r.blockId, a);
+  }
+  const centres = [];
+  for (const r of rows) {
+    if (r.pts.length < 4) continue;
+    const c = fitCircle(r.pts);
+    if (!c) continue;
+    if (!Number.isFinite(c.cx) || !Number.isFinite(c.cy)) continue;
+    centres.push({ x: c.cx, y: c.cy });
+  }
+  const centre = centres.length >= 2 ? (() => {
+    const xs = centres.map((c) => c.x).sort((a, b) => a - b);
+    const ys = centres.map((c) => c.y).sort((a, b) => a - b);
+    const mid = Math.floor(centres.length / 2);
+    return { cx: xs[mid], cy: ys[mid] };
+  })() : null;
+  if (centre) {
+    const radiusOf = (p) => Math.hypot(p.x - centre.cx, p.y - centre.cy);
+    let lo = Infinity, hi = -Infinity;
+    const spreads = [];
+    for (const r of rows) {
+      let rlo = Infinity, rhi = -Infinity;
+      for (const p of r.pts) {
+        const d = radiusOf(p);
+        if (d < rlo) rlo = d;
+        if (d > rhi) rhi = d;
+      }
+      spreads.push(rhi - rlo);
+      if (rlo < lo) lo = rlo;
+      if (rhi > hi) hi = rhi;
+    }
+    const range = hi - lo;
+    spreads.sort((a, b) => a - b);
+    const p90 = spreads[Math.min(spreads.length - 1, Math.floor(spreads.length * 0.9))];
+    if (range > 1e-9 && p90 / range <= CIRCLE_ROW_SPREAD_LIMIT) {
+      const withRadius = rows.map((r) => {
+        let sum = 0;
+        for (const p of r.pts) sum += radiusOf(p);
+        return { row: r, radius: sum / r.pts.length };
+      });
+      let minR = Infinity;
+      for (const w of withRadius) if (w.radius < minR) minR = w.radius;
+      withRadius.sort((a, b) => a.radius - b.radius);
+      let ordinal = -1, lastRadius = -Infinity;
+      const tolerance = range / Math.max(1, withRadius.length) * 0.5;
+      const ordered = [];
+      for (const w of withRadius) {
+        if (w.radius - lastRadius > tolerance) {
+          ordinal++;
+          lastRadius = w.radius;
+        }
+        w.row.ordinal = ordinal;
+        w.row.blockDepth = w.radius - minR;
+        ordered.push(w.row);
+      }
+      return { sectionId, rows: ordered, blockCount };
+    }
+  }
+  const out = [];
+  for (const [, group] of byBlock) {
+    const axis = fitBlockAxis(group);
+    if (axis) {
+      const key = (r) => {
+        let sum = 0;
+        for (const p of r.pts) sum += p.x * axis.x + p.y * axis.y;
+        return sum / r.pts.length;
+      };
+      group.sort((a, b) => key(a) - key(b));
+      let depth = 0;
+      for (let i = 0; i < group.length; i++) {
+        if (i > 0) depth += rowGap(group[i - 1].pts, group[i].pts);
+        group[i].ordinal = i;
+        group[i].blockDepth = depth;
+        out.push(group[i]);
+      }
+    } else {
+      let front = Infinity;
+      for (const r of group) if (r.focalDistance < front) front = r.focalDistance;
+      group.sort((a, b) => a.focalDistance - b.focalDistance);
+      for (let i = 0; i < group.length; i++) {
+        group[i].ordinal = i;
+        group[i].blockDepth = Math.max(0, group[i].focalDistance - front);
+        out.push(group[i]);
+      }
+    }
+  }
+  return { sectionId, rows: out, blockCount };
+}
+
 // src/core/layout.ts
 function overrideAccessibility(o) {
   if (!o) return [];
@@ -948,7 +1288,7 @@ function stackFloors(doc, spread = 900) {
   });
   return { ...doc, objects, floors: void 0 };
 }
-function expandFloorObjects(objects, zones, fallbackFocal) {
+function expandFloorObjects(objects, zones, fallbackFocal, viewFallback) {
   const out = [];
   const segmented = /* @__PURE__ */ new Map();
   const grouped = /* @__PURE__ */ new Map();
@@ -1018,6 +1358,7 @@ function expandFloorObjects(objects, zones, fallbackFocal) {
     const resolvedFocal = zone?.focalPoint ?? fallbackFocal;
     for (const seat of seats) {
       if (inheritedView) seat.viewUrl ??= inheritedView;
+      if (viewFallback) seat.viewUrl ??= viewFallback;
       if (owner) seat.sectionId = owner.logicalSectionId ?? owner.id;
       if (owner?.zone) seat.zoneId = owner.zone;
       if (resolvedFocal) seat.focalPoint = { ...resolvedFocal };
@@ -1031,13 +1372,14 @@ function expandChart(doc, options = {}) {
     const out2 = [];
     for (const floor of doc.floors) {
       const floorFocal = floor.focalPoint ?? doc.focalPoint;
-      const seats = expandFloorObjects(floor.objects, doc.zones, floorFocal);
+      const floorView = floor.viewFromSeatUrl ?? doc.viewFromSeatUrl;
+      const seats = expandFloorObjects(floor.objects, doc.zones, floorFocal, floorView);
       assignEyeHeights(floor.objects, floor.focalPoint ?? doc.focalPoint, floor.baseHeightM ?? 0, seats);
       out2.push(...seats);
     }
     return out2;
   }
-  const out = expandFloorObjects(doc.objects, doc.zones, doc.focalPoint);
+  const out = expandFloorObjects(doc.objects, doc.zones, doc.focalPoint, doc.viewFromSeatUrl);
   assignEyeHeights(doc.objects, doc.focalPoint, options.floorBaseHeightM ?? 0, out);
   return out;
 }
@@ -1050,17 +1392,28 @@ function assignEyeHeights(objects, focal, floorBaseHeightM, seats) {
   }
   const owner = new Array(seats.length);
   const geo = /* @__PURE__ */ new Map();
-  const frontDistU = /* @__PURE__ */ new Map();
+  const seatsBySection = /* @__PURE__ */ new Map();
   for (let i = 0; i < seats.length; i++) {
     const seat = seats[i];
     const sec = sections.find((s) => pointInPolygonWithHoles({ x: seat.x, y: seat.y }, s.outline, s.holes)) ?? null;
     owner[i] = sec;
     if (!sec) continue;
     if (!geo.has(sec.id)) geo.set(sec.id, sectionGeometry(sec, { floorBaseHeightM }));
-    const seatFocal = seat.focalPoint ?? focal;
-    const d = Math.hypot(seat.x - seatFocal.x, seat.y - seatFocal.y);
-    const cur = frontDistU.get(sec.id);
-    if (cur === void 0 || d < cur) frontDistU.set(sec.id, d);
+    const list = seatsBySection.get(sec.id);
+    if (list) list.push(i);
+    else seatsBySection.set(sec.id, [i]);
+  }
+  const seatLevel = new Array(seats.length).fill(void 0);
+  for (const [secId, indices] of seatsBySection) {
+    const g = geo.get(secId);
+    if (!g) continue;
+    const rakeTan = g.rake > 0 ? Math.tan(g.rake * Math.PI / 180) : 0;
+    const structure = resolveSection(secId, seats, indices, focal);
+    for (const row of structure.rows) {
+      const riseM = row.blockDepth * METRES_PER_CHART_UNIT * rakeTan;
+      const level = g.height + riseM;
+      for (const si of row.seatIndices) seatLevel[si] = level;
+    }
   }
   for (let i = 0; i < seats.length; i++) {
     const seat = seats[i];
@@ -1070,14 +1423,7 @@ function assignEyeHeights(objects, focal, floorBaseHeightM, seats) {
       continue;
     }
     const g = geo.get(sec.id);
-    let riseM = 0;
-    if (g.rake > 0) {
-      const seatFocal = seat.focalPoint ?? focal;
-      const d = Math.hypot(seat.x - seatFocal.x, seat.y - seatFocal.y);
-      const depthU = Math.max(0, d - (frontDistU.get(sec.id) ?? d));
-      riseM = depthU * METRES_PER_CHART_UNIT * Math.tan(g.rake * Math.PI / 180);
-    }
-    seat.eyeHeightM = g.height + riseM + SEATED_EYE_HEIGHT_M;
+    seat.eyeHeightM = (seatLevel[i] ?? g.height) + SEATED_EYE_HEIGHT_M;
   }
 }
 var PAD = 40;
@@ -9030,24 +9376,44 @@ function drawSeated(ctx, hx, hy, r, o) {
   const skin = `rgba(${o.tone[0]},${o.tone[1]},${o.tone[2]},${o.alpha})`;
   ctx.save();
   ctx.translate(hx, hy);
+  const leanPx = o.lean * r;
   ctx.fillStyle = clo;
   ctx.beginPath();
   ctx.moveTo(-neckHalf, neckTopY);
-  ctx.quadraticCurveTo(-neckHalf * 1.18, shoulderY - r * 0.6, -shHalf, shoulderY);
+  ctx.quadraticCurveTo(-neckHalf * 1.18, shoulderY - leanPx - r * 0.6, -shHalf, shoulderY - leanPx);
   ctx.quadraticCurveTo(-shHalf * 1.05, shoulderY + r * 1.2, -shHalf * 0.94, botY);
   ctx.lineTo(shHalf * 0.94, botY);
-  ctx.quadraticCurveTo(shHalf * 1.05, shoulderY + r * 1.2, shHalf, shoulderY);
-  ctx.quadraticCurveTo(neckHalf * 1.18, shoulderY - r * 0.6, neckHalf, neckTopY);
+  ctx.quadraticCurveTo(shHalf * 1.05, shoulderY + r * 1.2, shHalf, shoulderY + leanPx);
+  ctx.quadraticCurveTo(neckHalf * 1.18, shoulderY + leanPx - r * 0.6, neckHalf, neckTopY);
   ctx.closePath();
   ctx.fill();
   ctx.fillStyle = skin;
   ctx.fillRect(-neckHalf * 0.82, r * 0.5, neckHalf * 1.64, r * 0.9);
   ctx.save();
   ctx.rotate(o.tilt);
+  ctx.translate(o.turn * r, 0);
   ctx.fillStyle = skin;
-  ctx.beginPath();
-  ctx.ellipse(0, 0, r * 0.9, r * 1.06, 0, 0, TAU2);
-  ctx.fill();
+  if (r >= 18) {
+    ctx.beginPath();
+    ctx.moveTo(-r * 0.9, -r * 0.15);
+    ctx.quadraticCurveTo(-r * 0.96, -r * 1.12, 0, -r * 1.06);
+    ctx.quadraticCurveTo(r * 0.96, -r * 1.12, r * 0.9, -r * 0.15);
+    ctx.quadraticCurveTo(r * 0.86, r * 0.55, r * 0.36, r * 0.98);
+    ctx.quadraticCurveTo(0, r * 1.14, -r * 0.36, r * 0.98);
+    ctx.quadraticCurveTo(-r * 0.86, r * 0.55, -r * 0.9, -r * 0.15);
+    ctx.closePath();
+    ctx.fill();
+    if (r >= 22) {
+      ctx.beginPath();
+      ctx.ellipse(-r * 0.9, r * 0.18, r * 0.13, r * 0.22, 0, 0, TAU2);
+      ctx.ellipse(r * 0.9, r * 0.18, r * 0.13, r * 0.22, 0, 0, TAU2);
+      ctx.fill();
+    }
+  } else {
+    ctx.beginPath();
+    ctx.ellipse(0, 0, r * 0.9, r * 1.06, 0, 0, TAU2);
+    ctx.fill();
+  }
   drawHair(ctx, r, o.hair);
   if (o.rim > 0.01) {
     ctx.strokeStyle = `rgba(245,205,150,${(0.5 * o.rim).toFixed(3)})`;
@@ -9071,15 +9437,17 @@ function drawSeated(ctx, hx, hy, r, o) {
 function drawSeatedMid(ctx, hx, hy, r, clothing, tone, alpha) {
   ctx.fillStyle = `rgba(${clothing[0]},${clothing[1]},${clothing[2]},${alpha})`;
   ctx.beginPath();
-  ctx.moveTo(hx - r * 1.9, hy + r * 4);
-  ctx.quadraticCurveTo(hx - r * 1.95, hy + r * 1.2, hx - r * 0.5, hy + r * 0.9);
-  ctx.quadraticCurveTo(hx, hy + r * 0.4, hx + r * 0.5, hy + r * 0.9);
-  ctx.quadraticCurveTo(hx + r * 1.95, hy + r * 1.2, hx + r * 1.9, hy + r * 4);
+  ctx.moveTo(hx - r * 1.72, hy + r * 4);
+  ctx.quadraticCurveTo(hx - r * 1.78, hy + r * 1.55, hx - r * 0.46, hy + r * 1.02);
+  ctx.lineTo(hx - r * 0.4, hy + r * 0.62);
+  ctx.lineTo(hx + r * 0.4, hy + r * 0.62);
+  ctx.lineTo(hx + r * 0.46, hy + r * 1.02);
+  ctx.quadraticCurveTo(hx + r * 1.78, hy + r * 1.55, hx + r * 1.72, hy + r * 4);
   ctx.closePath();
   ctx.fill();
   ctx.fillStyle = `rgba(${tone[0]},${tone[1]},${tone[2]},${alpha})`;
   ctx.beginPath();
-  ctx.ellipse(hx, hy, r * 0.92, r * 1.05, 0, 0, TAU2);
+  ctx.ellipse(hx, hy, r * 0.9, r * 1.05, 0, 0, TAU2);
   ctx.fill();
 }
 function drawPerformer(ctx, x, footY, h, o) {
@@ -9421,15 +9789,29 @@ function drawArenaScene(ctx, distM, eyeM, scene, nearGlow, rigTintStr, rand) {
   riser.addColorStop(1, "rgba(0,0,0,0)");
   ctx.fillStyle = riser;
   ctx.fillRect(cx - halfW, topCy, halfW * 2, yBase - topCy);
+  const FORMATIONS = [
+    // frontman + guitarist + one at the back
+    [{ u: -0.24, v: 0.4, lead: true, pose: 3 }, { u: 0.34, v: -0.04, pose: 2 }, { u: -0.52, v: -0.38, pose: 0 }],
+    // duo — singer forward, instrument behind the shoulder
+    [{ u: 0.2, v: 0.34, lead: true, pose: 3 }, { u: -0.3, v: -0.08, pose: 2 }],
+    // 4-piece — lead just off-centre, band staggered around the far half
+    [{ u: -0.1, v: 0.28, lead: true, pose: 1 }, { u: 0.44, v: -0.2, pose: 2 }, { u: -0.46, v: -0.14, pose: 2 }, { u: 0.08, v: -0.46, pose: 0 }]
+  ];
+  const form = FORMATIONS[Math.floor(rand() * FORMATIONS.length)];
+  const mirror = rand() < 0.5 ? -1 : 1;
+  const spotX = (p) => cx + p.u * mirror * halfW * 0.84;
+  const spotY = (p) => topCy + p.v * topRy * 0.8;
+  const lead = form.find((p) => p.lead) ?? form[0];
+  const leadX = spotX(lead);
   const deckTop = ctx.createLinearGradient(0, topCy - topRy, 0, topCy + topRy);
-  deckTop.addColorStop(0, "#2b3350");
-  deckTop.addColorStop(1, "#161b2c");
+  deckTop.addColorStop(0, "#3d4a72");
+  deckTop.addColorStop(1, "#232b47");
   ctx.fillStyle = deckTop;
   ctx.beginPath();
   ctx.ellipse(cx, topCy, halfW, topRy, 0, 0, TAU2);
   ctx.fill();
-  const deckGlow = ctx.createRadialGradient(cx, topCy, 2, cx, topCy, halfW);
-  deckGlow.addColorStop(0, `rgba(255,214,160,${(0.28 * nearGlow).toFixed(3)})`);
+  const deckGlow = ctx.createRadialGradient(leadX, topCy, 2, leadX, topCy, halfW);
+  deckGlow.addColorStop(0, `rgba(255,214,160,${(0.5 * nearGlow).toFixed(3)})`);
   deckGlow.addColorStop(1, "rgba(255,214,160,0)");
   ctx.save();
   ctx.globalCompositeOperation = "lighter";
@@ -9443,18 +9825,37 @@ function drawArenaScene(ctx, distM, eyeM, scene, nearGlow, rigTintStr, rand) {
   ctx.beginPath();
   ctx.ellipse(cx, topCy, halfW, topRy, 0, 0, TAU2);
   ctx.stroke();
-  const perfCount = 2 + Math.floor(rand() * 3);
   const perfH = Math.max(24, (yBase - yFarTop) * 1.3);
-  for (let i = 0; i < perfCount; i++) {
-    const t2 = perfCount === 1 ? 0.5 : i / (perfCount - 1);
-    const px = cx + (t2 - 0.5) * 2 * halfW * 0.66;
-    const footY = topCy + topRy * 0.5 * Math.cos((t2 - 0.5) * Math.PI) - topRy * 0.1;
-    drawPerformer(ctx, px, footY, perfH * (0.85 + rand() * 0.3), {
-      tone: [10, 12, 20],
-      alpha: 0.92,
-      pose: Math.floor(rand() * 4),
-      rim: hslToRgb(40, 0.6, 0.72),
-      rimStrength: 0.8
+  const gearN = form.length >= 3 ? 3 : 2;
+  for (let i = 0; i < gearN; i++) {
+    const gu = (-0.62 + i * 0.52 + (rand() - 0.5) * 0.12) * -mirror;
+    const gx = cx + gu * halfW * 0.7;
+    const gy = topCy - topRy * (0.45 + rand() * 0.18);
+    const gw = halfW * (0.07 + rand() * 0.04);
+    const gh = perfH * (0.26 + rand() * 0.12);
+    ctx.fillStyle = "#0a0e18";
+    ctx.fillRect(gx - gw / 2, gy - gh, gw, gh);
+    ctx.fillStyle = `rgba(${rigTintStr},0.3)`;
+    ctx.fillRect(gx - gw / 2, gy - gh, gw, 1.5);
+  }
+  if (form.length >= 3) {
+    const drumX = cx - lead.u * mirror * halfW * 0.4;
+    ctx.fillStyle = "#0b0f1a";
+    ctx.beginPath();
+    ctx.ellipse(drumX, topCy - topRy * 0.34, halfW * 0.08, topRy * 0.1, 0, 0, TAU2);
+    ctx.fill();
+    ctx.strokeStyle = `rgba(${rigTintStr},0.35)`;
+    ctx.lineWidth = 1;
+    ctx.stroke();
+  }
+  for (const p of [...form].sort((a, b) => a.v - b.v)) {
+    const depthScale = 0.82 + (p.v + 1) * 0.14;
+    drawPerformer(ctx, spotX(p), spotY(p), perfH * depthScale * (p.lead ? 1.06 : 0.92), {
+      tone: [18, 21, 34],
+      alpha: 0.95,
+      pose: p.pose,
+      rim: hslToRgb(40, 0.72, 0.8),
+      rimStrength: p.lead ? 1.4 : 0.9
     });
   }
   const trussY = pitchToY(Math.min(60, farTopPitch + 34));
@@ -9471,10 +9872,55 @@ function drawArenaScene(ctx, distM, eyeM, scene, nearGlow, rigTintStr, rand) {
     const fxY = trussY + Math.sin(a) * trussRy;
     if (Math.sin(a) > -0.2) {
       const tx = cx + (rand() - 0.5) * halfW * 0.8;
-      drawBeam(ctx, fxX, fxY, tx, topCy, 3, halfW * 0.32, rigTintStr, 0.14 * (0.7 + nearGlow * 0.4));
+      drawBeam(ctx, fxX, fxY, tx, topCy, 3, halfW * 0.32, rigTintStr, 0.2 * (0.7 + nearGlow * 0.4));
     }
-    drawFixture(ctx, fxX, fxY, 2.2, rigTintStr);
+    drawFixture(ctx, fxX, fxY, 3, rigTintStr);
   }
+  const scoreY = pitchToY(Math.min(52, farTopPitch + 24));
+  const scoreW = Math.max(60, halfW * 0.4);
+  const scoreH = Math.max(24, scoreW * 0.34);
+  ctx.strokeStyle = "rgba(70,78,102,0.6)";
+  ctx.lineWidth = 1.5;
+  ctx.beginPath();
+  ctx.moveTo(cx - scoreW * 0.3, scoreY - scoreH / 2);
+  ctx.lineTo(cx - scoreW * 0.16, scoreY - scoreH * 2.2);
+  ctx.moveTo(cx + scoreW * 0.3, scoreY - scoreH / 2);
+  ctx.lineTo(cx + scoreW * 0.16, scoreY - scoreH * 2.2);
+  ctx.stroke();
+  ctx.fillStyle = "#0d1220";
+  ctx.fillRect(cx - scoreW / 2, scoreY - scoreH / 2, scoreW, scoreH);
+  const screen = ctx.createLinearGradient(0, scoreY - scoreH * 0.3, 0, scoreY + scoreH * 0.42);
+  screen.addColorStop(0, `rgba(${rigTintStr},0.5)`);
+  screen.addColorStop(1, "rgba(255,214,160,0.32)");
+  ctx.fillStyle = screen;
+  ctx.fillRect(cx - scoreW * 0.42, scoreY - scoreH * 0.3, scoreW * 0.84, scoreH * 0.72);
+  ctx.fillStyle = "rgba(255,214,160,0.55)";
+  ctx.fillRect(cx - scoreW / 2, scoreY + scoreH / 2 - 2, scoreW, 2);
+  const scoreGlow = ctx.createRadialGradient(cx, scoreY, 4, cx, scoreY, scoreW * 1.1);
+  scoreGlow.addColorStop(0, `rgba(${rigTintStr},0.2)`);
+  scoreGlow.addColorStop(1, "rgba(0,0,0,0)");
+  ctx.save();
+  ctx.globalCompositeOperation = "lighter";
+  ctx.fillStyle = scoreGlow;
+  ctx.fillRect(cx - scoreW * 1.1, scoreY - scoreW * 0.8, scoreW * 2.2, scoreW * 1.6);
+  const airGlow = ctx.createRadialGradient(cx, (trussY + topCy) / 2, 6, cx, (trussY + topCy) / 2, halfW * 1.5);
+  airGlow.addColorStop(0, `rgba(${rigTintStr},${(0.1 * (0.6 + nearGlow * 0.5)).toFixed(3)})`);
+  airGlow.addColorStop(1, "rgba(0,0,0,0)");
+  ctx.fillStyle = airGlow;
+  ctx.fillRect(cx - halfW * 1.5, trussY - 40, halfW * 3, topCy - trussY + 80);
+  ctx.restore();
+  const keyX = cx + Math.sign(leadX - cx || 1) * halfW * 0.5;
+  drawBeam(ctx, keyX, trussY - trussRy * 0.4, leadX, spotY(lead), 2.5, halfW * 0.16, "255,224,178", 0.42 * (0.7 + nearGlow * 0.4));
+  const pool2 = ctx.createRadialGradient(leadX, spotY(lead), 1, leadX, spotY(lead), halfW * 0.2);
+  pool2.addColorStop(0, `rgba(255,228,185,${(0.4 * nearGlow).toFixed(3)})`);
+  pool2.addColorStop(1, "rgba(255,228,185,0)");
+  ctx.save();
+  ctx.globalCompositeOperation = "lighter";
+  ctx.fillStyle = pool2;
+  ctx.beginPath();
+  ctx.ellipse(leadX, spotY(lead), halfW * 0.2, topRy * 0.24, 0, 0, TAU2);
+  ctx.fill();
+  ctx.restore();
 }
 function drawSportScene(ctx, distM, eyeM, scene, _nearGlow, baseHue, rigTintStr, rand) {
   const cx = W / 2;
@@ -9582,7 +10028,7 @@ function drawAudience(ctx, seat, neighborSeats, _focalPoint, stageBearing, eyeM,
     const oy = other.y - seat.y;
     const d = Math.hypot(ox, oy) * UNIT;
     if (own && other.sectionId === own && d < 3 && ox * dx + oy * dy > 0) seatAhead = true;
-    if (d < 0.3 || d > 17) continue;
+    if (d < 0.3 || d > 32) continue;
     const bearing = Math.atan2(ox, -oy) - stageBearing;
     const yaw = (bearing * 180 / Math.PI + 540) % 360 - 180;
     const rise = hasRelief ? (other.eyeHeightM ?? SEATED_EYE_HEIGHT_M) - eyeM : 0;
@@ -9592,40 +10038,91 @@ function drawAudience(ctx, seat, neighborSeats, _focalPoint, stageBearing, eyeM,
     for (let k = 0; k < other.id.length; k++) hh = hh * 31 + other.id.charCodeAt(k) & 65535;
     const jitter = 0.9 + (hh & 15) / 40;
     const r = Math.min(78, Math.atan2(0.16, d) * 180 / Math.PI * PX_PER_DEG * jitter);
-    if (r < 2) continue;
+    if (r < 1.2) continue;
     figs.push({ hx: yawToX(yaw), hy: pitchToY(headPitch), r, d, hash: hh });
   }
   figs.sort((a, b) => b.d - a.d);
+  const figRows = [];
+  {
+    const byY = [...figs].sort((a, b) => a.hy - b.hy);
+    let cur = [];
+    const flush = () => {
+      if (!cur.length) return;
+      const d = cur.reduce((s, f) => s + f.d, 0) / cur.length;
+      const hy = cur.reduce((s, f) => s + f.hy, 0) / cur.length;
+      const r = cur.reduce((s, f) => s + f.r, 0) / cur.length;
+      figRows.push({ figs: cur.sort((a, b) => b.d - a.d), d, hy, r });
+      cur = [];
+    };
+    for (const f of byY) {
+      const last = cur[cur.length - 1];
+      if (last && Math.abs(f.hy - last.hy) > Math.max(5, (last.r + f.r) / 2 * 1.7)) flush();
+      cur.push(f);
+    }
+    flush();
+  }
+  figRows.sort((a, b) => b.d - a.d);
   const CLOTHES = [[22, 26, 40], [28, 27, 42], [24, 31, 46], [31, 30, 47], [20, 24, 36]];
-  for (const f of figs) {
-    const alpha = f.d < 12 ? 0.95 : Math.max(0.66, 0.95 - (f.d - 12) / 18);
-    const lift = Math.round((1 - Math.min(1, f.d / 16)) * 10);
-    const headTone = [14 + (f.hash >> 4 & 6) + lift, 17 + (f.hash >> 4 & 6) + lift, 25 + (f.hash >> 4 & 6) + lift];
-    const clo0 = CLOTHES[f.hash % CLOTHES.length];
-    const clothing = [clo0[0] + lift, clo0[1] + lift, clo0[2] + lift];
-    if (f.r >= 13) {
-      const rim = f.d < 9 ? 0.16 * (1 - f.d / 9) + (scene.mode === "proscenium" ? 0.06 : 0) : 0;
-      drawSeated(ctx, f.hx, f.hy, f.r, {
-        tone: headTone,
-        clothing,
-        alpha,
-        tilt: ((f.hash >> 2 & 7) - 3.5) * 0.018,
-        // ±~7°
-        shoulderK: 1.72 + (f.hash >> 5 & 7) / 22,
-        // ~1.72..2.04
-        hair: f.hash % HAIR_KINDS,
-        rim
-      });
-    } else if (f.r >= 5.5) {
-      drawSeatedMid(ctx, f.hx, f.hy, f.r, clothing, headTone, alpha);
-    } else {
-      ctx.fillStyle = `rgba(${headTone[0]},${headTone[1]},${headTone[2]},${alpha.toFixed(3)})`;
-      ctx.beginPath();
-      ctx.arc(f.hx, f.hy, f.r, 0, TAU2);
-      ctx.fill();
-      ctx.beginPath();
-      ctx.ellipse(f.hx, f.hy + f.r * 1.4, f.r * 1.85, f.r * 0.95, 0, Math.PI, 0, true);
-      ctx.fill();
+  for (const row of figRows) {
+    if (row.figs.length >= 3 && row.r >= 1.6 && row.r < 26) {
+      const runs = [];
+      const byX = [...row.figs].sort((a, b) => a.hx - b.hx);
+      let run = [];
+      for (const f of byX) {
+        const last = run[run.length - 1];
+        if (last && f.hx - last.hx > Math.max(14, f.r * 7)) {
+          if (run.length >= 3) runs.push(run);
+          run = [];
+        }
+        run.push(f);
+      }
+      if (run.length >= 3) runs.push(run);
+      const stripAlpha = Math.min(0.42, 0.5 * (1 - row.d / 42));
+      if (stripAlpha > 0.05) {
+        ctx.fillStyle = `rgba(15, 19, 31, ${stripAlpha.toFixed(3)})`;
+        for (const seg of runs) {
+          const x0 = seg[0].hx - row.r * 1.6;
+          const x1 = seg[seg.length - 1].hx + row.r * 1.6;
+          ctx.beginPath();
+          ctx.roundRect(x0, row.hy + row.r * 0.8, x1 - x0, row.r * 2.4, row.r * 0.8);
+          ctx.fill();
+        }
+      }
+    }
+    for (const f of row.figs) {
+      const alpha = f.d < 12 ? 0.95 : f.d < 17 ? Math.max(0.66, 0.95 - (f.d - 12) / 18) : Math.max(0.3, 0.68 - (f.d - 17) / 34);
+      const lift = Math.round((1 - Math.min(1, f.d / 16)) * 10);
+      const headTone = [14 + (f.hash >> 4 & 6) + lift, 17 + (f.hash >> 4 & 6) + lift, 25 + (f.hash >> 4 & 6) + lift];
+      const clo0 = CLOTHES[f.hash % CLOTHES.length];
+      const clothing = [clo0[0] + lift, clo0[1] + lift, clo0[2] + lift];
+      if (f.r >= 13) {
+        const rim = f.d < 9 ? 0.16 * (1 - f.d / 9) + (scene.mode === "proscenium" ? 0.06 : 0) : 0;
+        drawSeated(ctx, f.hx, f.hy, f.r, {
+          tone: headTone,
+          clothing,
+          alpha,
+          tilt: ((f.hash >> 2 & 7) - 3.5) * 0.018,
+          // ±~7°
+          shoulderK: 1.72 + (f.hash >> 5 & 7) / 22,
+          // ~1.72..2.04
+          hair: f.hash % HAIR_KINDS,
+          rim,
+          turn: ((f.hash >> 8 & 7) - 3.5) * 0.034,
+          // ±~0.12 head-radii sideways
+          lean: ((f.hash >> 10 & 3) - 1.5) * 0.09
+          // one shoulder rides higher
+        });
+      } else if (f.r >= 5.5) {
+        drawSeatedMid(ctx, f.hx, f.hy, f.r, clothing, headTone, alpha);
+      } else {
+        ctx.fillStyle = `rgba(${headTone[0]},${headTone[1]},${headTone[2]},${alpha.toFixed(3)})`;
+        ctx.beginPath();
+        ctx.arc(f.hx, f.hy, f.r, 0, TAU2);
+        ctx.fill();
+        ctx.beginPath();
+        ctx.ellipse(f.hx, f.hy + f.r * 1.4, f.r * 1.85, f.r * 0.95, 0, Math.PI, 0, true);
+        ctx.fill();
+      }
     }
   }
   if (seatAhead) {