@seatlayer/core 0.29.0 → 0.30.0

package/dist/view3d/index.cjs

@@ -52,15 +52,6 @@ var SEAT_STATE_COLORS = {
   selected: [0.24, 0.74, 1],
   dimmed: [0.28, 0.32, 0.37]
 };
-function seatStateColorLUT() {
-  const out = [];
-  for (const s of SEAT_STATES) out.push(...SEAT_STATE_COLORS[s]);
-  return out;
-}
-function seatStateColorByIndex(index) {
-  const state = SEAT_STATES[index] ?? "available";
-  return SEAT_STATE_COLORS[state];
-}
 var STRUCTURE = {
   ground: [0.07, 0.085, 0.11],
   tierTop: [0.24, 0.28, 0.34],
@@ -71,7 +62,13 @@ var STRUCTURE = {
   decorTop: [0.22, 0.25, 0.29],
   decorWall: [0.15, 0.17, 0.2],
   gaTop: [0.24, 0.28, 0.33],
-  gaWall: [0.16, 0.19, 0.23]
+  gaWall: [0.16, 0.19, 0.23],
+  /** Exhibition / trade-show booth stand. */
+  boothTop: [0.3, 0.33, 0.38],
+  boothWall: [0.2, 0.23, 0.27],
+  /** Banquet table top — warmer, so a laid table reads apart from structure. */
+  tableTop: [0.38, 0.34, 0.29],
+  tableWall: [0.24, 0.21, 0.18]
 };
 var BACKGROUND = {
   top: [0.05, 0.06, 0.08],
@@ -106,6 +103,8 @@ function computeDpr() {
 }
 var GLContext = class {
   constructor(container, opts) {
+    /** Current clear colour, so a context restore repaints the themed background. */
+    this.clearRgb = [0, 0, 0];
     this.container = container;
     this.canvas = document.createElement("canvas");
     this.canvas.style.display = "block";
@@ -123,7 +122,8 @@ var GLContext = class {
       webgl: 2
     });
     this.gl = this.renderer.gl;
-    this.gl.clearColor(BACKGROUND.top[0], BACKGROUND.top[1], BACKGROUND.top[2], 1);
+    this.clearRgb = [BACKGROUND.top[0], BACKGROUND.top[1], BACKGROUND.top[2]];
+    this.gl.clearColor(this.clearRgb[0], this.clearRgb[1], this.clearRgb[2], 1);
     container.appendChild(this.canvas);
     this.lostHandler = (e) => {
       e.preventDefault();
@@ -134,6 +134,21 @@ var GLContext = class {
     this.canvas.addEventListener("webglcontextrestored", this.restoredHandler, false);
     this.resize();
   }
+  /**
+   * Repaint the clear colour from the chart's theme.
+   *
+   * The clear shows for one frame before the background triangle draws, and on
+   * any frame the scene does not cover — so leaving it at the library default
+   * flashes SeatLayer grey into a white-labelled venue.
+   */
+  setClearColor(rgb) {
+    this.clearRgb = [rgb[0], rgb[1], rgb[2]];
+    this.gl.clearColor(rgb[0], rgb[1], rgb[2], 1);
+  }
+  /** The clear colour currently set (the pick pass restores through this). */
+  get clearColor() {
+    return this.clearRgb;
+  }
   /** Match the drawing buffer to the container's CSS box. */
   resize() {
     const w = Math.max(1, this.container.clientWidth || this.canvas.clientWidth || 1);
@@ -282,14 +297,14 @@ var OrbitCamera = class {
    * then the damped `update()` eases it up into the 3/4 architectural angle and
    * dollies in — the venue "stands up" instead of teleporting (~600ms).
    */
-  frame(bounds, intro = false) {
+  frame(bounds, intro = false, stageAzimuth) {
     this.target.set(bounds.center[0], bounds.center[1], bounds.center[2]);
     const r = Math.max(1, bounds.radius);
     const halfV = this.fovY * DEG / 2;
     const aspect = this.camera.aspect || 1;
     const halfH = Math.atan(Math.tan(halfV) * aspect);
     const fit = Math.max(r / Math.tan(halfV), r / Math.tan(halfH));
-    this.azT = -30 * DEG;
+    this.azT = stageAzimuth ?? -30 * DEG;
     this.polT = 55 * DEG;
     this.distT = fit * FRAME_MARGIN;
     this.minDist = Math.max(2, r * 0.12);
@@ -308,6 +323,24 @@ var OrbitCamera = class {
   setAspect(aspect) {
     this.camera.perspective({ aspect });
   }
+  /**
+   * Damped return to the framed overview from wherever the camera is now (a
+   * seat, behind the shell, anywhere): re-pivot on the venue centre without
+   * moving the camera, then glide targets back to the 3/4 architectural pose.
+   */
+  frameSoft(bounds, stageAzimuth) {
+    this.target.set(bounds.center[0], bounds.center[1], bounds.center[2]);
+    this.syncFromCamera();
+    this.camera.perspective({ fov: this.fovY, aspect: this.camera.aspect });
+    const r = Math.max(1, bounds.radius);
+    const halfV = this.fovY * DEG / 2;
+    const aspect = this.camera.aspect || 1;
+    const halfH = Math.atan(Math.tan(halfV) * aspect);
+    const fit = Math.max(r / Math.tan(halfV), r / Math.tan(halfH));
+    this.azT = stageAzimuth ?? this.azimuth;
+    this.polT = 55 * DEG;
+    this.distT = fit * FRAME_MARGIN;
+  }
   /** Damp toward targets; returns true while still moving. */
   update() {
     const da = this.azT - this.azimuth;
@@ -424,6 +457,46 @@ function computeSeatLod(distance, radius) {
   };
 }
 
+// src/core/types.ts
+var ACCESSIBILITY_TYPES = [
+  { key: "wheelchair", label: "Wheelchair space", short: "Wheelchair", icon: "\u267F" },
+  { key: "companion", label: "Companion seat", short: "Companion", icon: "\u{1F9D1}\u200D\u{1F91D}\u200D\u{1F9D1}" },
+  { key: "semi-ambulatory", label: "Semi-ambulatory (limited mobility)", short: "Limited mobility", icon: "\u{1F9AF}" },
+  { key: "hearing", label: "Assistive listening", short: "Hearing", icon: "\u{1F9BB}" },
+  { key: "cart", label: "CART live-caption view", short: "CART captions", icon: "CC" },
+  { key: "sign-language", label: "Sign-language view", short: "Sign language", icon: "\u{1F91F}" },
+  { key: "plus-size", label: "Plus-size seat", short: "Plus-size", icon: "\u{1F4BA}" },
+  { key: "lift-armrest", label: "Lift-up armrest", short: "Lift armrest", icon: "\u2195\uFE0F" }
+];
+var ACCESSIBILITY_LABEL = new Map(ACCESSIBILITY_TYPES.map((a) => [a.key, a]));
+var ACCESSIBILITY_RING_COLOR = {
+  wheelchair: "#3b82f6",
+  companion: "#8b5cf6",
+  "semi-ambulatory": "#0ea5e9",
+  hearing: "#14b8a6",
+  cart: "#7c3aed",
+  "sign-language": "#f59e0b",
+  "plus-size": "#ec4899",
+  "lift-armrest": "#22c55e"
+};
+function accessibilityRingColor(types) {
+  const primary = types?.[0];
+  return primary && ACCESSIBILITY_RING_COLOR[primary] || "#3b82f6";
+}
+var SURROUNDINGS_SHAPE_ROLES = [
+  "reference-focal",
+  "bar",
+  "entrance",
+  "exit",
+  "restroom",
+  "screen",
+  "sound",
+  "concession",
+  "coat",
+  "wall"
+];
+var SURROUNDINGS_SHAPE_ROLE_SET = new Set(SURROUNDINGS_SHAPE_ROLES);
+
 // src/core/units.ts
 var METRES_PER_CHART_UNIT = 0.55 / 24;
 var CHART_UNITS_PER_METRE = 1 / METRES_PER_CHART_UNIT;
@@ -462,18 +535,47 @@ function sectionGeometry(section, context = {}) {
 
 // src/view3d/scene/geometry.ts
 var import_earcut = __toESM(require("earcut"), 1);
+var import_polygon_clipping = __toESM(require("polygon-clipping"), 1);
 var M = METRES_PER_CHART_UNIT;
+var MIN_TRI_ALTITUDE_M = 2e-3;
+function isDegenerate(p0, p1, p2) {
+  const e0 = Math.hypot(p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2]);
+  const e1 = Math.hypot(p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]);
+  const e2 = Math.hypot(p0[0] - p2[0], p0[1] - p2[1], p0[2] - p2[2]);
+  const longest = Math.max(e0, e1, e2);
+  if (longest < 1e-9) return true;
+  const s = (e0 + e1 + e2) / 2;
+  const area = Math.sqrt(Math.max(0, s * (s - e0) * (s - e1) * (s - e2)));
+  return 2 * area / longest < MIN_TRI_ALTITUDE_M;
+}
 var MeshBuilder = class {
   constructor() {
     this.pos = [];
     this.nor = [];
     this.col = [];
+    this.flr = [];
+    /** Floor index stamped onto every triangle emitted from now on. */
+    this.currentFloor = 0;
+  }
+  /** Stamp subsequent triangles as belonging to `index`. */
+  setFloor(index) {
+    this.currentFloor = index;
   }
   /** 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);
+  }
+  /** 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);
   }
   get vertexCount() {
     return this.pos.length / 3;
@@ -483,6 +585,7 @@ var MeshBuilder = class {
       position: new Float32Array(this.pos),
       normal: new Float32Array(this.nor),
       color: new Float32Array(this.col),
+      floor: new Float32Array(this.flr),
       count: this.pos.length / 3
     };
   }
@@ -537,33 +640,158 @@ function signedArea(pts) {
 function toCCW(pts) {
   return signedArea(pts) < 0 ? [...pts].reverse() : pts;
 }
-function extrudePrism(builder, outlineIn, holesIn, topY, bottomY, colTop, colWall, ao) {
+var MAX_CAP_SPLIT_DEPTH = 3;
+function capDeviation(a, b, c, topY) {
+  const ya = topY(a), yb = topY(b), yc = topY(c);
+  const edge = (p, q, yp, yq) => Math.abs(topY({ x: (p.x + q.x) / 2, y: (p.y + q.y) / 2 }) - (yp + yq) / 2);
+  const cx3 = (a.x + b.x + c.x) / 3, cy3 = (a.y + b.y + c.y) / 3;
+  const yCen = (ya + yb + yc) / 3;
+  let worst = Math.max(
+    edge(a, b, ya, yb),
+    edge(b, c, yb, yc),
+    edge(c, a, yc, ya),
+    Math.abs(topY({ x: cx3, y: cy3 }) - yCen)
+  );
+  const probe = (px, py, yp) => {
+    const d = Math.abs(topY({ x: (px + cx3) / 2, y: (py + cy3) / 2 }) - (yp + yCen) / 2);
+    if (d > worst) worst = d;
+  };
+  probe((a.x + b.x) / 2, (a.y + b.y) / 2, (ya + yb) / 2);
+  probe((b.x + c.x) / 2, (b.y + c.y) / 2, (yb + yc) / 2);
+  probe((c.x + a.x) / 2, (c.y + a.y) / 2, (yc + ya) / 2);
+  return worst;
+}
+function maxDevAtDepth(a, b, c, topY, depth) {
+  if (depth <= 0) return capDeviation(a, b, c, topY);
+  const ab = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+  const bc = { x: (b.x + c.x) / 2, y: (b.y + c.y) / 2 };
+  const ca = { x: (c.x + a.x) / 2, y: (c.y + a.y) / 2 };
+  return Math.max(
+    maxDevAtDepth(a, ab, ca, topY, depth - 1),
+    maxDevAtDepth(ab, b, bc, topY, depth - 1),
+    maxDevAtDepth(ca, bc, c, topY, depth - 1),
+    maxDevAtDepth(ab, bc, ca, topY, depth - 1)
+  );
+}
+function emitCapUniform(builder, a, b, c, topY, colTop, depth, topN) {
+  if (depth > 0) {
+    const ab = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+    const bc = { x: (b.x + c.x) / 2, y: (b.y + c.y) / 2 };
+    const ca = { x: (c.x + a.x) / 2, y: (c.y + a.y) / 2 };
+    emitCapUniform(builder, a, ab, ca, topY, colTop, depth - 1, topN);
+    emitCapUniform(builder, ab, b, bc, topY, colTop, depth - 1, topN);
+    emitCapUniform(builder, ca, bc, c, topY, colTop, depth - 1, topN);
+    emitCapUniform(builder, ab, bc, ca, topY, colTop, depth - 1, topN);
+    return;
+  }
+  const at = [a.x * M, topY(a), a.y * M];
+  const bt = [b.x * M, topY(b), b.y * M];
+  const ct = [c.x * M, topY(c), c.y * M];
+  if (topN) {
+    builder.triN(at, bt, ct, topN(a), topN(b), topN(c), colTop);
+    return;
+  }
+  let n = faceNormal(at, bt, ct);
+  if (n[1] < 0) n = [-n[0], -n[1], -n[2]];
+  builder.tri(at, bt, ct, n, colTop);
+}
+var MAX_RING_SPLIT_DEPTH = 8;
+function densifyRing(ring, topY, maxError) {
+  if (!Number.isFinite(maxError)) return ring;
+  const out = [];
+  const emit = (p, q, yp, yq, depth) => {
+    if (depth > 0) {
+      const mid = { x: (p.x + q.x) / 2, y: (p.y + q.y) / 2 };
+      const ym = topY(mid);
+      if (Math.abs(ym - (yp + yq) / 2) > maxError) {
+        emit(p, mid, yp, ym, depth - 1);
+        emit(mid, q, ym, yq, depth - 1);
+        return;
+      }
+    }
+    out.push(p);
+  };
+  for (let i = 0; i < ring.length; i++) {
+    const p = ring[i], q = ring[(i + 1) % ring.length];
+    emit(p, q, topY(p), topY(q), MAX_RING_SPLIT_DEPTH);
+  }
+  return out;
+}
+function dedupeRing(ring, eps) {
+  if (ring.length < 3) return 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) < eps) 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) < eps) {
+    out.pop();
+  }
+  if (out.length < 3) return ring;
+  const keep = [];
+  for (let i = 0; i < out.length; i++) {
+    const prev = keep.length ? keep[keep.length - 1] : out[(i - 1 + out.length) % out.length];
+    const p = out[i];
+    const next = out[(i + 1) % out.length];
+    const ax = next.x - prev.x, ay = next.y - prev.y;
+    const len = Math.hypot(ax, ay);
+    if (len > eps) {
+      const cross = Math.abs((p.x - prev.x) * ay - (p.y - prev.y) * ax) / len;
+      if (cross < eps) continue;
+    }
+    keep.push(p);
+  }
+  return keep.length >= 3 ? keep : out;
+}
+var RING_EPS_U = 1e-3 * CHART_UNITS_PER_METRE * 0.1;
+function extrudePrism(builder, outlineIn, holesIn, topY, bottomY, colTop, colWall, ao, maxCapError = Infinity, topNormal) {
   if (!outlineIn || outlineIn.length < 3) return;
+  if (maxCapError === void 0) maxCapError = Infinity;
   if (Math.abs(signedArea(outlineIn)) < 1e-4) return;
-  const outline = toCCW(outlineIn);
-  const holes = holesIn?.map((h) => toCCW(h)).filter((h) => h.length >= 3 && Math.abs(signedArea(h)) >= 1e-4);
+  const outline = dedupeRing(densifyRing(dedupeRing(toCCW(outlineIn), RING_EPS_U), topY, maxCapError), RING_EPS_U);
+  const holes = holesIn?.map((h) => dedupeRing(densifyRing(dedupeRing(toCCW(h), RING_EPS_U), topY, maxCapError), RING_EPS_U)).filter((h) => h.length >= 3 && Math.abs(signedArea(h)) >= 1e-4);
   const { pts, tris } = triangulate(outline, holes);
   const cTop = [colTop[0] * ao.top, colTop[1] * ao.top, colTop[2] * ao.top];
   const cBot = [colTop[0] * ao.bottomCap, colTop[1] * ao.bottomCap, colTop[2] * ao.bottomCap];
   const cWallTop = [colWall[0] * ao.top, colWall[1] * ao.top, colWall[2] * ao.top];
   const cWallBot = [colWall[0] * ao.wallBottom, colWall[1] * ao.wallBottom, colWall[2] * ao.wallBottom];
+  let capDepth = 0;
+  if (Number.isFinite(maxCapError)) {
+    for (; capDepth < MAX_CAP_SPLIT_DEPTH; capDepth++) {
+      let worst = 0;
+      for (let i = 0; i < tris.length; i += 3) {
+        const d = maxDevAtDepth(pts[tris[i]], pts[tris[i + 1]], pts[tris[i + 2]], topY, capDepth);
+        if (d > worst) worst = d;
+      }
+      if (worst <= maxCapError) break;
+    }
+  }
   for (let i = 0; i < tris.length; i += 3) {
     const a = pts[tris[i]], b = pts[tris[i + 1]], c = pts[tris[i + 2]];
-    const at = [a.x * M, topY(a), a.y * M];
-    const bt = [b.x * M, topY(b), b.y * M];
-    const ct = [c.x * M, topY(c), c.y * M];
-    let n = faceNormal(at, bt, ct);
-    if (n[1] < 0) n = [-n[0], -n[1], -n[2]];
-    builder.tri(at, bt, ct, n, cTop);
+    emitCapUniform(builder, a, b, c, topY, cTop, capDepth, topNormal);
     const ab = [a.x * M, bottomY, a.y * M];
     const bb = [b.x * M, bottomY, b.y * M];
     const cb = [c.x * M, bottomY, c.y * M];
     builder.tri(ab, cb, bb, [0, -1, 0], cBot);
   }
+  const splitRing = (ring) => {
+    if (capDepth <= 0) return ring;
+    const n = 1 << capDepth;
+    const out = [];
+    for (let i = 0; i < ring.length; i++) {
+      const a = ring[i], b = ring[(i + 1) % ring.length];
+      for (let k = 0; k < n; k++) {
+        const t = k / n;
+        out.push({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
+      }
+    }
+    return out;
+  };
   const oc = centroid(outline);
-  const rings = [{ ring: outline, flip: false }];
+  const rings = [{ ring: splitRing(outline), flip: false }];
   if (holes) {
-    for (const h of holes) if (h.length >= 3) rings.push({ ring: h, flip: true });
+    for (const h of holes) if (h.length >= 3) rings.push({ ring: splitRing(h), flip: true });
   }
   for (const { ring, flip } of rings) {
     for (let i = 0; i < ring.length; i++) {
@@ -599,14 +827,74 @@ function mergeMeshData(parts) {
   const position = new Float32Array(total * 3);
   const normal = new Float32Array(total * 3);
   const color = new Float32Array(total * 3);
+  const floor = new Float32Array(total);
   let off = 0;
   for (const p of parts) {
     position.set(p.position, off * 3);
     normal.set(p.normal, off * 3);
     color.set(p.color, off * 3);
+    floor.set(p.floor, off);
     off += p.count;
   }
-  return { position, normal, color, count: total };
+  return { position, normal, color, floor, count: total };
+}
+function outsetRing(ring, d, miterLimit = 2.5) {
+  if (d <= 0 || ring.length < 3) return ring;
+  const r = toCCW(ring);
+  const n = r.length;
+  const nrm = [];
+  for (let i = 0; i < n; i++) {
+    const a = r[i], b = r[(i + 1) % n];
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const len = Math.hypot(dx, dy) || 1;
+    nrm.push({ x: dy / len, y: -dx / len });
+  }
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const p = r[i];
+    const nPrev = nrm[(i - 1 + n) % n];
+    const nCur = nrm[i];
+    let mx = nPrev.x + nCur.x, my = nPrev.y + nCur.y;
+    const ml = Math.hypot(mx, my);
+    const bevel = () => {
+      out.push([p.x + nPrev.x * d, p.y + nPrev.y * d]);
+      out.push([p.x + nCur.x * d, p.y + nCur.y * d]);
+    };
+    if (ml < 1e-9) {
+      bevel();
+      continue;
+    }
+    mx /= ml;
+    my /= ml;
+    const cosHalf = mx * nPrev.x + my * nPrev.y;
+    const scale2 = 1 / Math.max(cosHalf, 1e-6);
+    if (!Number.isFinite(scale2) || scale2 > miterLimit) {
+      bevel();
+      continue;
+    }
+    out.push([p.x + mx * d * scale2, p.y + my * d * scale2]);
+  }
+  if (out.length < 3) return ring;
+  try {
+    const merged = import_polygon_clipping.default.union([[...out, out[0]]]);
+    let best = null, bestArea = -Infinity;
+    for (const poly of merged) {
+      const area = Math.abs(signedArea(poly[0].map(([x, y]) => ({ x, y }))));
+      if (area > bestArea) {
+        bestArea = area;
+        best = poly[0];
+      }
+    }
+    if (!best) return ring;
+    const pts = best.map(([x, y]) => ({ x, y }));
+    if (pts.length > 1) {
+      const f = pts[0], l = pts[pts.length - 1];
+      if (Math.abs(f.x - l.x) < 1e-9 && Math.abs(f.y - l.y) < 1e-9) pts.pop();
+    }
+    return pts.length >= 3 ? pts : ring;
+  } catch {
+    return ring;
+  }
 }
 function ellipsePolygon(cx, cy, rx, ry, seg = 28) {
   const out = [];
@@ -626,29 +914,107 @@ function rectPolygon(x, y, w, h) {
 }
 
 // src/view3d/scene/seatInstances.ts
-var SEAT_SURFACE_LIFT_M = 0.18;
+var SEAT_DOT_RADIUS_M = 0.22;
+var SEAT_PITCH_FRACTION = 0.42;
+function nearestNeighbourSpacing(seats) {
+  const n = seats.length;
+  const out = new Float64Array(n);
+  if (n < 2) {
+    out.fill(Infinity);
+    return out;
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const s of seats) {
+    if (s.x < minX) minX = s.x;
+    if (s.y < minY) minY = s.y;
+    if (s.x > maxX) maxX = s.x;
+    if (s.y > maxY) maxY = s.y;
+  }
+  const w = Math.max(maxX - minX, 1e-6), h = Math.max(maxY - minY, 1e-6);
+  const cell = Math.max(Math.sqrt(w * h / n), 1e-6);
+  const cols = Math.max(1, Math.ceil(w / cell) + 1);
+  const rows = Math.max(1, Math.ceil(h / cell) + 1);
+  const buckets = /* @__PURE__ */ new Map();
+  const cellOf = (x, y) => {
+    const cx = Math.min(cols - 1, Math.max(0, Math.floor((x - minX) / cell)));
+    const cy = Math.min(rows - 1, Math.max(0, Math.floor((y - minY) / cell)));
+    return cy * cols + cx;
+  };
+  for (let i = 0; i < n; i++) {
+    const k = cellOf(seats[i].x, seats[i].y);
+    const b = buckets.get(k);
+    if (b) b.push(i);
+    else buckets.set(k, [i]);
+  }
+  for (let i = 0; i < n; i++) {
+    const s = seats[i];
+    const cx = Math.min(cols - 1, Math.max(0, Math.floor((s.x - minX) / cell)));
+    const cy = Math.min(rows - 1, Math.max(0, Math.floor((s.y - minY) / cell)));
+    let best = Infinity;
+    for (let r = 1; r <= 4; r++) {
+      for (let gy = cy - r; gy <= cy + r; gy++) {
+        if (gy < 0 || gy >= rows) continue;
+        for (let gx = cx - r; gx <= cx + r; gx++) {
+          if (gx < 0 || gx >= cols) continue;
+          if (r > 1 && Math.abs(gy - cy) < r && Math.abs(gx - cx) < r) continue;
+          const b = buckets.get(gy * cols + gx);
+          if (!b) continue;
+          for (const j of b) {
+            if (j === i) continue;
+            const d = Math.hypot(seats[j].x - s.x, seats[j].y - s.y);
+            if (d < best) best = d;
+          }
+        }
+      }
+      if (Number.isFinite(best) && best <= r * cell) break;
+    }
+    out[i] = best;
+  }
+  return out;
+}
 function seatSurfaceY(seat) {
   const eye = seat.eyeHeightM;
-  if (Number.isFinite(eye)) {
-    return Math.max(0, eye - SEATED_EYE_HEIGHT_M) + SEAT_SURFACE_LIFT_M;
-  }
-  return SEAT_SURFACE_LIFT_M;
+  if (Number.isFinite(eye)) return Math.max(0, eye - SEATED_EYE_HEIGHT_M);
+  return 0;
 }
-function buildSeatInstances(seats, initial) {
+function buildSeatInstances(seats, initial, surfaces, seatFloor) {
   const count = seats.length;
   const iPosition = new Float32Array(count * 3);
   const iState = new Float32Array(count);
+  const iMaxRadius = new Float32Array(count);
+  const iRing = new Float32Array(count * 3);
   const idToIndex = /* @__PURE__ */ new Map();
+  const spacing = nearestNeighbourSpacing(seats);
   for (let i = 0; i < count; i++) {
     const seat = seats[i];
+    const resolved = surfaces?.seatPitchU(i);
+    const pitchM = (resolved ?? spacing[i]) * M;
+    iMaxRadius[i] = Number.isFinite(pitchM) ? Math.max(0.06, Math.min(SEAT_DOT_RADIUS_M, pitchM * SEAT_PITCH_FRACTION)) : SEAT_DOT_RADIUS_M;
     iPosition[i * 3] = seat.x * M;
-    iPosition[i * 3 + 1] = seatSurfaceY(seat);
+    iPosition[i * 3 + 1] = surfaces ? surfaces.seatDeckY(i) : seatSurfaceY(seat);
     iPosition[i * 3 + 2] = seat.y * M;
     iState[i] = seatStateIndex(initial ? initial(seat) : "available");
+    if (seat.accessibility?.length) {
+      const rgb = hexToRgb(accessibilityRingColor(seat.accessibility));
+      if (rgb) {
+        iRing[i * 3] = rgb[0];
+        iRing[i * 3 + 1] = rgb[1];
+        iRing[i * 3 + 2] = rgb[2];
+      }
+    }
     idToIndex.set(seat.id, i);
   }
-  return { count, iPosition, iState, idToIndex };
+  return {
+    count,
+    iPosition,
+    iState,
+    iMaxRadius,
+    iRing,
+    idToIndex,
+    iFloor: seatFloor ?? new Float32Array(count)
+  };
 }
+var RUN_MERGE_GAP = 64;
 function applySeatStates(data, updates) {
   const changed = [];
   for (const u of updates) {
@@ -668,7 +1034,7 @@ function applySeatStates(data, updates) {
   for (let i = 1; i < changed.length; i++) {
     const idx = changed[i];
     if (idx === prev) continue;
-    if (idx === prev + 1) {
+    if (idx <= prev + RUN_MERGE_GAP) {
       prev = idx;
       continue;
     }
@@ -680,6 +1046,1155 @@ function applySeatStates(data, updates) {
   return runs;
 }
 
+// src/view3d/theme.ts
+var BACKGROUND_INFLUENCE = 0.15;
+var BG_TOP_SCALE = 0.9;
+var BG_BOTTOM_SCALE = 1.76;
+var SEAT_SCALE_MIN = 0.7;
+var SEAT_SCALE_MAX = 1.6;
+function defaultTheme3D() {
+  return {
+    background: { top: [...BACKGROUND.top], bottom: [...BACKGROUND.bottom] },
+    structure: STRUCTURE,
+    seatStates: { ...SEAT_STATE_COLORS },
+    seatScale: 1
+  };
+}
+function resolveTheme3D(theme) {
+  const base = defaultTheme3D();
+  if (!theme) return base;
+  const bg = hexToRgb(theme.background);
+  if (bg) {
+    base.background = {
+      top: scaleRgb(bg, BG_TOP_SCALE),
+      bottom: scaleRgb(bg, BG_BOTTOM_SCALE)
+    };
+    const rebased = {};
+    for (const [key, value] of Object.entries(STRUCTURE)) {
+      rebased[key] = mix(value, bg, BACKGROUND_INFLUENCE);
+    }
+    base.structure = rebased;
+  }
+  const selection = hexToRgb(theme.selectionColor) ?? hexToRgb(theme.accent);
+  if (selection) base.seatStates = { ...base.seatStates, selected: selection };
+  const scale2 = theme.seatScale;
+  if (typeof scale2 === "number" && Number.isFinite(scale2)) {
+    base.seatScale = Math.min(SEAT_SCALE_MAX, Math.max(SEAT_SCALE_MIN, scale2));
+  }
+  return base;
+}
+function themeSeatColorLUT(theme, order) {
+  const out = [];
+  for (const s of order) out.push(...theme.seatStates[s]);
+  return out;
+}
+
+// src/view3d/labels.ts
+var ZONE_MIN_DISTANCE = 1.15;
+var SECTION_MAX_DISTANCE = 2.2;
+var NEAR_MAX_DISTANCE = 0.85;
+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 <= NEAR_MAX_DISTANCE) {
+    out.add("annotation");
+    out.add("booth");
+  }
+  return out;
+}
+function projectToScreen(viewProjection, p, width, height) {
+  const m = viewProjection;
+  const x = p[0], y = p[1], z = p[2];
+  const cx = m[0] * x + m[4] * y + m[8] * z + m[12];
+  const cy = m[1] * x + m[5] * y + m[9] * z + m[13];
+  const cz = m[2] * x + m[6] * y + m[10] * z + m[14];
+  const cw = m[3] * x + m[7] * y + m[11] * z + m[15];
+  if (!(cw > 1e-6)) return { x: 0, y: 0, depth: Infinity, visible: false };
+  const ndcX = cx / cw, ndcY = cy / cw, ndcZ = cz / cw;
+  const inside = ndcX >= -1.05 && ndcX <= 1.05 && ndcY >= -1.05 && ndcY <= 1.05 && ndcZ <= 1;
+  return {
+    x: (ndcX * 0.5 + 0.5) * width,
+    y: (1 - (ndcY * 0.5 + 0.5)) * height,
+    depth: ndcZ,
+    visible: inside
+  };
+}
+function cullOverlapping(items, separationX, separationY = separationX) {
+  const kept = [];
+  const ordered = [...items].sort((a, b) => a.screen.depth - b.screen.depth);
+  for (const item of ordered) {
+    let clash = false;
+    for (const k of kept) {
+      const dx = Math.abs(item.screen.x - k.screen.x);
+      const dy = Math.abs(item.screen.y - k.screen.y);
+      if (dx < separationX && dy < separationY) {
+        clash = true;
+        break;
+      }
+    }
+    if (!clash) kept.push(item);
+  }
+  return kept;
+}
+function centroidOf(points) {
+  if (!points.length) return null;
+  let x = 0, y = 0;
+  for (const p of points) {
+    x += p.x;
+    y += p.y;
+  }
+  return { x: x / points.length, y: y / points.length };
+}
+
+// src/view3d/scene/sceneModel.ts
+var import_polygon_clipping3 = __toESM(require("polygon-clipping"), 1);
+
+// 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 t = len2 > 1e-12 ? ((x - a.x) * vx + (y - a.y) * vy) / len2 : 0;
+    if (t < 0) t = 0;
+    else if (t > 1) t = 1;
+    const d = Math.hypot(x - (a.x + t * vx), y - (a.y + t * 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 t = p.x * ax + p.y * ay;
+      if (t < rlo) rlo = t;
+      if (t > rhi) rhi = t;
+      if (t < lo) lo = t;
+      if (t > hi) hi = t;
+    }
+    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 bounds = 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(bounds[i], bounds[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(bounds[i], bounds[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
+var DEG2 = Math.PI / 180;
+function pointInPolygon(p, poly) {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const xi = poly[i].x;
+    const yi = poly[i].y;
+    const xj = poly[j].x;
+    const yj = poly[j].y;
+    const hit = yi > p.y !== yj > p.y && p.x < (xj - xi) * (p.y - yi) / (yj - yi) + xi;
+    if (hit) inside = !inside;
+  }
+  return inside;
+}
+function pointOnPolygonBoundary(p, poly) {
+  return poly.some((start, index) => {
+    const end = poly[(index + 1) % poly.length];
+    const cross = (p.y - start.y) * (end.x - start.x) - (p.x - start.x) * (end.y - start.y);
+    if (Math.abs(cross) > 1e-7) return false;
+    const dot = (p.x - start.x) * (end.x - start.x) + (p.y - start.y) * (end.y - start.y);
+    const lengthSquared = (end.x - start.x) ** 2 + (end.y - start.y) ** 2;
+    return dot >= -1e-7 && dot <= lengthSquared + 1e-7;
+  });
+}
+function pointInPolygonWithHoles(p, outer, holes) {
+  return pointInPolygon(p, outer) && !(holes ?? []).some((hole) => pointInPolygon(p, hole) || pointOnPolygonBoundary(p, hole));
+}
+
+// src/core/rake.ts
+var BLEND_ROWS = 3;
+var BLEND_DISTANCE_RATIO = 2.2;
+var GRAD_STEP = 0.5;
+function radialRake(focal) {
+  return {
+    kind: "radial",
+    rowCount: 0,
+    rows: [],
+    nearestRow: () => -1,
+    depthAt: (x, y) => Math.hypot(x - focal.x, y - focal.y),
+    gradientAt: (x, y) => {
+      const dx = x - focal.x, dy = y - focal.y;
+      const d = Math.hypot(dx, dy);
+      return d < 1e-9 ? [0, 0] : [dx / d, dy / d];
+    }
+  };
+}
+function fitRow(points, focal) {
+  if (!points.length) return null;
+  let cx = 0, cy = 0, depth = 0;
+  for (const p of points) {
+    cx += p.x;
+    cy += p.y;
+    depth += Math.hypot(p.x - focal.x, p.y - focal.y);
+  }
+  const n = points.length;
+  cx /= n;
+  cy /= n;
+  depth /= n;
+  let ax = points[0], far = -1;
+  for (const p of points) {
+    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 pts = [...points].sort((p, q) => (p.x - cx) * dx + (p.y - cy) * dy - ((q.x - cx) * dx + (q.y - cy) * dy));
+  let radius = 0;
+  for (const p of pts) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > radius) radius = d;
+  }
+  return { pts, cx, cy, radius, depth };
+}
+function distToRow(r, x, y) {
+  const pts = r.pts;
+  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 t = len2 > 1e-12 ? ((x - a.x) * vx + (y - a.y) * vy) / len2 : 0;
+    if (t < 0) t = 0;
+    else if (t > 1) t = 1;
+    const d = Math.hypot(x - (a.x + t * vx), y - (a.y + t * vy));
+    if (d < best) best = d;
+  }
+  return best;
+}
+var CANDIDATE_ROWS = 8;
+function sampleRows(rows, x, y) {
+  const candD = new Array(CANDIDATE_ROWS).fill(Infinity);
+  const candI = new Array(CANDIDATE_ROWS).fill(-1);
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    const lower = Math.hypot(x - r.cx, y - r.cy) - r.radius;
+    for (let k = 0; k < CANDIDATE_ROWS; k++) {
+      if (lower < candD[k]) {
+        for (let j = CANDIDATE_ROWS - 1; j > k; j--) {
+          candD[j] = candD[j - 1];
+          candI[j] = candI[j - 1];
+        }
+        candD[k] = lower;
+        candI[k] = i;
+        break;
+      }
+    }
+  }
+  const bestD = new Array(BLEND_ROWS).fill(Infinity);
+  const bestI = new Array(BLEND_ROWS).fill(-1);
+  for (const i of candI) {
+    if (i < 0) continue;
+    const d = distToRow(rows[i], x, y);
+    for (let k = 0; k < BLEND_ROWS; k++) {
+      if (d < bestD[k]) {
+        for (let j = BLEND_ROWS - 1; j > k; j--) {
+          bestD[j] = bestD[j - 1];
+          bestI[j] = bestI[j - 1];
+        }
+        bestD[k] = d;
+        bestI[k] = i;
+        break;
+      }
+    }
+  }
+  if (bestI[0] < 0) return 0;
+  if (bestD[0] < 1e-6) return rows[bestI[0]].depth;
+  const cutoff = bestD[0] * BLEND_DISTANCE_RATIO;
+  let num = 0, den = 0;
+  for (let k = 0; k < BLEND_ROWS; k++) {
+    const i = bestI[k];
+    if (i < 0 || bestD[k] > cutoff) continue;
+    const w = 1 / (bestD[k] * bestD[k]);
+    num += w * rows[i].depth;
+    den += w;
+  }
+  return den > 0 ? num / den : rows[bestI[0]].depth;
+}
+function rowsRake(rows) {
+  const depthAt = (x, y) => sampleRows(rows, x, y);
+  const nearestRow = (x, y) => {
+    let best = Infinity, bestI = -1;
+    for (let i = 0; i < rows.length; i++) {
+      const r = rows[i];
+      if (Math.hypot(x - r.cx, y - r.cy) - r.radius >= best) continue;
+      const d = distToRow(r, x, y);
+      if (d < best) {
+        best = d;
+        bestI = i;
+      }
+    }
+    return bestI;
+  };
+  return {
+    kind: "rows",
+    rowCount: rows.length,
+    rows,
+    nearestRow,
+    depthAt,
+    gradientAt: (x, y) => {
+      const gx = (depthAt(x + GRAD_STEP, y) - depthAt(x - GRAD_STEP, y)) / (2 * GRAD_STEP);
+      const gy = (depthAt(x, y + GRAD_STEP) - depthAt(x, y - GRAD_STEP)) / (2 * GRAD_STEP);
+      const len = Math.hypot(gx, gy);
+      return len < 1e-9 ? [0, 0] : [gx / len, gy / len];
+    }
+  };
+}
+function buildSectionRake(rows, focal) {
+  const fits = [];
+  for (const r of rows) {
+    const f = fitRow(r.points, focal);
+    if (f) fits.push(f);
+  }
+  if (fits.length < 2) return radialRake(focal);
+  fits.sort((a, b) => a.depth - b.depth);
+  return rowsRake(fits);
+}
+
+// src/view3d/scene/surface.ts
+var FLAT_SLAB_TOP_M = 0.05;
+var CAP_MAX_ERROR_M = 0.05;
+var SEAT_CLEARANCE_M = 0.15;
+var SEAT_OWNERSHIP_PAD_U = SEAT_DOT_RADIUS_M * 1.5 * CHART_UNITS_PER_METRE;
+function bboxOf(pts) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of pts) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+var MAX_TIER_RISE_M = 25;
+function buildVenueSurfaces(units, seats) {
+  const bySection = /* @__PURE__ */ new Map();
+  const seatOwner = new Array(seats.length).fill(null);
+  const seatDeck = new Float64Array(seats.length);
+  const seatRowLevel = new Array(seats.length).fill(void 0);
+  const seatPitch = new Array(seats.length).fill(void 0);
+  const acc = /* @__PURE__ */ new Map();
+  const boxes = [];
+  for (const unit of units) {
+    for (const o of unit.objects) {
+      if (o.type !== "section" || !o.outline || o.outline.length < 3) continue;
+      const owned = outsetRing(o.outline, SEAT_OWNERSHIP_PAD_U);
+      acc.set(o.id, { section: o, unit, frontU: Infinity, hasSeats: false, rows: /* @__PURE__ */ new Map(), seatIndices: [] });
+      boxes.push({ id: o.id, box: bboxOf(owned), section: o, unit, outline: owned });
+    }
+  }
+  for (let i = 0; i < seats.length; i++) {
+    const s = seats[i];
+    for (const b of boxes) {
+      if (s.x < b.box.minX || s.x > b.box.maxX || s.y < b.box.minY || s.y > b.box.maxY) continue;
+      if (!pointInPolygonWithHoles({ x: s.x, y: s.y }, b.outline, b.section.holes)) continue;
+      seatOwner[i] = b.id;
+      const a = acc.get(b.id);
+      a.hasSeats = true;
+      const f = s.focalPoint ?? b.unit.focal;
+      const d = Math.hypot(s.x - f.x, s.y - f.y);
+      if (d < a.frontU) a.frontU = d;
+      a.seatIndices.push(i);
+      const rowKey = s.rowId || `__seat-${i}`;
+      const arr = a.rows.get(rowKey);
+      if (arr) arr.push({ x: s.x, y: s.y });
+      else a.rows.set(rowKey, [{ x: s.x, y: s.y }]);
+      break;
+    }
+  }
+  for (const [id, a] of acc) {
+    const geo = sectionGeometry(a.section, { floorBaseHeightM: a.unit.baseHeightM });
+    const bottomY = a.unit.baseHeightM;
+    const rakeTan = geo.rake > 0 ? Math.tan(geo.rake * Math.PI / 180) : 0;
+    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);
+    let frontU = Infinity;
+    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;
+      }
+    }
+    const flatTop = bottomY + FLAT_SLAB_TOP_M;
+    const baseFloor = bottomY + FLAT_SLAB_TOP_M;
+    const levelFor = (depthU) => {
+      const depthM = Math.max(0, depthU - frontU) * METRES_PER_CHART_UNIT;
+      const rise = Math.min(depthM * rakeTan, MAX_TIER_RISE_M);
+      return Math.max(baseFloor, geo.height + rise);
+    };
+    const levelForBlockDepth = (blockDepthU) => {
+      const depthM = Math.max(0, blockDepthU) * METRES_PER_CHART_UNIT;
+      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),
+      depth: r.blockDepth,
+      blockId: r.blockId
+    }));
+    const landingY = rowLevels.length ? rowLevels[0].y : flatTop;
+    const rowBounds = rowLevels.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 deckAt = flat ? () => flatTop : rowLevels.length >= 2 ? (x, y) => {
+      let best = Infinity, bestY = landingY;
+      for (let i = 0; i < rowLevels.length; i++) {
+        const b = rowBounds[i];
+        if (Math.hypot(x - b.cx, y - b.cy) - b.rad >= best) continue;
+        const d = distanceToPolyline(rowLevels[i].pts, x, y);
+        if (d < best) {
+          best = d;
+          bestY = rowLevels[i].y;
+        }
+      }
+      return bestY;
+    } : (x, y) => levelFor(rake.depthAt(x, y));
+    const UP = [0, 1, 0];
+    const normalAt = rowLevels.length >= 2 || flat ? () => UP : (x, y) => {
+      const d = rake.depthAt(x, y);
+      if (d <= frontU) return UP;
+      const depthM = (d - frontU) * METRES_PER_CHART_UNIT;
+      if (depthM * rakeTan >= MAX_TIER_RISE_M) return UP;
+      if (geo.height + depthM * rakeTan <= baseFloor) return UP;
+      const [gx, gy] = rake.gradientAt(x, y);
+      if (gx === 0 && gy === 0) return UP;
+      const inv = 1 / Math.hypot(rakeTan, 1);
+      return [-gx * rakeTan * inv, inv, -gy * rakeTan * inv];
+    };
+    if (!flat) {
+      for (const r of structure.rows) {
+        const y = levelForBlockDepth(r.blockDepth);
+        for (const si of r.seatIndices) seatRowLevel[si] = y;
+      }
+    }
+    for (const r of structure.rows) {
+      const gaps = [];
+      for (let k = 1; k < r.pts.length; k++) {
+        const d = Math.hypot(r.pts[k].x - r.pts[k - 1].x, r.pts[k].y - r.pts[k - 1].y);
+        if (d > 1e-6) gaps.push(d);
+      }
+      gaps.sort((x, y) => x - y);
+      const along = gaps.length ? gaps[Math.floor(gaps.length / 2)] : Infinity;
+      let across = Infinity;
+      const probe = r.pts[Math.floor(r.pts.length / 2)];
+      if (probe) {
+        for (const other of structure.rows) {
+          if (other === r || other.blockId !== r.blockId) continue;
+          const d = distanceToPolyline(other.pts, probe.x, probe.y);
+          if (d > 1e-6 && d < across) across = d;
+        }
+      }
+      const pitch = Math.min(along, Math.max(across, along * 0.5));
+      if (Number.isFinite(pitch) && pitch > 0) {
+        for (const si of r.seatIndices) seatPitch[si] = pitch;
+      }
+    }
+    bySection.set(id, { sectionId: id, deckAt, normalAt, flat, bottomY, rowLevels, landingY });
+  }
+  for (let i = 0; i < seats.length; i++) {
+    const ownerId = seatOwner[i];
+    const s = seats[i];
+    if (ownerId) {
+      const own = seatRowLevel[i];
+      seatDeck[i] = (own ?? bySection.get(ownerId).deckAt(s.x, s.y)) + SEAT_CLEARANCE_M;
+      continue;
+    }
+    const eye = s.eyeHeightM;
+    seatDeck[i] = Number.isFinite(eye) ? Math.max(0, eye - SEATED_EYE_HEIGHT_M) : 0;
+  }
+  return {
+    bySection,
+    seatOwner,
+    seatDeckY: (i) => seatDeck[i],
+    seatPitchU: (i) => seatPitch[i]
+  };
+}
+
+// src/view3d/scene/deckBands.ts
+var import_polygon_clipping2 = __toESM(require("polygon-clipping"), 1);
+var import_earcut2 = __toESM(require("earcut"), 1);
+var FRONT_REACH = 0.58;
+var MIN_RISER_M = 0.01;
+var MIN_REACH_U = SEAT_DOT_RADIUS_M * 1.5 * CHART_UNITS_PER_METRE;
+var BACK_REACH = 0.5;
+var END_REACH = 0.6;
+function rowNormals(pts, focal) {
+  const n = pts.length;
+  const raw = [];
+  for (let i = 0; i < n; i++) {
+    const a = pts[Math.max(0, i - 1)];
+    const b = pts[Math.min(n - 1, i + 1)];
+    let dx = b.x - a.x, dy = b.y - a.y;
+    const len = Math.hypot(dx, dy);
+    if (len < 1e-9) {
+      raw.push([0, 0]);
+      continue;
+    }
+    dx /= len;
+    dy /= len;
+    raw.push([-dy, dx]);
+  }
+  let vote = 0;
+  for (let i = 0; i < n; i++) {
+    vote += (pts[i].x - focal.x) * raw[i][0] + (pts[i].y - focal.y) * raw[i][1];
+  }
+  const flip = vote < 0;
+  return flip ? raw.map(([x, y]) => [-x, -y]) : raw;
+}
+function extendEnds(pts, by) {
+  if (pts.length < 2 || by <= 0) return [...pts];
+  const out = [...pts];
+  const dir = (p, q) => {
+    const dx = q.x - p.x, dy = q.y - p.y;
+    const len = Math.hypot(dx, dy) || 1;
+    return { x: dx / len, y: dy / len };
+  };
+  const head = dir(out[1], out[0]);
+  const tail = dir(out[out.length - 2], out[out.length - 1]);
+  out.unshift({ x: out[0].x + head.x * by, y: out[0].y + head.y * by });
+  out.push({
+    x: out[out.length - 1].x + tail.x * by,
+    y: out[out.length - 1].y + tail.y * by
+  });
+  return out;
+}
+function distToPolyline(pts, x, y) {
+  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 t = len2 > 1e-12 ? ((x - a.x) * vx + (y - a.y) * vy) / len2 : 0;
+    if (t < 0) t = 0;
+    else if (t > 1) t = 1;
+    const d = Math.hypot(x - (a.x + t * vx), y - (a.y + t * vy));
+    if (d < best) best = d;
+  }
+  return best;
+}
+function neighbourhoods(rows) {
+  const probesOf2 = (pts) => {
+    const n = pts.length;
+    if (n <= 2) return [...pts];
+    return [pts[Math.floor(n * 0.25)], pts[Math.floor(n * 0.5)], pts[Math.floor(n * 0.75)]];
+  };
+  const out = [];
+  for (let i = 0; i < rows.length; i++) {
+    const probes = probesOf2(rows[i].pts);
+    const pitches = [];
+    let bestFrontD = Infinity, belowY = null;
+    for (const c of probes) {
+      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 d = distToPolyline(rows[j].pts, c.x, c.y);
+        if (d < nearest) nearest = d;
+        if (rows[j].depth < rows[i].depth && d < bestFrontD) {
+          bestFrontD = d;
+          belowY = rows[j].y;
+        }
+      }
+      if (Number.isFinite(nearest) && nearest > 0) pitches.push(nearest);
+    }
+    pitches.sort((a, b) => a - b);
+    const pitch = pitches.length ? pitches[Math.floor(pitches.length / 2)] : 1;
+    out.push({ pitch, belowY });
+  }
+  return out;
+}
+function ribbonOf(rows, i, nbrs, focal) {
+  const row = rows[i];
+  const rowPts = row.pts.length >= 2 ? [...row.pts] : row.pts.length === 1 ? (() => {
+    const p = row.pts[0];
+    let dx = p.x - focal.x, dy = p.y - focal.y;
+    const len = Math.hypot(dx, dy) || 1;
+    dx /= len;
+    dy /= len;
+    const h = Math.max(nbrs[i].pitch, 1e-3) * 0.5;
+    return [{ x: p.x + dy * h, y: p.y - dx * h }, { x: p.x - dy * h, y: p.y + dx * h }];
+  })() : [];
+  if (rowPts.length < 2) return null;
+  let seatSpan = 0, spanN = 0;
+  for (let k = 1; k < rowPts.length; k++) {
+    const d = Math.hypot(rowPts[k].x - rowPts[k - 1].x, rowPts[k].y - rowPts[k - 1].y);
+    if (d > 1e-6) {
+      seatSpan += d;
+      spanN++;
+    }
+  }
+  const spacing = spanN > 0 ? seatSpan / spanN : 0;
+  const pts = extendEnds(rowPts, Math.max(spacing * END_REACH, MIN_REACH_U));
+  return {
+    pts,
+    nrm: rowNormals(pts, focal),
+    front: Math.max(nbrs[i].pitch * FRONT_REACH, MIN_REACH_U),
+    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 = import_polygon_clipping2.default.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;
+function simplifyRun(pts, tol) {
+  if (pts.length < 3) return pts;
+  const a = pts[0], b = pts[pts.length - 1];
+  const dx = b.x - a.x, dy = b.y - a.y;
+  const len = Math.hypot(dx, dy);
+  let worst = -1, worstI = -1;
+  for (let i = 1; i < pts.length - 1; i++) {
+    const p = pts[i];
+    const d = len > 1e-12 ? Math.abs((p.x - a.x) * dy - (p.y - a.y) * dx) / len : Math.hypot(p.x - a.x, p.y - a.y);
+    if (d > worst) {
+      worst = d;
+      worstI = i;
+    }
+  }
+  if (worst <= tol || worstI < 0) return [a, b];
+  const left = simplifyRun(pts.slice(0, worstI + 1), tol);
+  const right = simplifyRun(pts.slice(worstI), tol);
+  return [...left.slice(0, -1), ...right];
+}
+function simplifyRing(ring, tol) {
+  if (ring.length < 4) return ring;
+  const out = simplifyRun([...ring, ring[0]], tol);
+  out.pop();
+  return out.length >= 3 ? out : ring;
+}
+function pointInRing(ring, x, y) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const a = ring[i], b = ring[j];
+    if (a.y > y !== b.y > y && x < (b.x - a.x) * (y - a.y) / (b.y - a.y) + a.x) inside = !inside;
+  }
+  return inside;
+}
+var ClipTest = class {
+  constructor(rings) {
+    this.minX = Infinity;
+    this.minY = Infinity;
+    this.maxX = -Infinity;
+    this.maxY = -Infinity;
+    this.rings = rings;
+    for (const r of rings) {
+      for (const p of r) {
+        if (p.x < this.minX) this.minX = p.x;
+        if (p.y < this.minY) this.minY = p.y;
+        if (p.x > this.maxX) this.maxX = p.x;
+        if (p.y > this.maxY) this.maxY = p.y;
+      }
+    }
+  }
+  /** True when every point lies strictly inside ONE ring of the clip region. */
+  containsAll(pts) {
+    for (const p of pts) {
+      if (p.x < this.minX || p.x > this.maxX || p.y < this.minY || p.y > this.maxY) return false;
+    }
+    for (const ring of this.rings) {
+      let all = true;
+      for (const p of pts) {
+        if (!pointInRing(ring, p.x, p.y)) {
+          all = false;
+          break;
+        }
+      }
+      if (all) return true;
+    }
+    return false;
+  }
+};
+function emitClippedQuad(builder, clipRing, clipTest, quad, y, color) {
+  if (clipTest.containsAll(quad)) {
+    const UPF = [0, 1, 0];
+    const a = quad[0], b = quad[1], c = quad[2], d = quad[3];
+    builder.tri([a.x * M, y, a.y * M], [b.x * M, y, b.y * M], [c.x * M, y, c.y * M], UPF, color);
+    builder.tri([a.x * M, y, a.y * M], [c.x * M, y, c.y * M], [d.x * M, y, d.y * M], UPF, color);
+    return;
+  }
+  const ring = quad.map((p) => [p.x, p.y]);
+  ring.push(ring[0]);
+  let pieces;
+  try {
+    pieces = import_polygon_clipping2.default.intersection([ring], clipRing);
+  } catch {
+    return;
+  }
+  const UP = [0, 1, 0];
+  for (const poly of pieces) {
+    if (!poly.length || poly[0].length < 4) continue;
+    const outer = poly[0];
+    const flat = [];
+    const pts = [];
+    for (let i = 0; i < outer.length - 1; i++) {
+      flat.push(outer[i][0], outer[i][1]);
+      pts.push([outer[i][0], outer[i][1]]);
+    }
+    if (pts.length < 3) continue;
+    const tris = (0, import_earcut2.default)(flat, void 0, 2);
+    for (let i = 0; i < tris.length; i += 3) {
+      const a = pts[tris[i]], b = pts[tris[i + 1]], c = pts[tris[i + 2]];
+      builder.tri(
+        [a[0] * M, y, a[1] * M],
+        [b[0] * M, y, b[1] * M],
+        [c[0] * M, y, c[1] * M],
+        UP,
+        color
+      );
+    }
+  }
+}
+function emitDeckBands(builder, rows, focal, landingY, colors, clip) {
+  if (rows.length < 2) return;
+  const nbrs = neighbourhoods(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;
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    const rib = ribbonOf(rows, i, nbrs, focal);
+    if (!rib) continue;
+    const { pts, nrm, front, back } = rib;
+    const belowY = nbrs[i].belowY ?? landingY;
+    for (let k = 0; k + 1 < pts.length; k++) {
+      const p = pts[k], q = pts[k + 1];
+      const np = nrm[k], nq = nrm[k + 1];
+      if (Math.hypot(q.x - p.x, q.y - p.y) < 1e-6) continue;
+      if (np[0] === 0 && np[1] === 0 || nq[0] === 0 && nq[1] === 0) continue;
+      const pF = [(p.x - np[0] * front) * M, row.y, (p.y - np[1] * front) * M];
+      const qF = [(q.x - nq[0] * front) * M, row.y, (q.y - nq[1] * front) * M];
+      const pB = [(p.x + np[0] * back) * M, row.y, (p.y + np[1] * back) * M];
+      const qB = [(q.x + nq[0] * back) * M, row.y, (q.y + nq[1] * back) * M];
+      if (clipRing && clipTest) {
+        emitClippedQuad(builder, clipRing, clipTest, [
+          { x: p.x - np[0] * front, y: p.y - np[1] * front },
+          { x: q.x - nq[0] * front, y: q.y - nq[1] * front },
+          { x: q.x + nq[0] * back, y: q.y + nq[1] * back },
+          { x: p.x + np[0] * back, y: p.y + np[1] * back }
+        ], row.y, colors.tread);
+      } else {
+        builder.tri(pF, qF, qB, UP, colors.tread);
+        builder.tri(pF, qB, pB, UP, colors.tread);
+      }
+      if (row.y > belowY + MIN_RISER_M) {
+        const pFd = [pF[0], belowY, pF[2]];
+        const qFd = [qF[0], belowY, qF[2]];
+        const rn = [-np[0], 0, -np[1]];
+        builder.tri(pF, qF, qFd, rn, colors.riser);
+        builder.tri(pF, qFd, pFd, rn, colors.riser);
+      }
+    }
+  }
+}
+
 // src/view3d/scene/sceneModel.ts
 function floorUnits(doc) {
   if (doc.floors?.length) {
@@ -692,8 +2207,6 @@ function floorUnits(doc) {
   return [{ objects: doc.objects, focal: doc.focalPoint, baseHeightM: 0 }];
 }
 var AO = { top: 1, wallBottom: 0.5, bottomCap: 0.4 };
-var DECK_DROP_M = 0.28;
-var MAX_TIER_RISE_M = 25;
 function tintTop(fill, neutral) {
   if (!fill) return neutral;
   const muted = scaleRgb(desaturate(fill, 0.4), 0.62);
@@ -730,31 +2243,229 @@ function resolveSectionFills(doc, seats) {
 function sectionFill(section, byLogical) {
   return hexToRgb(section.color) ?? byLogical.get(section.logicalSectionId ?? section.id) ?? null;
 }
-function buildTier(builder, section, unit, fill) {
+function bboxOfRing(ring) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of ring) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+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];
+  const toRing = (pts) => {
+    const r = pts.map((p) => [p.x, p.y]);
+    r.push(r[0]);
+    return r;
+  };
+  try {
+    const diff = import_polygon_clipping3.default.difference([toRing(padded)], ...others.map((o) => [toRing(o.outline)]));
+    const out = [];
+    for (const poly of diff) {
+      if (!poly.length) continue;
+      const pts = poly[0].map(([x, y]) => ({ x, y }));
+      if (pts.length > 1) {
+        const f = pts[0], l = pts[pts.length - 1];
+        if (Math.abs(f.x - l.x) < 1e-9 && Math.abs(f.y - l.y) < 1e-9) pts.pop();
+      }
+      if (pts.length >= 3) out.push(pts);
+    }
+    return out.length ? out : [padded];
+  } catch {
+    return [padded];
+  }
+}
+function clipFootprints(blocks, allowed) {
+  if (!allowed.length) return blocks;
+  const toRing = (pts) => {
+    const r = pts.map((p) => [p.x, p.y]);
+    r.push(r[0]);
+    return r;
+  };
+  const allowedPolys = allowed.map((a) => [toRing(a)]);
+  const out = [];
+  for (const b of blocks) {
+    let pieces;
+    try {
+      pieces = import_polygon_clipping3.default.intersection([toRing(b.outline)], ...[allowedPolys.flat()]);
+    } catch {
+      out.push(b);
+      continue;
+    }
+    for (const poly of pieces) {
+      if (!poly.length) continue;
+      const pts = poly[0].map(([x, y]) => ({ x, y }));
+      if (pts.length > 1) {
+        const f = pts[0], l = pts[pts.length - 1];
+        if (Math.abs(f.x - l.x) < 1e-9 && Math.abs(f.y - l.y) < 1e-9) pts.pop();
+      }
+      if (pts.length >= 3) out.push({ outline: pts, holes: [], topY: b.topY });
+    }
+  }
+  return out.length ? out : blocks;
+}
+function buildTier(builder, section, unit, fill, surface, claimed, siblings, S) {
   if (!section.outline || section.outline.length < 3) return;
-  const geo = sectionGeometry(section, { floorBaseHeightM: unit.baseHeightM });
   const bottomY = unit.baseHeightM;
-  const rakeRad = geo.rake * Math.PI / 180;
-  const flat = geo.rake <= 0.01 && geo.height <= bottomY + 1e-3;
-  const colTop = tintTop(fill, STRUCTURE.tierTop);
-  if (flat) {
-    const topY2 = bottomY + 0.05;
-    extrudePrism(builder, section.outline, section.holes, () => topY2, bottomY, colTop, STRUCTURE.tierWall, AO);
+  const colTop = tintTop(fill, S.tierTop);
+  if (!surface) return;
+  const topY = (p) => surface.deckAt(p.x, p.y);
+  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 capUp = () => [0, 1, 0];
+    for (const b of blocks) {
+      extrudePrism(
+        builder,
+        b.outline,
+        b.holes,
+        () => b.topY,
+        bottomY,
+        colTop,
+        S.tierWall,
+        AO,
+        void 0,
+        capUp
+      );
+    }
+    if (!blocks.length) {
+      extrudePrism(
+        builder,
+        outline,
+        section.holes,
+        () => surface.landingY,
+        bottomY,
+        colTop,
+        S.tierWall,
+        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);
     return;
   }
-  let frontDist = Infinity;
-  for (const p of section.outline) {
-    const d = Math.hypot(p.x - unit.focal.x, p.y - unit.focal.y);
-    if (d < frontDist) frontDist = d;
-  }
-  const tan = Math.tan(rakeRad);
-  const topY = (p) => {
-    const d = Math.hypot(p.x - unit.focal.x, p.y - unit.focal.y);
-    const depthM = Math.max(0, d - frontDist) * M;
-    const rise = Math.min(depthM * tan, MAX_TIER_RISE_M);
-    return Math.max(bottomY + 0.05, geo.height + rise - DECK_DROP_M);
-  };
-  extrudePrism(builder, section.outline, section.holes, topY, bottomY, colTop, STRUCTURE.tierWall, AO);
+  const maxErr = surface.flat ? Infinity : CAP_MAX_ERROR_M;
+  const topN = (p) => surface.normalAt(p.x, p.y);
+  for (const ring of claimed.subtract(outline)) {
+    extrudePrism(builder, ring, section.holes, topY, bottomY, colTop, S.tierWall, AO, maxErr, topN);
+  }
+}
+var ClaimedArea = class {
+  constructor() {
+    this.rings = [];
+    this.boxes = [];
+  }
+  /** `ring` minus everything claimed so far; then claim what is returned. */
+  subtract(ring) {
+    const closed = ring.map((p) => [p.x, p.y]);
+    if (closed.length < 3) return [];
+    closed.push(closed[0]);
+    const box = bboxOfRing(ring);
+    const overlapping = this.rings.filter((_, i) => boxesOverlap(box, this.boxes[i]));
+    let pieces = [[closed]];
+    if (overlapping.length) {
+      try {
+        const diff = import_polygon_clipping3.default.difference([closed], ...overlapping);
+        pieces = diff.map((poly) => poly.map((r) => r.map(([x, y]) => [x, y])));
+      } catch {
+        pieces = [[closed]];
+      }
+    }
+    this.rings.push([closed]);
+    this.boxes.push(box);
+    const out = [];
+    for (const poly of pieces) {
+      if (!poly.length) continue;
+      const pts = poly[0].map(([x, y]) => ({ x, y }));
+      if (pts.length > 1) {
+        const f = pts[0], l = pts[pts.length - 1];
+        if (Math.abs(f.x - l.x) < 1e-9 && Math.abs(f.y - l.y) < 1e-9) pts.pop();
+      }
+      if (pts.length >= 3) out.push(pts);
+    }
+    return out;
+  }
+};
+var BOOTH_HEIGHT_M = 2.4;
+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 TABLE_HEIGHT_M = 0.75;
+function boothPolygon(booth) {
+  if (booth.points && booth.points.length >= 3) return booth.points;
+  const { center, width, height, rotation } = booth;
+  if (!width || !height) return null;
+  const a = (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: center.x + lx * cos - ly * sin,
+    y: center.y + lx * sin + ly * cos
+  }));
+}
+function buildBooth(builder, booth, base, fill, S) {
+  const poly = boothPolygon(booth);
+  if (!poly) return;
+  extrudePrism(
+    builder,
+    poly,
+    void 0,
+    () => base + BOOTH_HEIGHT_M,
+    base,
+    tintTop(fill, S.boothTop),
+    S.boothWall,
+    AO
+  );
+}
+function tablePolygon(table) {
+  if (table.shape === "round") {
+    const r = table.radius;
+    if (!r) return null;
+    return ellipsePolygon(table.center.x, table.center.y, r, r, 24);
+  }
+  const { width, height, rotation, center } = table;
+  if (!width || !height) return null;
+  const a = (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: center.x + lx * cos - ly * sin,
+    y: center.y + lx * sin + ly * cos
+  }));
+}
+function buildTable(builder, table, base, fill, S) {
+  const poly = tablePolygon(table);
+  if (!poly) return;
+  extrudePrism(
+    builder,
+    poly,
+    void 0,
+    () => base + TABLE_HEIGHT_M,
+    base,
+    tintTop(fill, S.tableTop),
+    S.tableWall,
+    AO
+  );
 }
 function shapePolygon(shape) {
   if (shape.kind === "polygon" && shape.points && shape.points.length >= 3) return shape.points;
@@ -768,19 +2479,19 @@ function shapePolygon(shape) {
   }
   return null;
 }
-function buildShape(builder, shape, base) {
+function buildShape(builder, shape, base, S) {
   const poly = shapePolygon(shape);
   if (!poly) return;
   const isStage = shape.role === "stage";
   const height = isStage ? base + 1 : base + 0.25;
-  const colTop = isStage ? STRUCTURE.stageTop : STRUCTURE.decorTop;
-  const colWall = isStage ? STRUCTURE.stageWall : STRUCTURE.decorWall;
+  const colTop = isStage ? S.stageTop : S.decorTop;
+  const colWall = isStage ? S.stageWall : S.decorWall;
   extrudePrism(builder, poly, void 0, () => height, base, colTop, colWall, AO);
 }
-function buildGa(builder, ga, base, fill) {
+function buildGa(builder, ga, base, fill, S) {
   if (!ga.points || ga.points.length < 3) return;
-  const colTop = tintTop(fill, STRUCTURE.gaTop);
-  extrudePrism(builder, ga.points, ga.holes, () => base + 0.15, base, colTop, STRUCTURE.gaWall, AO);
+  const colTop = tintTop(fill, S.gaTop);
+  extrudePrism(builder, ga.points, ga.holes, () => base + 0.15, base, colTop, S.gaWall, AO);
 }
 function chartFootprint(units, seats) {
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
@@ -796,6 +2507,13 @@ function chartFootprint(units, seats) {
       if (o.type === "section") for (const p of o.outline) acc(p.x, p.y);
       else if (o.type === "shape" && o.points) for (const p of o.points) acc(p.x, p.y);
       else if (o.type === "gaArea") for (const p of o.points) acc(p.x, p.y);
+      else if (o.type === "booth") {
+        const b = boothPolygon(o);
+        if (b) for (const p of b) acc(p.x, p.y);
+      } else if (o.type === "table") {
+        const t = tablePolygon(o);
+        if (t) for (const p of t) acc(p.x, p.y);
+      }
     }
   }
   if (!Number.isFinite(minX)) {
@@ -806,41 +2524,318 @@ 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;
   const units = floorUnits(doc);
   const builder = new MeshBuilder();
   const fp = chartFootprint(units, seats);
   const padU = Math.max(60, (fp.maxX - fp.minX + fp.maxY - fp.minY) * 0.06);
   const groundPoly = rectPolygon(fp.minX - padU, fp.minY - padU, fp.maxX - fp.minX + padU * 2, fp.maxY - fp.minY + padU * 2);
-  extrudePrism(builder, groundPoly, void 0, () => 0, -0.4, STRUCTURE.ground, STRUCTURE.ground, AO);
+  extrudePrism(builder, groundPoly, void 0, () => 0, -0.4, S.ground, S.ground, AO);
   const sectionFills = resolveSectionFills(doc, seats);
   const catColor = /* @__PURE__ */ new Map();
   for (const c of doc.categories ?? []) catColor.set(c.key, c.color);
-  for (const unit of units) {
+  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];
+    builder.setFloor(unitIndex);
+    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") buildTier(builder, o, unit, sectionFill(o, sectionFills));
-      else if (o.type === "shape") buildShape(builder, o, unit.baseHeightM);
-      else if (o.type === "gaArea") buildGa(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)));
+      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);
+      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);
     }
   }
