@seatlayer/core 0.30.1 → 0.31.0

package/dist/view3d/index.js

@@ -448,12 +448,42 @@ function isDegenerate(p0, p1, p2) {
   const area = Math.sqrt(Math.max(0, s * (s - e0) * (s - e1) * (s - e2)));
   return 2 * area / longest < MIN_TRI_ALTITUDE_M;
 }
+var F32Buffer = class {
+  constructor(initial = 1 << 14) {
+    this.len = 0;
+    this.buf = new Float32Array(initial);
+  }
+  push3(a, b, c) {
+    if (this.len + 3 > this.buf.length) this.grow(this.len + 3);
+    this.buf[this.len++] = a;
+    this.buf[this.len++] = b;
+    this.buf[this.len++] = c;
+  }
+  push1(a) {
+    if (this.len + 1 > this.buf.length) this.grow(this.len + 1);
+    this.buf[this.len++] = a;
+  }
+  grow(need) {
+    let cap = this.buf.length * 2;
+    while (cap < need) cap *= 2;
+    const next = new Float32Array(cap);
+    next.set(this.buf.subarray(0, this.len));
+    this.buf = next;
+  }
+  get length() {
+    return this.len;
+  }
+  /** A copy trimmed to the used length. */
+  toArray() {
+    return this.buf.slice(0, this.len);
+  }
+};
 var MeshBuilder = class {
   constructor() {
-    this.pos = [];
-    this.nor = [];
-    this.col = [];
-    this.flr = [];
+    this.pos = new F32Buffer();
+    this.nor = new F32Buffer();
+    this.col = new F32Buffer();
+    this.flr = new F32Buffer();
     /** Floor index stamped onto every triangle emitted from now on. */
     this.currentFloor = 0;
   }
@@ -464,28 +494,44 @@ var MeshBuilder = class {
   /** One triangle with a shared (flat) normal and per-vertex colours. */
   tri(p0, p1, p2, n, c0, c1 = c0, c2 = c0) {
     if (isDegenerate(p0, p1, p2)) return;
-    this.pos.push(p0[0], p0[1], p0[2], p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]);
-    this.nor.push(n[0], n[1], n[2], n[0], n[1], n[2], n[0], n[1], n[2]);
-    this.col.push(c0[0], c0[1], c0[2], c1[0], c1[1], c1[2], c2[0], c2[1], c2[2]);
-    this.flr.push(this.currentFloor, this.currentFloor, this.currentFloor);
+    this.pos.push3(p0[0], p0[1], p0[2]);
+    this.pos.push3(p1[0], p1[1], p1[2]);
+    this.pos.push3(p2[0], p2[1], p2[2]);
+    this.nor.push3(n[0], n[1], n[2]);
+    this.nor.push3(n[0], n[1], n[2]);
+    this.nor.push3(n[0], n[1], n[2]);
+    this.col.push3(c0[0], c0[1], c0[2]);
+    this.col.push3(c1[0], c1[1], c1[2]);
+    this.col.push3(c2[0], c2[1], c2[2]);
+    this.flr.push1(this.currentFloor);
+    this.flr.push1(this.currentFloor);
+    this.flr.push1(this.currentFloor);
   }
   /** One triangle with independent per-vertex normals (smooth shading). */
   triN(p0, p1, p2, n0, n1, n2, c0, c1 = c0, c2 = c0) {
     if (isDegenerate(p0, p1, p2)) return;
-    this.pos.push(p0[0], p0[1], p0[2], p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]);
-    this.nor.push(n0[0], n0[1], n0[2], n1[0], n1[1], n1[2], n2[0], n2[1], n2[2]);
-    this.col.push(c0[0], c0[1], c0[2], c1[0], c1[1], c1[2], c2[0], c2[1], c2[2]);
-    this.flr.push(this.currentFloor, this.currentFloor, this.currentFloor);
+    this.pos.push3(p0[0], p0[1], p0[2]);
+    this.pos.push3(p1[0], p1[1], p1[2]);
+    this.pos.push3(p2[0], p2[1], p2[2]);
+    this.nor.push3(n0[0], n0[1], n0[2]);
+    this.nor.push3(n1[0], n1[1], n1[2]);
+    this.nor.push3(n2[0], n2[1], n2[2]);
+    this.col.push3(c0[0], c0[1], c0[2]);
+    this.col.push3(c1[0], c1[1], c1[2]);
+    this.col.push3(c2[0], c2[1], c2[2]);
+    this.flr.push1(this.currentFloor);
+    this.flr.push1(this.currentFloor);
+    this.flr.push1(this.currentFloor);
   }
   get vertexCount() {
     return this.pos.length / 3;
   }
   build() {
     return {
-      position: new Float32Array(this.pos),
-      normal: new Float32Array(this.nor),
-      color: new Float32Array(this.col),
-      floor: new Float32Array(this.flr),
+      position: this.pos.toArray(),
+      normal: this.nor.toArray(),
+      color: this.col.toArray(),
+      floor: this.flr.toArray(),
       count: this.pos.length / 3
     };
   }