+  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()]);
-  const seatData = buildSeatInstances(seats, input.initialState);
+  __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) {
+    const sectionZone = /* @__PURE__ */ new Map();
+    for (const unit of units) {
+      for (const o of unit.objects) {
+        if (o.type === "section" && o.zone) sectionZone.set(o.id, o.zone);
+      }
+    }
+    const acc = /* @__PURE__ */ new Map();
+    for (let i = 0; i < seats.length; i++) {
+      const s = seats[i];
+      const owner = surfaces.seatOwner[i];
+      const zid = s.zoneId ?? (owner ? sectionZone.get(owner) : void 0);
+      if (!zid) continue;
+      let a = acc.get(zid);
+      if (!a) {
+        a = { n: 0, minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity, sumY: 0 };
+        acc.set(zid, a);
+      }
+      a.n++;
+      if (s.x < a.minX) a.minX = s.x;
+      if (s.y < a.minY) a.minY = s.y;
+      if (s.x > a.maxX) a.maxX = s.x;
+      if (s.y > a.maxY) a.maxY = s.y;
+      a.sumY += surfaces.seatDeckY(i);
+    }
+    for (const z of zoneDefs) {
+      const a = acc.get(z.id);
+      const sectionIds = [];
+      for (const [secId, zid] of sectionZone) if (zid === z.id) sectionIds.push(secId);
+      if (!a || a.n === 0) {
+        zones.push({
+          id: z.id,
+          label: z.label,
+          color: hexToRgb(z.color),
+          sectionIds,
+          seatCount: 0,
+          center: [0, 0, 0],
+          radius: 0,
+          focalWorld: [(z.focalPoint ?? focal).x * M, 1.5, (z.focalPoint ?? focal).y * M]
+        });
+        continue;
+      }
+      zones.push({
+        id: z.id,
+        label: z.label,
+        color: hexToRgb(z.color),
+        sectionIds,
+        seatCount: a.n,
+        center: [(a.minX + a.maxX) / 2 * M, a.sumY / a.n, (a.minY + a.maxY) / 2 * M],
+        radius: 0.5 * Math.hypot((a.maxX - a.minX) * M, (a.maxY - a.minY) * M) || 1,
+        // A zone may face its own point (`ZoneDef.focalPoint`); the documented
+        // fallback is the floor/chart focal.
+        focalWorld: [(z.focalPoint ?? focal).x * M, 1.5, (z.focalPoint ?? focal).y * M]
+      });
+    }
+  }
+  const labels = [];
+  for (const z of zones) {
+    if (z.seatCount === 0) continue;
+    labels.push({
+      id: `zone:${z.id}`,
+      kind: "zone",
+      text: z.label,
+      anchor: [z.center[0], z.center[1] + ZONE_LABEL_LIFT_M, z.center[2]],
+      color: doc.zones?.find((d) => d.id === z.id)?.color
+    });
+  }
+  {
+    const acc = /* @__PURE__ */ new Map();
+    for (let i = 0; i < seats.length; i++) {
+      const owner = surfaces.seatOwner[i];
+      if (!owner) continue;
+      let a = acc.get(owner);
+      if (!a) {
+        a = { n: 0, x: 0, y: 0, deck: 0 };
+        acc.set(owner, a);
+      }
+      a.n++;
+      a.x += seats[i].x;
+      a.y += seats[i].y;
+      a.deck += surfaces.seatDeckY(i);
+    }
+    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;
+        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]
+        });
+      }
+    }
+  }
+  for (const unit of units) {
+    for (const o of unit.objects) {
+      if (o.type === "text") {
+        if (!o.text) continue;
+        labels.push({
+          id: `text:${o.id}`,
+          kind: "annotation",
+          text: o.text,
+          anchor: [o.position.x * M, unit.baseHeightM + ANNOTATION_LIFT_M, o.position.y * M],
+          color: o.color,
+          rotation: o.rotation
+        });
+      } else if (o.type === "booth") {
+        const poly = boothPolygon(o);
+        if (!poly) continue;
+        const c = centroidOf(poly);
+        if (!c) continue;
+        labels.push({
+          id: `booth:${o.id}`,
+          kind: "booth",
+          text: o.displayLabel || o.label || o.id,
+          anchor: [c.x * M, unit.baseHeightM + BOOTH_HEIGHT_M + BOOTH_LABEL_LIFT_M, c.y * M]
+        });
+      }
+    }
+  }
+  const floors = [];
+  {
+    const sectionFloor = /* @__PURE__ */ new Map();
+    for (let ui = 0; ui < units.length; ui++) {
+      for (const o of units[ui].objects) if (o.type === "section") sectionFloor.set(o.id, ui);
+    }
+    const acc = units.map(() => ({ n: 0, minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity, sumY: 0 }));
+    for (let i = 0; i < seats.length; i++) {
+      const owner = surfaces.seatOwner[i];
+      const ui = owner !== null ? sectionFloor.get(owner) : void 0;
+      if (ui === void 0) continue;
+      const a = acc[ui];
+      const s = seats[i];
+      a.n++;
+      if (s.x < a.minX) a.minX = s.x;
+      if (s.y < a.minY) a.minY = s.y;
+      if (s.x > a.maxX) a.maxX = s.x;
+      if (s.y > a.maxY) a.maxY = s.y;
+      a.sumY += surfaces.seatDeckY(i);
+      seatFloor[i] = ui;
+    }
+    for (let ui = 0; ui < units.length; ui++) {
+      const a = acc[ui];
+      const f = doc.floors?.[ui];
+      floors.push({
+        index: ui,
+        id: f?.id ?? `floor-${ui}`,
+        label: f?.name ?? (units.length > 1 ? `Floor ${ui + 1}` : "Venue"),
+        seatCount: a.n,
+        center: a.n ? [(a.minX + a.maxX) / 2 * M, a.sumY / a.n, (a.minY + a.maxY) / 2 * M] : [0, 0, 0],
+        radius: a.n ? 0.5 * Math.hypot((a.maxX - a.minX) * M, (a.maxY - a.minY) * M) || 1 : 0
+      });
+    }
+  }
   const cx = (fp.minX + fp.maxX) / 2 * M;
   const cz = (fp.minY + fp.maxY) / 2 * M;
   const radius = 0.5 * Math.hypot((fp.maxX - fp.minX) * M, (fp.maxY - fp.minY) * M) || 10;
-  const focal = doc.focalPoint ?? { x: (fp.minX + fp.maxX) / 2, y: (fp.minY + fp.maxY) / 2 };
   return {
     solids,
     seats: seatData,
     bounds: { center: [cx, radius * 0.08, cz], radius, groundY: 0 },
-    stateColorLUT: seatStateColorLUT(),
+    stateColorLUT: themeSeatColorLUT(theme, SEAT_STATES),
+    theme,
     seatCount: seats.length,
     // 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]
+    focalWorld: [focal.x * M, 1.5, focal.y * M],
+    zones,
+    labels,
+    floors
   };
 }
 
+// src/view3d/labelOverlay.ts
+var SEPARATION_X_PX = 88;
+var SEPARATION_Y_PX = 20;
+var KIND_STYLE = {
+  zone: { size: 15, weight: "600", opacity: 0.95 },
+  section: { size: 12, weight: "500", opacity: 0.88 },
+  booth: { size: 11, weight: "500", opacity: 0.85 },
+  annotation: { size: 11, weight: "400", opacity: 0.75 }
+};
+var LabelOverlay = class {
+  constructor(container, opts = {}) {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.labels = [];
+    this.opts = opts;
+    this.root = document.createElement("div");
+    this.root.setAttribute("data-view3d-labels", "");
+    const s = this.root.style;
+    s.position = "absolute";
+    s.inset = "0";
+    s.pointerEvents = "none";
+    s.overflow = "hidden";
+    if (opts.fontFamily) s.fontFamily = opts.fontFamily;
+    container.appendChild(this.root);
+  }
+  setLabels(labels) {
+    this.labels = labels;
+    for (const [id, node] of this.nodes) {
+      if (!labels.some((l) => l.id === id)) {
+        node.remove();
+        this.nodes.delete(id);
+      }
+    }
+  }
+  /**
+   * Reposition every label for the current camera.
+   *
+   * `viewProjection` is column-major, as OGL supplies it.
+   */
+  update(viewProjection, width, height, cameraDistance, venueRadius) {
+    if (!this.labels.length) return;
+    const kinds = visibleLabelKinds(cameraDistance, venueRadius);
+    const candidates = [];
+    for (const label of this.labels) {
+      if (!kinds.has(label.kind)) continue;
+      const screen = projectToScreen(viewProjection, label.anchor, width, height);
+      if (!screen.visible) continue;
+      candidates.push({ label, screen });
+    }
+    const kept = cullOverlapping(candidates, SEPARATION_X_PX, SEPARATION_Y_PX);
+    const keptIds = new Set(kept.map((k) => k.label.id));
+    for (const { label, screen } of kept) {
+      const node = this.nodeFor(label);
+      const st = node.style;
+      st.display = "";
+      st.transform = `translate(-50%, -50%) translate(${screen.x.toFixed(1)}px, ${screen.y.toFixed(1)}px)`;
+    }
+    for (const [id, node] of this.nodes) {
+      if (!keptIds.has(id)) node.style.display = "none";
+    }
+  }
+  nodeFor(label) {
+    let node = this.nodes.get(label.id);
+    if (node) return node;
+    node = document.createElement("div");
+    node.textContent = label.text;
+    node.setAttribute("data-label-kind", label.kind);
+    const style = KIND_STYLE[label.kind];
+    const s = node.style;
+    s.position = "absolute";
+    s.left = "0";
+    s.top = "0";
+    s.whiteSpace = "nowrap";
+    s.fontSize = `${style.size}px`;
+    s.fontWeight = style.weight;
+    s.opacity = String(style.opacity);
+    s.color = label.color ?? this.opts.ink ?? "#e8edf5";
+    s.textShadow = "0 1px 3px rgba(0,0,0,0.85), 0 0 8px rgba(0,0,0,0.55)";
+    s.letterSpacing = label.kind === "zone" ? "0.08em" : "0.02em";
+    if (label.kind === "zone") s.textTransform = "uppercase";
+    s.display = "none";
+    this.root.appendChild(node);
+    this.nodes.set(label.id, node);
+    return node;
+  }
+  dispose() {
+    this.root.remove();
+    this.nodes.clear();
+  }
+};
+
 // src/view3d/scene/build.ts
 var import_ogl4 = require("ogl");
 