@@ -993,16 +1039,23 @@ function themeSeatColorLUT(theme, order) {
 var ZONE_MIN_DISTANCE = 1.15;
 var SECTION_MAX_DISTANCE = 2.2;
 var NEAR_MAX_DISTANCE = 0.85;
+var ROW_MAX_DISTANCE = 0.5;
+var SEAT_MAX_DISTANCE = 0.26;
 function visibleLabelKinds(distance, venueRadius) {
   const r = Math.max(1e-6, venueRadius);
   const d = distance / r;
   const out = /* @__PURE__ */ new Set();
   if (d >= ZONE_MIN_DISTANCE) out.add("zone");
-  if (d <= SECTION_MAX_DISTANCE) out.add("section");
+  if (d <= SECTION_MAX_DISTANCE) {
+    out.add("section");
+    out.add("ga");
+  }
   if (d <= NEAR_MAX_DISTANCE) {
     out.add("annotation");
     out.add("booth");
   }
+  if (d <= ROW_MAX_DISTANCE) out.add("row");
+  if (d <= SEAT_MAX_DISTANCE) out.add("seat");
   return out;
 }
 function projectToScreen(viewProjection, p, width, height) {
@@ -1270,23 +1323,27 @@ function buildVenueSurfaces(units, seats) {
     const inferredFlat = geo.rake <= 0.01 && geo.height <= bottomY + 1e-3;
     const kind = a.section.surfaceKind;
     const flat = kind === "flat" ? true : kind === "rakedRows" ? geo.rake > 0.01 ? false : inferredFlat : inferredFlat;
-    const rake = buildSectionRake([...a.rows.values()].map((points) => ({ points })), a.unit.focal);
+    const structure = a.hasSeats ? resolveSection(id, seats, a.seatIndices, a.unit.focal) : { sectionId: id, rows: [], blockCount: 0 };
+    const needsRake = structure.rows.length < 2;
+    const rake = needsRake ? buildSectionRake([...a.rows.values()].map((points) => ({ points })), a.unit.focal) : null;
     let frontU = Infinity;
-    if (a.hasSeats) {
-      for (const pts of a.rows.values()) {
-        for (const p of pts) {
+    if (rake) {
+      if (a.hasSeats) {
+        for (const pts of a.rows.values()) {
+          for (const p of pts) {
+            const d = rake.depthAt(p.x, p.y);
+            if (d < frontU) frontU = d;
+          }
+        }
+      }
+      if (!a.hasSeats || !Number.isFinite(frontU)) {
+        frontU = Infinity;
+        for (const p of a.section.outline) {
           const d = rake.depthAt(p.x, p.y);
           if (d < frontU) frontU = d;
         }
       }
     }
-    if (!a.hasSeats || !Number.isFinite(frontU)) {
-      frontU = Infinity;
-      for (const p of a.section.outline) {
-        const d = rake.depthAt(p.x, p.y);
-        if (d < frontU) frontU = d;
-      }
-    }
     const flatTop = bottomY + FLAT_SLAB_TOP_M;
     const baseFloor = bottomY + FLAT_SLAB_TOP_M;
     const levelFor = (depthU) => {
@@ -1299,7 +1356,6 @@ function buildVenueSurfaces(units, seats) {
       const rise = Math.min(depthM * rakeTan, MAX_TIER_RISE_M);
       return Math.max(baseFloor, geo.height + rise);
     };
-    const structure = a.hasSeats ? resolveSection(id, seats, a.seatIndices, a.unit.focal) : { sectionId: id, rows: [], blockCount: 0 };
     const rowLevels = flat ? [] : structure.rows.map((r) => ({
       pts: r.pts,
       y: levelForBlockDepth(r.blockDepth),
@@ -1335,9 +1391,10 @@ function buildVenueSurfaces(units, seats) {
         }
       }
       return bestY;
-    } : (x, y) => levelFor(rake.depthAt(x, y));
+    } : (x, y) => rake ? levelFor(rake.depthAt(x, y)) : flatTop;
     const UP = [0, 1, 0];
     const normalAt = rowLevels.length >= 2 || flat ? () => UP : (x, y) => {
+      if (!rake) return UP;
       const d = rake.depthAt(x, y);
       if (d <= frontU) return UP;
       const depthM = (d - frontU) * METRES_PER_CHART_UNIT;
@@ -1460,7 +1517,23 @@ function distToPolyline(pts, x, y) {
   }
   return best;
 }
-function neighbourhoods(rows) {
+function rowNeighbourhoods(rows) {
+  const bounds = rows.map((r) => {
+    let cx = 0, cy = 0;
+    for (const p of r.pts) {
+      cx += p.x;
+      cy += p.y;
+    }
+    const n = r.pts.length || 1;
+    cx /= n;
+    cy /= n;
+    let rad = 0;
+    for (const p of r.pts) {
+      const d = Math.hypot(p.x - cx, p.y - cy);
+      if (d > rad) rad = d;
+    }
+    return { cx, cy, rad };
+  });
   const probesOf = (pts) => {
     const n = pts.length;
     if (n <= 2) return [...pts];
@@ -1475,6 +1548,9 @@ function neighbourhoods(rows) {
       let nearest = Infinity;
       for (let j = 0; j < rows.length; j++) {
         if (j === i || Math.abs(rows[j].y - rows[i].y) < 1e-3) continue;
+        const b = bounds[j];
+        const lower = Math.hypot(c.x - b.cx, c.y - b.cy) - b.rad;
+        if (lower >= nearest && lower >= bestFrontD) continue;
         const d = distToPolyline(rows[j].pts, c.x, c.y);
         if (d < nearest) nearest = d;
         if (rows[j].depth < rows[i].depth && d < bestFrontD) {
@@ -1519,65 +1595,8 @@ function ribbonOf(rows, i, nbrs, focal) {
     back: Math.max(nbrs[i].pitch * BACK_REACH, MIN_REACH_U)
   };
 }
-function deckFootprints(rows, focal) {
-  if (rows.length < 2) return [];
-  const nbrs = neighbourhoods(rows);
-  const rings = [];
-  const ribbons = [];
-  for (let i = 0; i < rows.length; i++) {
-    const r = ribbonOf(rows, i, nbrs, focal);
-    ribbons.push(r);
-    if (!r) continue;
-    const f = [];
-    const b = [];
-    const rf = r.front + FOOTPRINT_MARGIN_U;
-    const rb = r.back + FOOTPRINT_MARGIN_U;
-    for (let k = 0; k < r.pts.length; k++) {
-      const p = r.pts[k], n = r.nrm[k];
-      f.push([p.x - n[0] * rf, p.y - n[1] * rf]);
-      b.push([p.x + n[0] * rb, p.y + n[1] * rb]);
-    }
-    const ring = [...f, ...b.reverse()];
-    if (ring.length < 3) continue;
-    ring.push(ring[0]);
-    rings.push([ring]);
-  }
-  if (!rings.length) return [];
-  let merged;
-  try {
-    merged = polygonClipping2.union(rings[0], ...rings.slice(1));
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const poly of merged) {
-    if (!poly.length || poly[0].length < 4) continue;
-    const toPts = (ring) => {
-      const pts = ring.map(([x, y]) => ({ x, y }));
-      const first = pts[0], last = pts[pts.length - 1];
-      if (pts.length > 1 && Math.abs(first.x - last.x) < 1e-9 && Math.abs(first.y - last.y) < 1e-9) pts.pop();
-      return pts;
-    };
-    const outline = toPts(poly[0]);
-    if (outline.length < 3) continue;
-    let topY = Infinity;
-    for (let i = 0; i < rows.length; i++) {
-      const r = ribbons[i];
-      if (!r) continue;
-      const mid = r.pts[Math.floor(r.pts.length / 2)];
-      if (pointInRing(outline, mid.x, mid.y) && rows[i].y < topY) topY = rows[i].y;
-    }
-    if (!Number.isFinite(topY)) continue;
-    out.push({
-      outline: simplifyRing(outline, FOOTPRINT_TOLERANCE_U),
-      holes: poly.slice(1).map(toPts).map((h) => simplifyRing(h, FOOTPRINT_TOLERANCE_U)).filter((h) => h.length >= 3),
-      topY
-    });
-  }
-  return out;
-}
-var FOOTPRINT_TOLERANCE_U = 0.3;
 var FOOTPRINT_MARGIN_U = 1.5;
+var FOOTPRINT_TOLERANCE_U = 0.3;
 function simplifyRun(pts, tol) {
   if (pts.length < 3) return pts;
   const a = pts[0], b = pts[pts.length - 1];
@@ -1603,6 +1622,102 @@ function simplifyRing(ring, tol) {
   out.pop();
   return out.length >= 3 ? out : ring;
 }
+function deckFootprints(rows, focal, shared) {
+  if (rows.length < 2) return [];
+  const nbrs = shared ?? rowNeighbourhoods(rows);
+  const byBlock = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rows.length; i++) {
+    const a = byBlock.get(rows[i].blockId);
+    if (a) a.push(i);
+    else byBlock.set(rows[i].blockId, [i]);
+  }
+  const out = [];
+  for (const [, indices] of byBlock) {
+    indices.sort((a, b) => rows[a].depth - rows[b].depth);
+    const ribbons = indices.map((i) => ribbonOf(rows, i, nbrs, focal));
+    const usable = ribbons.filter((r) => r !== null);
+    if (!usable.length) continue;
+    const frontOf = (r, k) => ({
+      x: r.pts[k].x - r.nrm[k][0] * (r.front + FOOTPRINT_MARGIN_U),
+      y: r.pts[k].y - r.nrm[k][1] * (r.front + FOOTPRINT_MARGIN_U)
+    });
+    const backOf = (r, k) => ({
+      x: r.pts[k].x + r.nrm[k][0] * (r.back + FOOTPRINT_MARGIN_U),
+      y: r.pts[k].y + r.nrm[k][1] * (r.back + FOOTPRINT_MARGIN_U)
+    });
+    const first = usable[0], last = usable[usable.length - 1];
+    const ring = [];
+    for (let k = 0; k < first.pts.length; k++) ring.push(frontOf(first, k));
+    for (const r of usable) ring.push(backOf(r, r.pts.length - 1));
+    for (let k = last.pts.length - 1; k >= 0; k--) ring.push(backOf(last, k));
+    for (let i = usable.length - 1; i >= 0; i--) ring.push(frontOf(usable[i], 0));
+    const deduped = dedupeAdjacent(ring);
+    let topY = Infinity;
+    for (const i of indices) if (rows[i].y < topY) topY = rows[i].y;
+    if (!Number.isFinite(topY)) continue;
+    const covers = deduped.length >= 3 && Math.abs(ringArea(deduped)) > 1e-6 && usable.every((r) => {
+      const mid = r.pts[Math.floor(r.pts.length / 2)];
+      return pointInRing(deduped, mid.x, mid.y);
+    });
+    if (covers) {
+      out.push({ outline: simplifyRing(deduped, FOOTPRINT_TOLERANCE_U), holes: [], topY });
+      continue;
+    }
+    for (const poly of unionRibbons(usable)) out.push({ outline: poly, holes: [], topY });
+  }
+  return out;
+}
+function unionRibbons(ribbons) {
+  const rings = [];
+  for (const r of ribbons) {
+    const f = [];
+    const b = [];
+    const rf = r.front + FOOTPRINT_MARGIN_U;
+    const rb = r.back + FOOTPRINT_MARGIN_U;
+    for (let k = 0; k < r.pts.length; k++) {
+      const p = r.pts[k], n = r.nrm[k];
+      f.push([p.x - n[0] * rf, p.y - n[1] * rf]);
+      b.push([p.x + n[0] * rb, p.y + n[1] * rb]);
+    }
+    const ring = [...f, ...b.reverse()];
+    if (ring.length < 3) continue;
+    ring.push(ring[0]);
+    rings.push([ring]);
+  }
+  if (!rings.length) return [];
+  try {
+    const merged = polygonClipping2.union(rings[0], ...rings.slice(1));
+    const out = [];
+    for (const poly of merged) {
+      if (!poly.length || poly[0].length < 4) continue;
+      const pts = poly[0].map(([x, y]) => ({ x, y }));
+      const first = pts[0], last = pts[pts.length - 1];
+      if (pts.length > 1 && Math.abs(first.x - last.x) < 1e-9 && Math.abs(first.y - last.y) < 1e-9) pts.pop();
+      if (pts.length >= 3) out.push(simplifyRing(pts, FOOTPRINT_TOLERANCE_U));
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function ringArea(ring) {
+  let a = 0;
+  for (let i = 0, n = ring.length; i < n; i++) {
+    const p = ring[i], q = ring[(i + 1) % n];
+    a += p.x * q.y - q.x * p.y;
+  }
+  return a / 2;
+}
+function dedupeAdjacent(ring) {
+  const out = [];
+  for (const p of ring) {
+    const last = out[out.length - 1];
+    if (last && Math.hypot(p.x - last.x, p.y - last.y) < 1e-9) continue;
+    out.push(p);
+  }
+  while (out.length > 2 && Math.hypot(out[0].x - out[out.length - 1].x, out[0].y - out[out.length - 1].y) < 1e-9) out.pop();
+  return out;
+}
 function pointInRing(ring, x, y) {
   let inside = false;
   for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
@@ -1685,9 +1800,9 @@ function emitClippedQuad(builder, clipRing, clipTest, quad, y, color) {
     }
   }
 }
-function emitDeckBands(builder, rows, focal, landingY, colors, clip) {
+function emitDeckBands(builder, rows, focal, landingY, colors, clip, shared) {
   if (rows.length < 2) return;
-  const nbrs = neighbourhoods(rows);
+  const nbrs = shared ?? rowNeighbourhoods(rows);
   const UP = [0, 1, 0];
   const clipRing = clip && clip.length >= 3 ? [[...clip.map((p) => [p.x, p.y]), [clip[0].x, clip[0].y]]] : null;
   const clipTest = clip && clip.length >= 3 ? new ClipTest([[...clip]]) : null;
@@ -1790,9 +1905,7 @@ function boxesOverlap(a, b) {
   return a.minX <= b.maxX && b.minX <= a.maxX && a.minY <= b.maxY && b.minY <= a.maxY;
 }
 function paddedFootprint(section, siblings) {
-  const __tp = performance.now();
   const padded = outsetRing(section.outline, SEAT_DOT_RADIUS_M * 1.5 * CHART_UNITS_PER_METRE);
-  __t("outsetRing", __tp);
   const box = bboxOfRing(padded);
   const others = siblings.filter((o) => o !== section && o.outline && o.outline.length >= 3 && boxesOverlap(box, bboxOfRing(o.outline)));
   if (!others.length) return [padded];
@@ -1856,9 +1969,8 @@ function buildTier(builder, section, unit, fill, surface, claimed, siblings, S)
   const footprint = paddedFootprint(section, siblings);
   const outline = footprint[0] ?? section.outline;
   if (surface.rowLevels.length >= 2) {
-    const __tf = performance.now();
-    const blocks = clipFootprints(deckFootprints(surface.rowLevels, unit.focal), footprint);
-    __t("deckFootprints", __tf);
+    const nbrs = rowNeighbourhoods(surface.rowLevels);
+    const blocks = clipFootprints(deckFootprints(surface.rowLevels, unit.focal, nbrs), footprint);
     const capUp = () => [0, 1, 0];
     for (const b of blocks) {
       extrudePrism(
@@ -1886,14 +1998,12 @@ function buildTier(builder, section, unit, fill, surface, claimed, siblings, S)
         AO
       );
     }
-    const __tb = performance.now();
     emitDeckBands(builder, surface.rowLevels, unit.focal, surface.landingY, {
       tread: [colTop[0] * AO.top, colTop[1] * AO.top, colTop[2] * AO.top],
       // Risers read as the structure they are, a shade below their tread, which
       // is what makes the stepping legible from a low angle.
       riser: [colTop[0] * 0.72, colTop[1] * 0.72, colTop[2] * 0.72]
-    }, footprint.length === 1 ? outline : footprint.flat());
-    __t("emitDeckBands", __tb);
+    }, footprint.length === 1 ? outline : footprint.flat(), nbrs);
     return;
   }
   const maxErr = surface.flat ? Infinity : CAP_MAX_ERROR_M;
@@ -1943,7 +2053,12 @@ var ZONE_LABEL_LIFT_M = 6;
 var SECTION_LABEL_LIFT_M = 2.2;
 var ANNOTATION_LIFT_M = 0.1;
 var BOOTH_LABEL_LIFT_M = 0.3;
+var GA_LABEL_LIFT_M = 1.8;
+var ROW_LABEL_LIFT_M = 0.9;
+var SEAT_LABEL_LIFT_M = 0.55;
+var SEAT_LABEL_MAX = 6e3;
 var TABLE_HEIGHT_M = 0.75;
+var DECOR_PLATE_M = 0.15;
 function boothPolygon(booth) {
   if (booth.points && booth.points.length >= 3) return booth.points;
   const { center, width, height, rotation } = booth;
@@ -2017,10 +2132,63 @@ function buildShape(builder, shape, base, S) {
   if (!poly) return;
   const isStage = shape.role === "stage";
   const height = isStage ? base + 1 : base + 0.25;
-  const colTop = isStage ? S.stageTop : S.decorTop;
+  const colTop = tintTop(hexToRgb(shape.fill), isStage ? S.stageTop : S.decorTop);
   const colWall = isStage ? S.stageWall : S.decorWall;
   extrudePrism(builder, poly, void 0, () => height, base, colTop, colWall, AO);
 }
+function decorPolygon(decor) {
+  const { x, y, width, height } = decor;
+  if (!width || !height) return null;
+  const cx = x + width / 2, cy = y + height / 2;
+  const a = (decor.rotation ?? 0) * Math.PI / 180;
+  const cos = Math.cos(a), sin = Math.sin(a);
+  const hw = width / 2, hh = height / 2;
+  return [[-hw, -hh], [hw, -hh], [hw, hh], [-hw, hh]].map(([lx, ly]) => ({
+    x: cx + lx * cos - ly * sin,
+    y: cy + lx * sin + ly * cos
+  }));
+}
+function decorPlatePaint(href) {
+  if (!href || !href.startsWith("data:image/svg+xml")) return null;
+  let svg = href.slice(href.indexOf(",") + 1);
+  if (/;base64/i.test(href.slice(0, href.indexOf(",")))) {
+    try {
+      svg = atob(svg);
+    } catch {
+      return null;
+    }
+  } else {
+    try {
+      svg = decodeURIComponent(svg);
+    } catch {
+    }
+  }
+  const covering = svg.match(/<(?:rect|path)\b[^>]*\bfill="([^"]+)"/i);
+  if (!covering) return null;
+  const paint = covering[1].trim();
+  if (paint === "none" || paint === "transparent") return null;
+  const gradient = paint.match(/^url\(#([^)]+)\)$/);
+  if (!gradient) return hexToRgb(paint);
+  const def = svg.match(new RegExp(`<(?:linear|radial)Gradient\\b[^>]*\\bid="${gradient[1]}"[^>]*>([\\s\\S]*?)</(?:linear|radial)Gradient>`, "i"));
+  if (!def) return null;
+  const stops = [];
+  for (const m of def[1].matchAll(/stop-color="([^"]+)"/gi)) {
+    const c = hexToRgb(m[1].trim());
+    if (c) stops.push(c);
+  }
+  if (!stops.length) return null;
+  return stops.reduce((acc, c, i) => mix(acc, c, 1 / (i + 1)), stops[0]);
+}
+function buildDecorImage(builder, decor, base, S) {
+  if (decor.layer === "foreground") return;
+  const poly = decorPolygon(decor);
+  if (!poly) return;
+  const top = base + DECOR_PLATE_M;
+  let paint = tintTop(decorPlatePaint(decor.href), S.decorTop);
+  const opacity = Math.max(0, Math.min(1, decor.opacity ?? 1));
+  if (opacity < 1) paint = mix(S.ground, paint, opacity);
+  extrudePrism(builder, poly, void 0, () => top, base, paint, mix(paint, S.decorWall, 0.5), AO);
+}
 function buildGa(builder, ga, base, fill, S) {
   if (!ga.points || ga.points.length < 3) return;
   const colTop = tintTop(fill, S.gaTop);
@@ -2046,6 +2214,9 @@ function chartFootprint(units, seats) {
       } else if (o.type === "table") {
         const t = tablePolygon(o);
         if (t) for (const p of t) acc(p.x, p.y);
+      } else if (o.type === "decorImage") {
+        const d = decorPolygon(o);
+        if (d) for (const p of d) acc(p.x, p.y);
       }
     }
   }
@@ -2057,12 +2228,7 @@ function chartFootprint(units, seats) {
   }
   return { minX, minY, maxX, maxY };
 }
-var __PROF = {};
-var __t = (k, t0) => {
-  __PROF[k] = (__PROF[k] ?? 0) + (performance.now() - t0);
-};
 function buildSceneModel(input) {
-  for (const k of Object.keys(__PROF)) delete __PROF[k];
   const { doc, seats } = input;
   const theme = resolveTheme3D(doc.theme);
   const S = theme.structure;
@@ -2075,9 +2241,7 @@ function buildSceneModel(input) {
   const sectionFills = resolveSectionFills(doc, seats);
   const catColor = /* @__PURE__ */ new Map();
   for (const c of doc.categories ?? []) catColor.set(c.key, c.color);
-  const __t0 = performance.now();
   const surfaces = buildVenueSurfaces(units, seats);
-  __t("surfaces", __t0);
   const seatFloor = new Float32Array(seats.length);
   for (let unitIndex = 0; unitIndex < units.length; unitIndex++) {
     const unit = units[unitIndex];
@@ -2085,23 +2249,17 @@ function buildSceneModel(input) {
     const claimed = new ClaimedArea();
     const siblings = unit.objects.filter((o) => o.type === "section" && !!o.outline && o.outline.length >= 3);
     for (const o of unit.objects) {
-      if (o.type === "section") {
-        const t = performance.now();
-        buildTier(builder, o, unit, sectionFill(o, sectionFills), surfaces.bySection.get(o.id), claimed, siblings, S);
-        __t("buildTier", t);
-      } else if (o.type === "shape") buildShape(builder, o, unit.baseHeightM, S);
+      if (o.type === "section") buildTier(builder, o, unit, sectionFill(o, sectionFills), surfaces.bySection.get(o.id), claimed, siblings, S);
+      else if (o.type === "shape") buildShape(builder, o, unit.baseHeightM, S);
       else if (o.type === "gaArea") buildGa(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)), S);
       else if (o.type === "booth") buildBooth(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)), S);
       else if (o.type === "table") buildTable(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)), S);
+      else if (o.type === "decorImage") buildDecorImage(builder, o, unit.baseHeightM, S);
     }
   }
   const focal = doc.focalPoint ?? { x: (fp.minX + fp.maxX) / 2, y: (fp.minY + fp.maxY) / 2 };
-  const __tm = performance.now();
   const solids = mergeMeshData([builder.build()]);
-  __t("meshBuild+merge", __tm);
-  const __ts = performance.now();
   const seatData = buildSeatInstances(seats, input.initialState, surfaces, seatFloor);
-  __t("seatInstances", __ts);
   const zoneDefs = doc.zones ?? [];
   const zones = [];
   if (zoneDefs.length) {
@@ -2161,6 +2319,7 @@ function buildSceneModel(input) {
     }
   }
   const labels = [];
+  const sections = [];
   for (const z of zones) {
     if (z.seatCount === 0) continue;
     labels.push({
@@ -2173,6 +2332,7 @@ function buildSceneModel(input) {
   }
   {
     const acc = /* @__PURE__ */ new Map();
+    const ext = /* @__PURE__ */ new Map();
     for (let i = 0; i < seats.length; i++) {
       const owner = surfaces.seatOwner[i];
       if (!owner) continue;
@@ -2185,18 +2345,87 @@ function buildSceneModel(input) {
       a.x += seats[i].x;
       a.y += seats[i].y;
       a.deck += surfaces.seatDeckY(i);
+      let e = ext.get(owner);
+      if (!e) {
+        e = { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity };
+        ext.set(owner, e);
+      }
+      if (seats[i].x < e.minX) e.minX = seats[i].x;
+      if (seats[i].x > e.maxX) e.maxX = seats[i].x;
+      if (seats[i].y < e.minY) e.minY = seats[i].y;
+      if (seats[i].y > e.maxY) e.maxY = seats[i].y;
     }
     for (const unit of units) {
       for (const o of unit.objects) {
         if (o.type !== "section") continue;
         const a = acc.get(o.id);
         if (!a || a.n === 0) continue;
+        const e = ext.get(o.id);
+        const centre = [a.x / a.n * M, a.deck / a.n, a.y / a.n * M];
+        sections.push({
+          id: o.id,
+          label: o.displayLabel || o.label || o.id,
+          seatCount: a.n,
+          center: centre,
+          // Half-diagonal of the seat extent — the same fit the zones use.
+          radius: Math.max(1, Math.hypot(e.maxX - e.minX, e.maxY - e.minY) * 0.5 * M),
+          // A section faces its floor's focal, which is what the camera should
+          // look along so the seats present their fronts.
+          focalWorld: [unit.focal.x * M, unit.baseHeightM + 1.5, unit.focal.y * M]
+        });
         labels.push({
           id: `section:${o.id}`,
           kind: "section",
           // The buyer-facing name wins over the technical one, as it does in 2D.
           text: o.displayLabel || o.label || o.id,
-          anchor: [a.x / a.n * M, a.deck / a.n + SECTION_LABEL_LIFT_M, a.y / a.n * M]
+          anchor: [centre[0], centre[1] + SECTION_LABEL_LIFT_M, centre[2]]
+        });
+      }
+    }
+  }
+  {
+    for (const unit of units) {
+      for (const o of unit.objects) {
+        if (o.type !== "gaArea") continue;
+        const c = centroidOf(o.points);
+        if (!c) continue;
+        const name = o.displayLabel || o.label || o.id;
+        labels.push({
+          id: `ga:${o.id}`,
+          kind: "ga",
+          text: o.capacity > 0 ? `${name} \xB7 ${o.capacity.toLocaleString()}` : name,
+          anchor: [c.x * M, unit.baseHeightM + GA_LABEL_LIFT_M, c.y * M]
+        });
+      }
+    }
+    const rowEnds = /* @__PURE__ */ new Map();
+    for (let i = 0; i < seats.length; i++) {
+      const s = seats[i];
+      const far = Math.hypot(s.x - focal.x, s.y - focal.y);
+      const cur = rowEnds.get(s.rowId);
+      if (!cur || far > cur.far) rowEnds.set(s.rowId, { seat: s, index: i, far });
+    }
+    for (const [rowId, end] of rowEnds) {
+      const cut = end.seat.label ? end.seat.label.lastIndexOf("-") : -1;
+      const text = cut > 0 ? end.seat.label.slice(0, cut) : rowId;
+      if (!text) continue;
+      labels.push({
+        id: `row:${rowId}`,
+        kind: "row",
+        text,
+        anchor: [end.seat.x * M, surfaces.seatDeckY(end.index) + ROW_LABEL_LIFT_M, end.seat.y * M]
+      });
+    }
+    if (seats.length <= SEAT_LABEL_MAX) {
+      for (let i = 0; i < seats.length; i++) {
+        const s = seats[i];
+        const text = s.displayLabel || s.label;
+        if (!text) continue;
+        labels.push({
+          id: `seat:${s.id}`,
+          kind: "seat",
+          text,
+          anchor: [s.x * M, surfaces.seatDeckY(i) + SEAT_LABEL_LIFT_M, s.y * M]
         });
       }
     }
@@ -2274,6 +2503,7 @@ function buildSceneModel(input) {
     // Look-at target ~1.5 m up so a seated camera aims slightly down at the stage.
     focalWorld: [focal.x * M, 1.5, focal.y * M],
     zones,
+    sections,
     labels,
     floors
   };
@@ -2285,8 +2515,19 @@ var SEPARATION_Y_PX = 20;
 var KIND_STYLE = {
   zone: { size: 15, weight: "600", opacity: 0.95 },
   section: { size: 12, weight: "500", opacity: 0.88 },
+  ga: { size: 12, weight: "500", opacity: 0.88 },
   booth: { size: 11, weight: "500", opacity: 0.85 },
-  annotation: { size: 11, weight: "400", opacity: 0.75 }
+  annotation: { size: 11, weight: "400", opacity: 0.75 },
+  // Row and seat identity are quieter than the structure they sit inside: at
+  // this range the venue is already understood and the label is a detail, so it
+  // must not compete with the seating it is printed over.
+  row: { size: 10.5, weight: "600", opacity: 0.8 },
+  seat: { size: 9.5, weight: "500", opacity: 0.72 }
+};
+var DENSE_KINDS = /* @__PURE__ */ new Set(["row", "seat"]);
+var DENSE_SEPARATION = {
+  row: { x: 62, y: 16 },
+  seat: { x: 24, y: 13 }
 };
 var LabelOverlay = class {
   constructor(container, opts = {}) {
@@ -2327,7 +2568,15 @@ var LabelOverlay = class {
       if (!screen.visible) continue;
       candidates.push({ label, screen });
     }
-    const kept = cullOverlapping(candidates, SEPARATION_X_PX, SEPARATION_Y_PX);
+    const structure = candidates.filter((c) => !DENSE_KINDS.has(c.label.kind));
+    const kept = [
+      ...cullOverlapping(structure, SEPARATION_X_PX, SEPARATION_Y_PX),
+      ...["row", "seat"].flatMap((kind) => cullOverlapping(
+        candidates.filter((c) => c.label.kind === kind),
+        DENSE_SEPARATION[kind].x,
+        DENSE_SEPARATION[kind].y
+      ))
+    ];
     const keptIds = new Set(kept.map((k) => k.label.id));
     for (const { label, screen } of kept) {
       const node = this.nodeFor(label);
@@ -3683,6 +3932,20 @@ function mountVenue3D(container, input, opts = {}) {
       loop.requestRender();
       return true;
     },
+    sections() {
+      return model.sections;
+    },
+    focusSection(sectionId) {
+      const sec = model.sections.find((s) => s.id === sectionId);
+      if (!sec || sec.seatCount === 0) return false;
+      cinematic.cancel();
+      const dx = sec.focalWorld[0] - sec.center[0];
+      const dz = sec.focalWorld[2] - sec.center[2];
+      const azimuth = Math.hypot(dx, dz) > sec.radius * 0.12 ? Math.atan2(dx, dz) : void 0;
+      orbit.frame({ center: sec.center, radius: sec.radius * 1.45 }, false, azimuth);
+      loop.requestRender();
+      return true;
+    },
     setReducedMotionForTest(value) {
       reducedForced = value;
     },