@@ -853,16 +2848,29 @@ precision highp float;
 in vec3 position;
 in vec3 normal;
 in vec3 color;
+in float floorIndex;
+uniform mat4 modelMatrix;
+uniform float uFocusFloor;   // -1 = show every floor
 uniform mat4 modelViewMatrix;
 uniform mat4 projectionMatrix;
 uniform mat3 normalMatrix;
 out vec3 vColor;
+out vec3 vNormalWorld;
 out vec3 vNormalView;
 out vec3 vPosView;
+out float vDim;
 void main() {
+  // Per-floor isolation without splitting the merged mesh into a draw call per
+  // floor: a floor that is not the focused one is dimmed, not hidden, so the
+  // buyer keeps the whole venue as context while looking at one level.
+  vDim = (uFocusFloor < -0.5 || abs(floorIndex - uFocusFloor) < 0.5) ? 0.0 : 1.0;
   vec4 mv = modelViewMatrix * vec4(position, 1.0);
   vPosView = mv.xyz;
   vNormalView = normalize(normalMatrix * normal);
+  // World normal drives the key + hemisphere so the lighting stays welded to the
+  // venue as the camera orbits (the scene has no non-uniform scale, so mat3 of
+  // the model matrix is the correct normal transform).
+  vNormalWorld = normalize(mat3(modelMatrix) * normal);
   vColor = color;
   gl_Position = projectionMatrix * mv;
 }`
@@ -872,18 +2880,26 @@ var SOLID_FRAG = (
   `#version 300 es
 precision highp float;
 in vec3 vColor;
+in vec3 vNormalWorld;
 in vec3 vNormalView;
 in vec3 vPosView;
+in float vDim;
+uniform vec3 uKeyDir;                           // WORLD space, unit, points at the light
 out vec4 fragColor;
 void main() {
-  vec3 N = normalize(vNormalView);
+  vec3 N = normalize(vNormalWorld);
   vec3 V = normalize(-vPosView);
-  float hemi = 0.5 + 0.5 * N.y;                 // sky/ground gradient
-  vec3 L = normalize(vec3(0.4, 0.85, 0.55));    // warm key, view space
-  float key = max(dot(N, L), 0.0);
-  vec3 base = vColor * (0.60 + 0.32 * hemi) + vColor * key * 0.32;
-  float fres = pow(1.0 - max(dot(N, V), 0.0), 3.0);
-  base += vec3(0.26, 0.31, 0.38) * fres * 0.35; // cool rim, restrained
+  float hemi = 0.5 + 0.5 * N.y;                 // sky/ground gradient about WORLD up
+  float key = max(dot(N, uKeyDir), 0.0);        // fixed key \u2014 does not orbit with you
+  // Low opposite fill so faces turned away from the key keep their form instead
+  // of crushing to a single flat value.
+  vec3 fillDir = normalize(vec3(-uKeyDir.x, 0.25, -uKeyDir.z));
+  float fill = max(dot(N, fillDir), 0.0);
+  vec3 base = vColor * (0.52 + 0.34 * hemi) + vColor * key * 0.34 + vColor * fill * 0.10;
+  float fres = pow(1.0 - max(dot(normalize(vNormalView), V), 0.0), 3.0);
+  base += vec3(0.26, 0.31, 0.38) * fres * 0.35; // cool rim, restrained (view-dependent by design)
+  // Unfocused floors fall back toward the background rather than vanishing.
+  base = mix(base, base * 0.45, vDim);
   fragColor = vec4(base, 1.0);
 }`
 );
@@ -894,22 +2910,45 @@ precision highp float;
 in vec2 position;      // quad corner in [-1,1]
 in vec3 iOffset;       // per-instance world position
 in vec3 iColor;        // per-instance state colour (resolved CPU-side)
+in float iMaxRadius;   // per-instance world-radius ceiling (seat pitch derived)
+in vec3 iRing;         // accommodation ring colour; (0,0,0) = not accessible
+in float iFloor;       // owning floor index
 uniform mat4 modelViewMatrix;
 uniform mat4 projectionMatrix;
 uniform float uSeatRadius;
 uniform float uSeatScale;
 uniform float uMinPixels;
 uniform float uPixelToWorld;   // (2*tan(fovY/2)) / viewportHeightPx
+uniform float uFocusFloor;     // -1 = show every floor
 out vec2 vUv;
 out vec3 vColor;
+out float vBudget;     // 1 = dot holds its minimum pixel size, <1 = it cannot
+out vec3 vRing;
+out float vDim;
 void main() {
   vec4 mv = modelViewMatrix * vec4(iOffset, 1.0);
   float depth = max(-mv.z, 0.001);
   float minR = uMinPixels * depth * uPixelToWorld;      // screen-space floor
-  float r = max(uSeatRadius * uSeatScale, minR);
+  // Grow to hold the pixel floor, but never past this seat's own pitch ceiling:
+  // unbounded growth is what merges neighbouring rows into one mass at range.
+  float r = min(max(uSeatRadius * uSeatScale, minR), iMaxRadius);
+  // How much of the requested pixel floor the dot could actually afford. Below 1
+  // it is losing legibility to distance, and the fragment stage dissolves it
+  // toward the tier top rather than letting a sub-pixel dot alias and shimmer.
+  vBudget = minR > 0.0 ? clamp(r / minR, 0.0, 1.0) : 1.0;
   mv.xy += position * r;                                 // camera-facing billboard
+  // Seat the dot ON the deck instead of centring it in the deck. iOffset is the
+  // exact surface point, so half the billboard would otherwise sit below the cap
+  // and be clipped by it \u2014 and because uMinPixels grows r with distance, no
+  // constant world-space lift can prevent that at every range. Offsetting by r
+  // along the screen projection of WORLD up is self-correcting: it is full at a
+  // grazing view (where slicing happens) and vanishes looking straight down
+  // (where the dot must stay centred on its seat).
+  mv.xy += normalize(vec3(modelViewMatrix * vec4(0.0, 1.0, 0.0, 0.0))).xy * r;
   vUv = position;
   vColor = iColor;
+  vRing = iRing;
+  vDim = (uFocusFloor < -0.5 || abs(iFloor - uFocusFloor) < 0.5) ? 0.0 : 1.0;
   gl_Position = projectionMatrix * mv;
 }`
 );
@@ -919,6 +2958,9 @@ var SEAT_FRAG = (
 precision highp float;
 in vec2 vUv;
 in vec3 vColor;
+in float vBudget;
+in vec3 vRing;
+in float vDim;
 uniform float uSeatFade;      // fade toward tier colour with distance (LOD)
 uniform vec3 uFadeColor;
 out vec4 fragColor;
@@ -929,6 +2971,20 @@ void main() {
   float shade = 0.80 + 0.28 * (0.5 - vUv.y * 0.5);       // subtle top-lit
   vec3 c = vColor * shade;
   c = mix(c, uFadeColor, uSeatFade);
+  // Accommodation ring \u2014 the 3D echo of the coloured ring 2D draws around every
+  // accessible seat. Painted INSIDE the dot's own radius rather than outside it,
+  // so an accessible seat still respects the row-pitch ceiling and cannot grow
+  // into its neighbour just for carrying a ring.
+  float ringMask = step(0.001, dot(vRing, vRing));
+  float ring = smoothstep(0.58, 0.70, d) * (1.0 - smoothstep(0.90, 1.0, d));
+  c = mix(c, vRing, ring * ringMask * 0.95);
+  // A dot that can no longer afford its pixel floor dissolves instead of
+  // aliasing; the tier cap underneath already carries the section's category
+  // tint, so the block reads as coloured seating rather than empty concrete.
+  alpha *= smoothstep(0.35, 1.0, vBudget);
+  // Seats on an unfocused floor recede with their structure.
+  c = mix(c, uFadeColor, vDim * 0.75);
+  alpha *= mix(1.0, 0.30, vDim);
   fragColor = vec4(c, alpha);
 }`
 );
@@ -964,6 +3020,7 @@ var SEAT_PICK_VERT = (
 precision highp float;
 in vec2 position;
 in vec3 iOffset;
+in float iMaxRadius;
 uniform mat4 modelViewMatrix;
 uniform mat4 projectionMatrix;
 uniform float uSeatRadius;
@@ -978,8 +3035,10 @@ void main() {
   vec4 mv = modelViewMatrix * vec4(iOffset, 1.0);
   float depth = max(-mv.z, 0.001);
   float minR = uMinPixels * depth * uPixelToWorld;
-  float r = max(uSeatRadius * uSeatScale, minR);
+  float r = min(max(uSeatRadius * uSeatScale, minR), iMaxRadius);
   mv.xy += position * r;
+  // Must match SEAT_VERT exactly, or the hit mask drifts off the drawn dot.
+  mv.xy += normalize(vec3(modelViewMatrix * vec4(0.0, 1.0, 0.0, 0.0))).xy * r;
   vUv = position;
   gl_Position = projectionMatrix * mv;
 }`
@@ -1023,7 +3082,7 @@ function createSeatPickProgram(gl) {
     depthWrite: true,
     cullFace: false,
     uniforms: {
-      uSeatRadius: { value: 0.22 },
+      uSeatRadius: { value: SEAT_DOT_RADIUS_M },
       uSeatScale: { value: 1 },
       uMinPixels: { value: 2.5 },
       uPixelToWorld: { value: 2e-3 }
@@ -1050,7 +3109,13 @@ function createSolidProgram(gl) {
     fragment: SOLID_FRAG,
     cullFace: false,
     depthTest: true,
-    depthWrite: true
+    depthWrite: true,
+    uniforms: {
+      // High and off-axis, in world space: reads as a house rig rather than a
+      // headlamp welded to the camera.
+      uKeyDir: { value: new Float32Array([0.38, 0.86, 0.34]) },
+      uFocusFloor: { value: -1 }
+    }
   });
 }
 function createSeatProgram(gl) {
@@ -1062,11 +3127,12 @@ function createSeatProgram(gl) {
     depthWrite: false,
     cullFace: false,
     uniforms: {
-      uSeatRadius: { value: 0.22 },
+      uSeatRadius: { value: SEAT_DOT_RADIUS_M },
       uSeatScale: { value: 1 },
       uMinPixels: { value: 2.5 },
       uPixelToWorld: { value: 2e-3 },
       uSeatFade: { value: 0 },
+      uFocusFloor: { value: -1 },
       uFadeColor: { value: new Float32Array([0.32, 0.37, 0.43]) }
     }
   });
@@ -1086,9 +3152,9 @@ function createBackgroundProgram(gl, top, bottom) {
 }
 
 // src/view3d/scene/build.ts
-function writeSeatColors(iColor, iState, start, count) {
+function writeSeatColors(iColor, iState, start, count, states) {
   for (let i = start; i < start + count; i++) {
-    const c = seatStateColorByIndex(iState[i]);
+    const c = states[iState[i]] ?? states[0];
     iColor[i * 3] = c[0];
     iColor[i * 3 + 1] = c[1];
     iColor[i * 3 + 2] = c[2];
@@ -1100,14 +3166,15 @@ function buildGpuScene(gl, model) {
   const main = new import_ogl4.Transform();
   const background = new import_ogl4.Transform();
   const bgGeo = new import_ogl4.Geometry(gl, { position: { size: 2, data: BG_TRI } });
-  const bgProg = createBackgroundProgram(gl, BACKGROUND.top, BACKGROUND.bottom);
+  const bgProg = createBackgroundProgram(gl, model.theme.background.top, model.theme.background.bottom);
   const bgMesh = new import_ogl4.Mesh(gl, { geometry: bgGeo, program: bgProg });
   bgMesh.frustumCulled = false;
   bgMesh.setParent(background);
   const solidGeo = new import_ogl4.Geometry(gl, {
     position: { size: 3, data: model.solids.position },
     normal: { size: 3, data: model.solids.normal },
-    color: { size: 3, data: model.solids.color }
+    color: { size: 3, data: model.solids.color },
+    floorIndex: { size: 1, data: model.solids.floor }
   });
   const solidProg = createSolidProgram(gl);
   const solidMesh = new import_ogl4.Mesh(gl, { geometry: solidGeo, program: solidProg });
@@ -1115,11 +3182,18 @@ function buildGpuScene(gl, model) {
   solidMesh.setParent(main);
   const seatProg = createSeatProgram(gl);
   const iColor = new Float32Array(model.seats.count * 3);
-  writeSeatColors(iColor, model.seats.iState, 0, model.seats.count);
+  const stateColors = SEAT_STATES.map((st) => model.theme.seatStates[st]);
+  writeSeatColors(iColor, model.seats.iState, 0, model.seats.count, stateColors);
   const seatGeo = new import_ogl4.Geometry(gl, {
     position: { size: 2, data: SEAT_QUAD },
     iOffset: { size: 3, data: model.seats.iPosition, instanced: 1 },
-    iColor: { size: 3, data: iColor, instanced: 1 }
+    iColor: { size: 3, data: iColor, instanced: 1 },
+    // Per-seat world-radius ceiling: what stops distant rows merging into one
+    // mass when the shader grows a dot to hold its minimum pixel size.
+    iMaxRadius: { size: 1, data: model.seats.iMaxRadius, instanced: 1 },
+    // Accommodation ring colour; (0,0,0) means the seat carries no access type.
+    iRing: { size: 3, data: model.seats.iRing, instanced: 1 },
+    iFloor: { size: 1, data: model.seats.iFloor, instanced: 1 }
   });
   const seatMesh = new import_ogl4.Mesh(gl, { geometry: seatGeo, program: seatProg });
   seatMesh.frustumCulled = false;
@@ -1129,12 +3203,13 @@ function buildGpuScene(gl, model) {
     main,
     background,
     seatProgram: seatProg,
+    solidProgram: solidProg,
     seatGeometry: seatGeo,
     solidGeometry: solidGeo,
     drawCalls: 3,
     uploadSeatStateRuns(runs) {
       if (!runs.length) return;
-      for (const run of runs) writeSeatColors(iColor, model.seats.iState, run.start, run.length);
+      for (const run of runs) writeSeatColors(iColor, model.seats.iState, run.start, run.length, stateColors);
       const buffer = colorAttr.buffer;
       if (!buffer) {
         colorAttr.needsUpdate = true;
@@ -1202,6 +3277,8 @@ var PickPipeline = class {
     this.seatScene = new import_ogl5.Transform();
     this.solidScene = new import_ogl5.Transform();
     this.target = null;
+    /** Display clear colour to restore after the pick pass (theme-dependent). */
+    this.restoreClear = [0, 0, 0];
     this.renderer = renderer;
     this.gl = renderer.gl;
     this.maxIndex = seatCount;
@@ -1214,6 +3291,10 @@ var PickPipeline = class {
     solidMesh.frustumCulled = false;
     solidMesh.setParent(this.solidScene);
   }
+  /** Follow the theme's background when the scene is (re)built. */
+  setRestoreClear(rgb) {
+    this.restoreClear = [rgb[0], rgb[1], rgb[2]];
+  }
   /** Match the display seat sizing so the pick mask lines up with the dots. */
   syncFromSeatProgram(seatProgram) {
     for (const k of SYNC_KEYS) this.seatProg.uniforms[k].value = seatProgram.uniforms[k].value;
@@ -1254,7 +3335,7 @@ var PickPipeline = class {
     const boxH = Math.max(1, Math.min(bh, py + radius + 1) - y0);
     gl.enable(gl.SCISSOR_TEST);
     gl.scissor(x0, y0, boxW, boxH);
-    const [br, bg, bb] = BACKGROUND.top;
+    const [br, bg, bb] = this.restoreClear;
     gl.clearColor(0, 0, 0, 1);
     this.renderer.render({ scene: this.solidScene, camera, target, clear: true });
     this.renderer.render({ scene: this.seatScene, camera, target, clear: false });
@@ -1682,7 +3763,7 @@ var Analytics3D = class {
 
 // src/view3d/index.ts
 var SEAT_EYE_ABOVE_DECK = 1.02;
-var DEG2 = Math.PI / 180;
+var DEG3 = Math.PI / 180;
 var TAP_SLOP = 6;
 var TAP_MS = 500;
 function mountVenue3D(container, input, opts = {}) {
@@ -1707,9 +3788,15 @@ function mountVenue3D(container, input, opts = {}) {
   const prefetch = /* @__PURE__ */ new Map();
   let flightGen = 0;
   let reducedForced = null;
+  let focusedFloor = -1;
   const rebuildGpu = () => {
     gpu = buildGpuScene(glctx.gl, model);
     pick = new PickPipeline(glctx.renderer, gpu.seatGeometry, gpu.solidGeometry, model.seats.count);
+    glctx.setClearColor(model.theme.background.top);
+    pick.setRestoreClear(model.theme.background.top);
+    gpu.seatProgram.uniforms.uSeatRadius.value = SEAT_DOT_RADIUS_M * model.theme.seatScale;
+    gpu.seatProgram.uniforms.uFocusFloor.value = focusedFloor;
+    gpu.solidProgram.uniforms.uFocusFloor.value = focusedFloor;
   };
   const glctx = new GLContext(container, {
     onContextLost: () => {
@@ -1732,8 +3819,21 @@ function mountVenue3D(container, input, opts = {}) {
     // first real drag/wheel/pinch (not the intro ease)
   );
   orbit.setAspect(glctx.aspect);
-  orbit.frame(model.bounds, true);
+  const stageAzimuth = (() => {
+    const dx = model.focalWorld[0] - model.bounds.center[0];
+    const dz = model.focalWorld[2] - model.bounds.center[2];
+    return Math.hypot(dx, dz) > model.bounds.radius * 0.12 ? Math.atan2(dx, dz) : void 0;
+  })();
+  orbit.frame(model.bounds, true, stageAzimuth);
   const cinematic = new Cinematic(orbit.camera);
+  if (!container.style.position || container.style.position === "static") {
+    container.style.position = "relative";
+  }
+  const labelOverlay = new LabelOverlay(container, {
+    fontFamily: input.doc.theme?.fontFamily,
+    ink: input.doc.theme?.textColor
+  });
+  labelOverlay.setLabels(model.labels);
   rebuildGpu();
   const loop = new RenderLoop(() => {
     if (contextLost || !gpu || frozen) return false;
@@ -1743,9 +3843,16 @@ function mountVenue3D(container, input, opts = {}) {
     const u = gpu.seatProgram.uniforms;
     u.uSeatScale.value = lod.scale;
     u.uSeatFade.value = lod.fade;
-    u.uPixelToWorld.value = 2 * Math.tan(orbit.camera.fov * DEG2 / 2) / Math.max(1, glctx.pixelHeight);
+    u.uPixelToWorld.value = 2 * Math.tan(orbit.camera.fov * DEG3 / 2) / Math.max(1, glctx.pixelHeight);
     glctx.renderer.render({ scene: gpu.background, clear: true });
     glctx.renderer.render({ scene: gpu.main, camera: orbit.camera, clear: false });
+    labelOverlay.update(
+      orbit.camera.projectionViewMatrix,
+      glctx.canvas.clientWidth || 1,
+      glctx.canvas.clientHeight || 1,
+      orbit.currentDistance,
+      model.bounds.radius
+    );
     return moving;
   });
   const ro = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => handle.resize()) : null;
@@ -1793,6 +3900,72 @@ function mountVenue3D(container, input, opts = {}) {
     orbit.camera.fov = FOV_END;
     orbit.camera.updateProjectionMatrix();
   };
+  let arriveChip = null;
+  const removeArriveChip = () => {
+    arriveChip?.remove();
+    arriveChip = null;
+  };
+  const showArriveChip = (seatId, gen) => {
+    removeArriveChip();
+    if (disposed || !opts.getSeatView) return;
+    const chip = document.createElement("button");
+    chip.type = "button";
+    chip.textContent = "\u25C9 View in 360\xB0";
+    chip.setAttribute("aria-label", `Open the 360\xB0 view from seat ${seatId}`);
+    Object.assign(chip.style, {
+      position: "absolute",
+      left: "50%",
+      bottom: "18px",
+      transform: "translateX(-50%)",
+      minHeight: "44px",
+      padding: "10px 18px",
+      borderRadius: "999px",
+      background: "rgba(12,18,32,0.78)",
+      color: "#eef1f8",
+      border: "1px solid rgba(150,165,205,0.4)",
+      backdropFilter: "blur(6px)",
+      font: "600 13px/1 inherit",
+      cursor: "pointer",
+      zIndex: "4"
+    });
+    chip.addEventListener("click", () => {
+      if (disposed || gen !== flightGen) {
+        removeArriveChip();
+        return;
+      }
+      removeArriveChip();
+      void openPanorama(seatId, 400, gen);
+    });
+    container.appendChild(chip);
+    arriveChip = chip;
+  };
+  const overviewChip = document.createElement("button");
+  overviewChip.type = "button";
+  overviewChip.textContent = "\u2302 Overview";
+  overviewChip.setAttribute("aria-label", "Return to the venue overview");
+  Object.assign(overviewChip.style, {
+    position: "absolute",
+    right: "14px",
+    bottom: "18px",
+    minHeight: "40px",
+    padding: "8px 14px",
+    borderRadius: "999px",
+    background: "rgba(12,18,32,0.72)",
+    color: "#c9d4ea",
+    border: "1px solid rgba(150,165,205,0.35)",
+    backdropFilter: "blur(6px)",
+    font: "600 12.5px/1 inherit",
+    cursor: "pointer",
+    zIndex: "4"
+  });
+  overviewChip.addEventListener("click", () => {
+    if (disposed || frozen) return;
+    cancelFlight();
+    removeArriveChip();
+    orbit.frameSoft(model.bounds, stageAzimuth);
+    loop.requestRender();
+  });
+  container.appendChild(overviewChip);
   const openPanorama = async (seatId, fadeMs, gen) => {
     const viewPromise = ensureSeatView(seatId);
     if (!viewPromise) {
@@ -1813,6 +3986,7 @@ function mountVenue3D(container, input, opts = {}) {
       return;
     }
     if (disposed || gen !== flightGen) return;
+    removeArriveChip();
     panorama = mountPanorama(container, view, {
       fadeMs,
       seatLabel: seatId,
@@ -1822,6 +3996,7 @@ function mountVenue3D(container, input, opts = {}) {
         analytics.panoramaClosed();
         orbit.resumeAfterFlight(model.focalWorld);
         loop.requestRender();
+        showArriveChip(seatId, flightGen);
       }
     });
     analytics.panoramaOpened();
@@ -1843,6 +4018,7 @@ function mountVenue3D(container, input, opts = {}) {
     }
     frozen = false;
     const gen = ++flightGen;
+    removeArriveChip();
     const seatEye = seatEyeWorld(idx);
     const focal = model.focalWorld;
     const start = [orbit.camera.position.x, orbit.camera.position.y, orbit.camera.position.z];
@@ -1851,9 +4027,9 @@ function mountVenue3D(container, input, opts = {}) {
       placeCameraFinal(finalPos, focal);
       loop.requestRender();
       analytics.cinematicSkipped();
-      return openPanorama(seatId, 300, gen).then(() => {
-        if (!disposed) orbit.syncFromCamera();
-      });
+      if (!disposed) orbit.syncFromCamera();
+      showArriveChip(seatId, gen);
+      return Promise.resolve();
     }
     const startQuat = new import_ogl7.Quat().copy(orbit.camera.quaternion);
     const endQuat = lookAtQuat(orbit.camera, finalPos, focal);
@@ -1861,7 +4037,9 @@ function mountVenue3D(container, input, opts = {}) {
     return cinematic.start(waypoints, startQuat, endQuat).then(() => {
       if (disposed || gen !== flightGen) return;
       analytics.cinematicPlayed(FLIGHT_DURATION_MS);
-      return openPanorama(seatId, 400, gen);
+      orbit.resumeAfterFlight(model.focalWorld);
+      loop.requestRender();
+      showArriveChip(seatId, gen);
     });
   };
   let downX = 0, downY = 0, downT = 0, downId = -1, moved = false, suppressTap = false;
@@ -1937,13 +4115,51 @@ function mountVenue3D(container, input, opts = {}) {
     loseContextForTest() {
       glctx.simulateContextLossCycle();
     },
+    floors() {
+      return model.floors;
+    },
+    focusFloor(index) {
+      if (index !== null && !model.floors.some((f) => f.index === index)) return false;
+      const value = index ?? -1;
+      if (gpu) {
+        gpu.seatProgram.uniforms.uFocusFloor.value = value;
+        gpu.solidProgram.uniforms.uFocusFloor.value = value;
+      }
+      focusedFloor = value;
+      if (index !== null) {
+        const f = model.floors[index];
+        if (f.seatCount > 0) {
+          cinematic.cancel();
+          orbit.frame({ center: f.center, radius: f.radius * 1.25 });
+        }
+      }
+      loop.requestRender();
+      return true;
+    },
+    zones() {
+      return model.zones;
+    },
+    focusZone(zoneId) {
+      const zone = model.zones.find((z) => z.id === zoneId);
+      if (!zone || zone.seatCount === 0) return false;
+      cinematic.cancel();
+      const dx = zone.focalWorld[0] - zone.center[0];
+      const dz = zone.focalWorld[2] - zone.center[2];
+      const azimuth = Math.hypot(dx, dz) > zone.radius * 0.12 ? Math.atan2(dx, dz) : void 0;
+      orbit.frame({ center: zone.center, radius: zone.radius * 1.25 }, false, azimuth);
+      loop.requestRender();
+      return true;
+    },
     setReducedMotionForTest(value) {
       reducedForced = value;
     },
     dispose() {
       disposed = true;
+      removeArriveChip();
+      overviewChip.remove();
       cancelFlight();
       loop.stop();
+      labelOverlay.dispose();
       ro?.disconnect();
       if (panorama) {
         panorama.dispose();