@seatlayer/core 0.30.1 → 0.32.0

package/dist/view3d/index.cjs

@@ -207,10 +207,18 @@ var OrbitCamera = class {
     this.maxDist = 100;
     this.gestureFired = false;
     this.dragging = false;
+    this.panning = false;
     this.lastX = 0;
     this.lastY = 0;
     this.activePointers = /* @__PURE__ */ new Map();
     this.pinchDist = 0;
+    this.pinchCx = 0;
+    this.pinchCy = 0;
+    /** Damped pan pivot. `target` chases this the way azimuth chases `azT`. */
+    this.targetT = new import_ogl2.Vec3();
+    /** Venue centre + radius, so pan can be clamped to somewhere still useful. */
+    this.panAnchor = new import_ogl2.Vec3();
+    this.panLimit = 0;
     this.camera = new import_ogl2.Camera(gl, { fov: FOV, near: 0.1, far: 5e3, aspect: 1 });
     this.canvas = canvas;
     this.requestRender = requestRender;
@@ -222,12 +230,17 @@ var OrbitCamera = class {
       }
       this.activePointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
       if (this.activePointers.size === 1) {
-        this.dragging = true;
+        this.panning = e.button === 2 || e.button === 1 || e.shiftKey;
+        this.dragging = !this.panning;
         this.lastX = e.clientX;
         this.lastY = e.clientY;
       } else if (this.activePointers.size === 2) {
         this.dragging = false;
+        this.panning = false;
         this.pinchDist = this.currentPinchDistance();
+        const c = this.pinchCentroid();
+        this.pinchCx = c.x;
+        this.pinchCy = c.y;
       }
     };
     this.onPointerMove = (e) => {
@@ -240,11 +253,24 @@ var OrbitCamera = class {
           this.fireGesture();
         }
         this.pinchDist = d;
+        const c = this.pinchCentroid();
+        this.panBy(c.x - this.pinchCx, c.y - this.pinchCy);
+        this.pinchCx = c.x;
+        this.pinchCy = c.y;
         return;
       }
-      if (!this.dragging) return;
       const dx = e.clientX - this.lastX;
       const dy = e.clientY - this.lastY;
+      if (this.panning) {
+        this.lastX = e.clientX;
+        this.lastY = e.clientY;
+        if (dx !== 0 || dy !== 0) {
+          this.panBy(dx, dy);
+          this.fireGesture();
+        }
+        return;
+      }
+      if (!this.dragging) return;
       this.lastX = e.clientX;
       this.lastY = e.clientY;
       if (dx !== 0 || dy !== 0) this.fireGesture();
@@ -259,7 +285,13 @@ var OrbitCamera = class {
       } catch {
       }
       if (this.activePointers.size < 2) this.pinchDist = 0;
-      if (this.activePointers.size === 0) this.dragging = false;
+      if (this.activePointers.size === 0) {
+        this.dragging = false;
+        this.panning = false;
+      }
+    };
+    this.onContextMenu = (e) => {
+      e.preventDefault();
     };
     this.onWheel = (e) => {
       e.preventDefault();
@@ -273,6 +305,55 @@ var OrbitCamera = class {
     canvas.addEventListener("pointerup", this.onPointerUp);
     canvas.addEventListener("pointercancel", this.onPointerUp);
     canvas.addEventListener("wheel", this.onWheel, { passive: false });
+    canvas.addEventListener("contextmenu", this.onContextMenu);
+  }
+  pinchCentroid() {
+    const pts = [...this.activePointers.values()];
+    if (!pts.length) return { x: 0, y: 0 };
+    let x = 0;
+    let y = 0;
+    for (const p of pts) {
+      x += p.x;
+      y += p.y;
+    }
+    return { x: x / pts.length, y: y / pts.length };
+  }
+  /**
+   * Slide the orbit pivot across the camera's own screen plane.
+   *
+   * Scaled by distance and FOV so a pixel of drag moves the same amount of VENUE
+   * under the cursor whatever the zoom: at the overview a drag sweeps the whole
+   * bowl, and pushed in among the seats it nudges. A fixed world-units-per-pixel
+   * would be unusable at one end or the other.
+   */
+  panBy(dxPx, dyPx) {
+    const h = this.canvas.clientHeight || 1;
+    const perPx = 2 * this.distance * Math.tan(this.fovY * DEG / 2) / h;
+    const sinA = Math.sin(this.azimuth);
+    const cosA = Math.cos(this.azimuth);
+    const rightX = cosA;
+    const rightZ = -sinA;
+    const cp = Math.cos(this.polar);
+    const sp = Math.sin(this.polar);
+    const fwdX = -sinA * cp;
+    const fwdZ = -cosA * cp;
+    this.targetT.x += (-dxPx * rightX + dyPx * fwdX) * perPx;
+    this.targetT.z += (-dxPx * rightZ + dyPx * fwdZ) * perPx;
+    this.targetT.y += dyPx * sp * perPx;
+    this.clampPan();
+    this.requestRender();
+  }
+  /** Keep the pivot within a bounds-derived box so a stray drag cannot lose the
+   *  venue entirely — the Overview chip should never be the only way back. */
+  clampPan() {
+    if (this.panLimit <= 0) return;
+    const lim = this.panLimit;
+    const cx = this.panAnchor.x;
+    const cy = this.panAnchor.y;
+    const cz = this.panAnchor.z;
+    this.targetT.x = Math.max(cx - lim, Math.min(cx + lim, this.targetT.x));
+    this.targetT.z = Math.max(cz - lim, Math.min(cz + lim, this.targetT.z));
+    this.targetT.y = Math.max(cy - lim * 0.5, Math.min(cy + lim, this.targetT.y));
   }
   /** One-shot: notify the first real user gesture (drives 3d_orbit_engaged). */
   fireGesture() {
@@ -299,6 +380,9 @@ var OrbitCamera = class {
    */
   frame(bounds, intro = false, stageAzimuth) {
     this.target.set(bounds.center[0], bounds.center[1], bounds.center[2]);
+    this.targetT.copy(this.target);
+    this.panAnchor.copy(this.target);
+    this.panLimit = Math.max(1, bounds.radius) * 1.5;
     const r = Math.max(1, bounds.radius);
     const halfV = this.fovY * DEG / 2;
     const aspect = this.camera.aspect || 1;
@@ -330,6 +414,9 @@ var OrbitCamera = class {
    */
   frameSoft(bounds, stageAzimuth) {
     this.target.set(bounds.center[0], bounds.center[1], bounds.center[2]);
+    this.targetT.copy(this.target);
+    this.panAnchor.copy(this.target);
+    this.panLimit = Math.max(1, bounds.radius) * 1.5;
     this.syncFromCamera();
     this.camera.perspective({ fov: this.fovY, aspect: this.camera.aspect });
     const r = Math.max(1, bounds.radius);
@@ -346,10 +433,17 @@ var OrbitCamera = class {
     const da = this.azT - this.azimuth;
     const dp = this.polT - this.polar;
     const dd = this.distT - this.distance;
-    const moving = Math.abs(da) > 1e-4 || Math.abs(dp) > 1e-4 || Math.abs(dd) > 1e-4;
+    const tx = this.targetT.x - this.target.x;
+    const ty = this.targetT.y - this.target.y;
+    const tz = this.targetT.z - this.target.z;
+    const panEps = Math.max(1e-4, this.distance * 1e-4);
+    const moving = Math.abs(da) > 1e-4 || Math.abs(dp) > 1e-4 || Math.abs(dd) > 1e-4 || Math.abs(tx) > panEps || Math.abs(ty) > panEps || Math.abs(tz) > panEps;
     this.azimuth += da * DAMP;
     this.polar += dp * DAMP;
     this.distance += dd * DAMP;
+    this.target.x += tx * DAMP;
+    this.target.y += ty * DAMP;
+    this.target.z += tz * DAMP;
     if (moving) this.applyPosition();
     return moving;
   }
@@ -375,6 +469,7 @@ var OrbitCamera = class {
   /** Point the orbit pivot at a new world target without moving the camera. */
   setTarget(target) {
     this.target.set(target[0], target[1], target[2]);
+    this.targetT.copy(this.target);
   }
   /** Restore the base FOV (a flight ends pushed-in) and re-sync orbit state. A
    * flight ends looking at `target` (the venue focal), so re-pivot there first —
@@ -382,6 +477,7 @@ var OrbitCamera = class {
   resumeAfterFlight(target) {
     this.camera.perspective({ fov: this.fovY, aspect: this.camera.aspect });
     if (target) this.target.set(target[0], target[1], target[2]);
+    this.targetT.copy(this.target);
     this.syncFromCamera();
   }
   applyPosition() {
@@ -398,6 +494,7 @@ var OrbitCamera = class {
     this.canvas.removeEventListener("pointerup", this.onPointerUp);
     this.canvas.removeEventListener("pointercancel", this.onPointerUp);
     this.canvas.removeEventListener("wheel", this.onWheel);
+    this.canvas.removeEventListener("contextmenu", this.onContextMenu);
     this.activePointers.clear();
   }
 };
@@ -446,17 +543,129 @@ var RenderLoop = class {
 };
 
 // src/view3d/lod.ts
+var SEAT_MIN_PIXELS_NEAR = 2.5;
+var SEAT_MIN_PIXELS_FAR = 1.15;
+var CHAIR_FULL_M = 12;
+var CHAIR_NONE_M = 22;
+var CHAIR_GATHER_M = 30;
+var CHAIR_REBUILD_M = 4;
+var CHAIR_MAX_INSTANCES = 8192;
+var CHAIR_REQUIRED_COVER_M = CHAIR_NONE_M + CHAIR_REBUILD_M;
 function computeSeatLod(distance, radius) {
   const near = radius * 1.4;
   const far = radius * 3.2;
-  if (distance <= near) return { scale: 1, fade: 0 };
+  if (distance <= near) return { scale: 1, fade: 0, minPixels: SEAT_MIN_PIXELS_NEAR };
   const t = Math.min(1, (distance - near) / Math.max(1e-3, far - near));
   return {
     scale: 1 - t * 0.4,
-    fade: t * 0.55
+    fade: t * 0.55,
+    // Tapered on the same ramp as the fade: as the block starts reading by its
+    // tier tint, the dots stop fighting each other for pixels.
+    minPixels: SEAT_MIN_PIXELS_NEAR + t * (SEAT_MIN_PIXELS_FAR - SEAT_MIN_PIXELS_NEAR)
   };
 }
 
+// src/view3d/scene/nearField.ts
+var SEATS_PER_CELL = 4;
+var NearFieldIndex = class {
+  constructor(iPosition, count) {
+    this.minX = 0;
+    this.minZ = 0;
+    this.cell = 1;
+    this.cols = 1;
+    this.rows = 1;
+    /** CSR-style buckets: `cellStart[c]…cellStart[c+1]` indexes into `cellItems`. */
+    this.cellStart = null;
+    this.cellItems = null;
+    this.iPosition = iPosition;
+    this.count = count;
+  }
+  /** Built on demand; safe to call repeatedly. */
+  ensureGrid() {
+    if (this.cellStart || this.count === 0) return;
+    const p = this.iPosition;
+    let minX = Infinity, minZ = Infinity, maxX = -Infinity, maxZ = -Infinity;
+    for (let i = 0; i < this.count; i++) {
+      const x = p[i * 3], z = p[i * 3 + 2];
+      if (x < minX) minX = x;
+      if (x > maxX) maxX = x;
+      if (z < minZ) minZ = z;
+      if (z > maxZ) maxZ = z;
+    }
+    const w = Math.max(maxX - minX, 1e-3);
+    const h = Math.max(maxZ - minZ, 1e-3);
+    this.cell = Math.max(Math.sqrt(w * h * SEATS_PER_CELL / this.count), 0.25);
+    this.cols = Math.max(1, Math.ceil(w / this.cell) + 1);
+    this.rows = Math.max(1, Math.ceil(h / this.cell) + 1);
+    this.minX = minX;
+    this.minZ = minZ;
+    const nCells = this.cols * this.rows;
+    const start = new Int32Array(nCells + 1);
+    const cellOf = (i) => {
+      const cx = Math.min(this.cols - 1, Math.max(0, Math.floor((p[i * 3] - minX) / this.cell)));
+      const cz = Math.min(this.rows - 1, Math.max(0, Math.floor((p[i * 3 + 2] - minZ) / this.cell)));
+      return cz * this.cols + cx;
+    };
+    for (let i = 0; i < this.count; i++) start[cellOf(i) + 1]++;
+    for (let c = 0; c < nCells; c++) start[c + 1] += start[c];
+    const items = new Int32Array(this.count);
+    const cursor = start.slice(0, nCells);
+    for (let i = 0; i < this.count; i++) items[cursor[cellOf(i)]++] = i;
+    this.cellStart = start;
+    this.cellItems = items;
+  }
+  /**
+   * Fill `out` with the indices of seats within `radius` metres of (camX, camZ),
+   * nearest cell-ring first, and return how many were written.
+   *
+   * Ring order is what makes the CHAIR_MAX_INSTANCES cap harmless: when the cap
+   * bites it drops the OUTERMOST seats, which are the ones already past the fade
+   * band and drawing nothing. A cap that truncated in index order would instead
+   * punch holes in the row you are sitting in.
+   *
+   * Note this is a horizontal (XZ) query and ignores height. A stacked venue's
+   * upper tier is therefore gathered along with the stalls beneath it — which is
+   * correct, because the fade weight is re-derived from true view depth in the
+   * shader anyway. The grid's only job is to bound the candidate set.
+   */
+  gather(camX, camZ, radius, out) {
+    this.ensureGrid();
+    const start = this.cellStart;
+    const items = this.cellItems;
+    if (!start || !items) return 0;
+    const cap = out.length;
+    const r2 = radius * radius;
+    const cx = Math.floor((camX - this.minX) / this.cell);
+    const cz = Math.floor((camZ - this.minZ) / this.cell);
+    const maxRing = Math.ceil(radius / this.cell) + 1;
+    const p = this.iPosition;
+    let n = 0;
+    for (let ring = 0; ring <= maxRing && n < cap; ring++) {
+      const z0 = cz - ring, z1 = cz + ring;
+      const x0 = cx - ring, x1 = cx + ring;
+      for (let gz = z0; gz <= z1 && n < cap; gz++) {
+        if (gz < 0 || gz >= this.rows) continue;
+        const edge = gz === z0 || gz === z1;
+        for (let gx = x0; gx <= x1 && n < cap; gx++) {
+          if (!edge && gx !== x0 && gx !== x1) {
+            gx = x1 - 1;
+            continue;
+          }
+          if (gx < 0 || gx >= this.cols) continue;
+          const c = gz * this.cols + gx;
+          for (let k = start[c], e = start[c + 1]; k < e && n < cap; k++) {
+            const i = items[k];
+            const dx = p[i * 3] - camX;
+            const dz = p[i * 3 + 2] - camZ;
+            if (dx * dx + dz * dz <= r2) out[n++] = i;
+          }
+        }
+      }
+    }
+    return n;
+  }
+};
+
 // src/core/types.ts
 var ACCESSIBILITY_TYPES = [
   { key: "wheelchair", label: "Wheelchair space", short: "Wheelchair", icon: "\u267F" },
@@ -483,6 +692,12 @@ function accessibilityRingColor(types) {
   const primary = types?.[0];
   return primary && ACCESSIBILITY_RING_COLOR[primary] || "#3b82f6";
 }
+var SEAT_COMMERCIAL_MARKS = [
+  { key: "obstructedView", label: "Obstructed view", short: "Obstructed", icon: "\u26D4" },
+  { key: "restrictedView", label: "Restricted view", short: "Restricted", icon: "\u{1F441}" },
+  { key: "premium", label: "Premium seat", short: "Premium", icon: "\u2605" }
+];
+var SEAT_COMMERCIAL_LABEL = new Map(SEAT_COMMERCIAL_MARKS.map((mark) => [mark.key, mark]));
 var SURROUNDINGS_SHAPE_ROLES = [
   "reference-focal",
   "bar",
@@ -548,12 +763,42 @@ function isDegenerate(p0, p1, p2) {
   const area = Math.sqrt(Math.max(0, s * (s - e0) * (s - e1) * (s - e2)));
   return 2 * area / longest < MIN_TRI_ALTITUDE_M;
 }
+var F32Buffer = class {
+  constructor(initial = 1 << 14) {
+    this.len = 0;
+    this.buf = new Float32Array(initial);
+  }
+  push3(a, b, c) {
+    if (this.len + 3 > this.buf.length) this.grow(this.len + 3);
+    this.buf[this.len++] = a;
+    this.buf[this.len++] = b;
+    this.buf[this.len++] = c;
+  }
+  push1(a) {
+    if (this.len + 1 > this.buf.length) this.grow(this.len + 1);
+    this.buf[this.len++] = a;
+  }
+  grow(need) {
+    let cap = this.buf.length * 2;
+    while (cap < need) cap *= 2;
+    const next = new Float32Array(cap);
+    next.set(this.buf.subarray(0, this.len));
+    this.buf = next;
+  }
+  get length() {
+    return this.len;
+  }
+  /** A copy trimmed to the used length. */
+  toArray() {
+    return this.buf.slice(0, this.len);
+  }
+};
 var MeshBuilder = class {
   constructor() {
-    this.pos = [];
-    this.nor = [];
-    this.col = [];
-    this.flr = [];
+    this.pos = new F32Buffer();
+    this.nor = new F32Buffer();
+    this.col = new F32Buffer();
+    this.flr = new F32Buffer();
     /** Floor index stamped onto every triangle emitted from now on. */
     this.currentFloor = 0;
   }
@@ -564,28 +809,44 @@ var MeshBuilder = class {
   /** One triangle with a shared (flat) normal and per-vertex colours. */
   tri(p0, p1, p2, n, c0, c1 = c0, c2 = c0) {
     if (isDegenerate(p0, p1, p2)) return;
-    this.pos.push(p0[0], p0[1], p0[2], p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]);
-    this.nor.push(n[0], n[1], n[2], n[0], n[1], n[2], n[0], n[1], n[2]);
-    this.col.push(c0[0], c0[1], c0[2], c1[0], c1[1], c1[2], c2[0], c2[1], c2[2]);
-    this.flr.push(this.currentFloor, this.currentFloor, this.currentFloor);
+    this.pos.push3(p0[0], p0[1], p0[2]);
+    this.pos.push3(p1[0], p1[1], p1[2]);
+    this.pos.push3(p2[0], p2[1], p2[2]);
+    this.nor.push3(n[0], n[1], n[2]);
+    this.nor.push3(n[0], n[1], n[2]);
+    this.nor.push3(n[0], n[1], n[2]);
+    this.col.push3(c0[0], c0[1], c0[2]);
+    this.col.push3(c1[0], c1[1], c1[2]);
+    this.col.push3(c2[0], c2[1], c2[2]);
+    this.flr.push1(this.currentFloor);
+    this.flr.push1(this.currentFloor);
+    this.flr.push1(this.currentFloor);
   }
   /** One triangle with independent per-vertex normals (smooth shading). */
   triN(p0, p1, p2, n0, n1, n2, c0, c1 = c0, c2 = c0) {
     if (isDegenerate(p0, p1, p2)) return;
-    this.pos.push(p0[0], p0[1], p0[2], p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]);
-    this.nor.push(n0[0], n0[1], n0[2], n1[0], n1[1], n1[2], n2[0], n2[1], n2[2]);
-    this.col.push(c0[0], c0[1], c0[2], c1[0], c1[1], c1[2], c2[0], c2[1], c2[2]);
-    this.flr.push(this.currentFloor, this.currentFloor, this.currentFloor);
+    this.pos.push3(p0[0], p0[1], p0[2]);
+    this.pos.push3(p1[0], p1[1], p1[2]);
+    this.pos.push3(p2[0], p2[1], p2[2]);
+    this.nor.push3(n0[0], n0[1], n0[2]);
+    this.nor.push3(n1[0], n1[1], n1[2]);
+    this.nor.push3(n2[0], n2[1], n2[2]);
+    this.col.push3(c0[0], c0[1], c0[2]);
+    this.col.push3(c1[0], c1[1], c1[2]);
+    this.col.push3(c2[0], c2[1], c2[2]);
+    this.flr.push1(this.currentFloor);
+    this.flr.push1(this.currentFloor);
+    this.flr.push1(this.currentFloor);
   }
   get vertexCount() {
     return this.pos.length / 3;
   }
   build() {
     return {
-      position: new Float32Array(this.pos),
-      normal: new Float32Array(this.nor),
-      color: new Float32Array(this.col),
-      floor: new Float32Array(this.flr),
+      position: this.pos.toArray(),
+      normal: this.nor.toArray(),
+      color: this.col.toArray(),
+      floor: this.flr.toArray(),
       count: this.pos.length / 3
     };
   }
@@ -913,6 +1174,152 @@ function rectPolygon(x, y, w, h) {
   ];
 }
 
+// src/view3d/scene/seatChair.ts
+var CHAIR_PART = { pedestal: 0, pad: 1, back: 2 };
+var CHAIR_PITCH_FRACTION = 0.44;
+var CHAIR_HALF_WIDTH_MIN_M = 0.15;
+var CHAIR_HALF_WIDTH_MAX_M = 0.3;
+var CHAIR_HALF_WIDTH_DEFAULT_M = 0.24;
+function chairHalfWidth(pitchM) {
+  if (pitchM === void 0 || !Number.isFinite(pitchM) || pitchM <= 0) {
+    return CHAIR_HALF_WIDTH_DEFAULT_M;
+  }
+  return Math.min(CHAIR_HALF_WIDTH_MAX_M, Math.max(CHAIR_HALF_WIDTH_MIN_M, pitchM * CHAIR_PITCH_FRACTION));
+}
+var BACK_RAKE_SLOPE = 0.21;
+var PAD_BACK_GAP_M = 0.05;
+var PAD_TOP_M = 0.45;
+var BACK_BASE_M = PAD_TOP_M + PAD_BACK_GAP_M;
+var BOXES = [
+  // Pedestal — a plain column under the pad. Without it the pad floats 0.36 m
+  // over the deck and the row reads as hovering trays.
+  { part: CHAIR_PART.pedestal, min: [-0.3, 0, -0.3], max: [0.3, 0.36, 0.3] },
+  // Seat pad — a full seat width across and about as deep, which is what a real
+  // one is. Its depth is bounded by the same pitch as its width, because the
+  // pitch measure is the tighter of the in-row and row-to-row spacings, so a
+  // tightly-raked tier cannot drive a pad into the back of the row in front.
+  { part: CHAIR_PART.pad, min: [-1, 0.36, -0.95], max: [1, PAD_TOP_M, 1] },
+  // Back panel — thin, raked, and the tallest thing in the row, so it is what
+  // carries the state colour when you look along a row from behind.
+  {
+    part: CHAIR_PART.back,
+    min: [-1, BACK_BASE_M, -1],
+    max: [1, 0.92, -0.72]
+  }
+];
+var FACES = [
+  // +X
+  { n: [1, 0, 0], c: [[1, 0, 0], [1, 1, 0], [1, 1, 1], [1, 0, 1]] },
+  // -X
+  { n: [-1, 0, 0], c: [[0, 0, 1], [0, 1, 1], [0, 1, 0], [0, 0, 0]] },
+  // +Y
+  { n: [0, 1, 0], c: [[0, 1, 0], [0, 1, 1], [1, 1, 1], [1, 1, 0]] },
+  // -Y
+  { n: [0, -1, 0], c: [[0, 0, 1], [0, 0, 0], [1, 0, 0], [1, 0, 1]] },
+  // +Z
+  { n: [0, 0, 1], c: [[0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]] },
+  // -Z
+  { n: [0, 0, -1], c: [[1, 0, 0], [0, 0, 0], [0, 1, 0], [1, 1, 0]] }
+];
+function buildChairMesh() {
+  const vertexCount = BOXES.length * FACES.length * 4;
+  const indexCount = BOXES.length * FACES.length * 6;
+  const position = new Float32Array(vertexCount * 3);
+  const normal = new Float32Array(vertexCount * 3);
+  const part = new Float32Array(vertexCount);
+  const index = new Uint16Array(indexCount);
+  let v = 0;
+  let t = 0;
+  for (const box of BOXES) {
+    for (const face of FACES) {
+      const base = v;
+      const corner3 = new Float32Array(12);
+      for (let ci = 0; ci < 4; ci++) {
+        const corner = face.c[ci];
+        for (let a = 0; a < 3; a++) {
+          corner3[ci * 3 + a] = corner[a] ? box.max[a] : box.min[a];
+        }
+      }
+      const ax = corner3[3] - corner3[0], ay = corner3[4] - corner3[1], az = corner3[5] - corner3[2];
+      const bx = corner3[6] - corner3[0], by = corner3[7] - corner3[1], bz = corner3[8] - corner3[2];
+      let nx = ay * bz - az * by;
+      let ny = az * bx - ax * bz;
+      let nz = ax * by - ay * bx;
+      const nl = Math.hypot(nx, ny, nz);
+      if (nl > 1e-9) {
+        nx /= nl;
+        ny /= nl;
+        nz /= nl;
+      } else {
+        nx = face.n[0];
+        ny = face.n[1];
+        nz = face.n[2];
+      }
+      if (nx * face.n[0] + ny * face.n[1] + nz * face.n[2] < 0) {
+        nx = -nx;
+        ny = -ny;
+        nz = -nz;
+      }
+      for (let ci = 0; ci < 4; ci++) {
+        position[v * 3] = corner3[ci * 3];
+        position[v * 3 + 1] = corner3[ci * 3 + 1];
+        position[v * 3 + 2] = corner3[ci * 3 + 2];
+        normal[v * 3] = nx;
+        normal[v * 3 + 1] = ny;
+        normal[v * 3 + 2] = nz;
+        part[v] = box.part;
+        v++;
+      }
+      index[t++] = base;
+      index[t++] = base + 1;
+      index[t++] = base + 2;
+      index[t++] = base;
+      index[t++] = base + 2;
+      index[t++] = base + 3;
+    }
+  }
+  return { position, normal, part, index, vertexCount, indexCount };
+}
+function computeSeatYaw(iPosition, count, rowIdAt, focal) {
+  const yaw = new Float32Array(count);
+  const px = (i) => iPosition[i * 3];
+  const pz = (i) => iPosition[i * 3 + 2];
+  let runStart = 0;
+  const flushRun = (start, end) => {
+    const n = end - start;
+    for (let i = start; i < end; i++) {
+      const [fx, fz] = focal(i);
+      let dx = fx - px(i);
+      let dz = fz - pz(i);
+      if (n >= 2) {
+        const a = Math.max(start, i - 1);
+        const b = Math.min(end - 1, i + 1);
+        const tx = px(b) - px(a);
+        const tz = pz(b) - pz(a);
+        const tl = Math.hypot(tx, tz);
+        if (tl > 1e-6) {
+          let nx = -tz / tl;
+          let nz = tx / tl;
+          if (nx * dx + nz * dz < 0) {
+            nx = -nx;
+            nz = -nz;
+          }
+          dx = nx;
+          dz = nz;
+        }
+      }
+      yaw[i] = dx === 0 && dz === 0 ? 0 : Math.atan2(dx, dz);
+    }
+  };
+  for (let i = 1; i <= count; i++) {
+    if (i === count || rowIdAt(i) !== rowIdAt(runStart)) {
+      flushRun(runStart, i);
+      runStart = i;
+    }
+  }
+  return yaw;
+}
+
 // src/view3d/scene/seatInstances.ts
 var SEAT_DOT_RADIUS_M = 0.22;
 var SEAT_PITCH_FRACTION = 0.42;
@@ -982,6 +1389,7 @@ function buildSeatInstances(seats, initial, surfaces, seatFloor) {
   const iPosition = new Float32Array(count * 3);
   const iState = new Float32Array(count);
   const iMaxRadius = new Float32Array(count);
+  const iChairWidth = new Float32Array(count);
   const iRing = new Float32Array(count * 3);
   const idToIndex = /* @__PURE__ */ new Map();
   const spacing = nearestNeighbourSpacing(seats);
@@ -990,6 +1398,7 @@ function buildSeatInstances(seats, initial, surfaces, seatFloor) {
     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;
+    iChairWidth[i] = chairHalfWidth(Number.isFinite(pitchM) ? pitchM : void 0);
     iPosition[i * 3] = seat.x * M;
     iPosition[i * 3 + 1] = surfaces ? surfaces.seatDeckY(i) : seatSurfaceY(seat);
     iPosition[i * 3 + 2] = seat.y * M;
@@ -1011,7 +1420,9 @@ function buildSeatInstances(seats, initial, surfaces, seatFloor) {
     iMaxRadius,
     iRing,
     idToIndex,
-    iFloor: seatFloor ?? new Float32Array(count)
+    iChairWidth,
+    iFloor: seatFloor ?? new Float32Array(count),
+    iYaw: new Float32Array(count)
   };
 }
 var RUN_MERGE_GAP = 64;
@@ -1093,16 +1504,23 @@ function themeSeatColorLUT(theme, order) {
 var ZONE_MIN_DISTANCE = 1.15;
 var SECTION_MAX_DISTANCE = 2.2;
 var NEAR_MAX_DISTANCE = 0.85;
+var ROW_MAX_DISTANCE = 0.5;
+var SEAT_MAX_DISTANCE = 0.26;
 function visibleLabelKinds(distance, venueRadius) {
   const r = Math.max(1e-6, venueRadius);
   const d = distance / r;
   const out = /* @__PURE__ */ new Set();
   if (d >= ZONE_MIN_DISTANCE) out.add("zone");
-  if (d <= SECTION_MAX_DISTANCE) out.add("section");
+  if (d <= SECTION_MAX_DISTANCE) {
+    out.add("section");
+    out.add("ga");
+  }
   if (d <= NEAR_MAX_DISTANCE) {
     out.add("annotation");
     out.add("booth");
   }
+  if (d <= ROW_MAX_DISTANCE) out.add("row");
+  if (d <= SEAT_MAX_DISTANCE) out.add("seat");
   return out;
 }
 function projectToScreen(viewProjection, p, width, height) {
@@ -1139,6 +1557,28 @@ function cullOverlapping(items, separationX, separationY = separationX) {
   }
   return kept;
 }
+var DENSE_LABEL_BUDGET = { row: 8, seat: 14 };
+function focusScore(screen, worldDistance, width, height) {
+  const half = Math.max(1, Math.min(width, height) * 0.5);
+  const off = Math.min(2, Math.hypot(screen.x - width / 2, screen.y - height / 2) / half);
+  return worldDistance * (1 + 1.5 * off);
+}
+function pickDenseLabels(items, separationX, separationY, budget) {
+  const ordered = [...items].sort((a, b) => a.focus - b.focus);
+  const kept = [];
+  for (const item of ordered) {
+    if (kept.length >= budget) break;
+    let clash = false;
+    for (const k of kept) {
+      if (Math.abs(item.screen.x - k.screen.x) < separationX && Math.abs(item.screen.y - k.screen.y) < separationY) {
+        clash = true;
+        break;
+      }
+    }
+    if (!clash) kept.push(item);
+  }
+  return kept;
+}
 function centroidOf(points) {
   if (!points.length) return null;
   let x = 0, y = 0;
@@ -1679,191 +2119,6 @@ function buildSectionRake(rows, focal) {
   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);
@@ -1912,9 +2167,71 @@ function extendEnds(pts, 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;
+var CORNER_STEP_RAD = Math.PI / 12;
+function convexHull(pts) {
+  if (pts.length < 3) return [...pts];
+  const s = [...pts].sort((a, b) => a.x - b.x || a.y - b.y);
+  const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+  const half = (src) => {
+    const out = [];
+    for (const p of src) {
+      while (out.length >= 2 && cross(out[out.length - 2], out[out.length - 1], p) <= 0) out.pop();
+      out.push(p);
+    }
+    out.pop();
+    return out;
+  };
+  const hull = [...half(s), ...half([...s].reverse())];
+  return hull.length >= 3 ? hull : [...pts];
+}
+function seatClusterPatch(pts, pad) {
+  if (!pts.length || !(pad > 0)) return [];
+  const hull = convexHull(pts);
+  const arc = (v, from, to, out2) => {
+    let sweep = to - from;
+    while (sweep < 0) sweep += Math.PI * 2;
+    while (sweep > Math.PI * 2) sweep -= Math.PI * 2;
+    const steps = Math.max(1, Math.ceil(sweep / CORNER_STEP_RAD));
+    const r = pad / Math.cos(sweep / steps / 2);
+    for (let k = 0; k <= steps; k++) {
+      const a = from + sweep * k / steps;
+      out2.push({ x: v.x + Math.cos(a) * r, y: v.y + Math.sin(a) * r });
+    }
+  };
+  if (hull.length < 3) {
+    let cx = 0, cy = 0;
+    for (const p of hull) {
+      cx += p.x;
+      cy += p.y;
+    }
+    cx /= hull.length || 1;
+    cy /= hull.length || 1;
+    let far = 0;
+    for (const p of hull) far = Math.max(far, Math.hypot(p.x - cx, p.y - cy));
+    const out2 = [];
+    const steps = Math.max(3, Math.ceil(Math.PI * 2 / CORNER_STEP_RAD));
+    const r = (far + pad) / Math.cos(Math.PI / steps);
+    for (let k = 0; k < steps; k++) {
+      const a = k / steps * Math.PI * 2;
+      out2.push({ x: cx + Math.cos(a) * r, y: cy + Math.sin(a) * r });
+    }
+    return out2;
+  }
+  const n = hull.length;
+  const edgeAngle = [];
+  for (let i = 0; i < n; i++) {
+    const a = hull[i], b = hull[(i + 1) % n];
+    edgeAngle.push(Math.atan2(-(b.x - a.x), b.y - a.y));
+  }
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    arc(hull[i], edgeAngle[(i + n - 1) % n], edgeAngle[i], out);
+  }
+  return dedupeAdjacent(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;
@@ -1927,7 +2244,23 @@ function distToPolyline(pts, x, y) {
   }
   return best;
 }
-function neighbourhoods(rows) {
+function rowNeighbourhoods(rows) {
+  const bounds = rows.map((r) => {
+    let cx = 0, cy = 0;
+    for (const p of r.pts) {
+      cx += p.x;
+      cy += p.y;
+    }
+    const n = r.pts.length || 1;
+    cx /= n;
+    cy /= n;
+    let rad = 0;
+    for (const p of r.pts) {
+      const d = Math.hypot(p.x - cx, p.y - cy);
+      if (d > rad) rad = d;
+    }
+    return { cx, cy, rad };
+  });
   const probesOf2 = (pts) => {
     const n = pts.length;
     if (n <= 2) return [...pts];
@@ -1942,6 +2275,9 @@ function neighbourhoods(rows) {
       let nearest = Infinity;
       for (let j = 0; j < rows.length; j++) {
         if (j === i || Math.abs(rows[j].y - rows[i].y) < 1e-3) continue;
+        const b = bounds[j];
+        const lower = Math.hypot(c.x - b.cx, c.y - b.cy) - b.rad;
+        if (lower >= nearest && lower >= bestFrontD) continue;
         const d = distToPolyline(rows[j].pts, c.x, c.y);
         if (d < nearest) nearest = d;
         if (rows[j].depth < rows[i].depth && d < bestFrontD) {
@@ -1986,65 +2322,8 @@ function ribbonOf(rows, i, nbrs, focal) {
     back: Math.max(nbrs[i].pitch * BACK_REACH, MIN_REACH_U)
   };
 }
-function deckFootprints(rows, focal) {
-  if (rows.length < 2) return [];
-  const nbrs = neighbourhoods(rows);
-  const rings = [];
-  const ribbons = [];
-  for (let i = 0; i < rows.length; i++) {
-    const r = ribbonOf(rows, i, nbrs, focal);
-    ribbons.push(r);
-    if (!r) continue;
-    const f = [];
-    const b = [];
-    const rf = r.front + FOOTPRINT_MARGIN_U;
-    const rb = r.back + FOOTPRINT_MARGIN_U;
-    for (let k = 0; k < r.pts.length; k++) {
-      const p = r.pts[k], n = r.nrm[k];
-      f.push([p.x - n[0] * rf, p.y - n[1] * rf]);
-      b.push([p.x + n[0] * rb, p.y + n[1] * rb]);
-    }
-    const ring = [...f, ...b.reverse()];
-    if (ring.length < 3) continue;
-    ring.push(ring[0]);
-    rings.push([ring]);
-  }
-  if (!rings.length) return [];
-  let merged;
-  try {
-    merged = 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;
+var FOOTPRINT_TOLERANCE_U = 0.3;
 function simplifyRun(pts, tol) {
   if (pts.length < 3) return pts;
   const a = pts[0], b = pts[pts.length - 1];
@@ -2070,6 +2349,109 @@ function simplifyRing(ring, tol) {
   out.pop();
   return out.length >= 3 ? out : ring;
 }
+function deckFootprints(rows, focal, shared) {
+  if (rows.length < 2) return [];
+  const nbrs = shared ?? rowNeighbourhoods(rows);
+  const byBlock = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rows.length; i++) {
+    const a = byBlock.get(rows[i].blockId);
+    if (a) a.push(i);
+    else byBlock.set(rows[i].blockId, [i]);
+  }
+  const out = [];
+  for (const [, allIndices] of byBlock) {
+    const indices = [];
+    for (const i of allIndices) {
+      const patch = rows[i].patch;
+      if (patch && patch.length >= 3) out.push({ outline: [...patch], holes: [], topY: rows[i].y });
+      else indices.push(i);
+    }
+    if (!indices.length) continue;
+    indices.sort((a, b) => rows[a].depth - rows[b].depth);
+    const ribbons = indices.map((i) => ribbonOf(rows, i, nbrs, focal));
+    const usable = ribbons.filter((r) => r !== null);
+    if (!usable.length) continue;
+    const frontOf = (r, k) => ({
+      x: r.pts[k].x - r.nrm[k][0] * (r.front + FOOTPRINT_MARGIN_U),
+      y: r.pts[k].y - r.nrm[k][1] * (r.front + FOOTPRINT_MARGIN_U)
+    });
+    const backOf = (r, k) => ({
+      x: r.pts[k].x + r.nrm[k][0] * (r.back + FOOTPRINT_MARGIN_U),
+      y: r.pts[k].y + r.nrm[k][1] * (r.back + FOOTPRINT_MARGIN_U)
+    });
+    const first = usable[0], last = usable[usable.length - 1];
+    const ring = [];
+    for (let k = 0; k < first.pts.length; k++) ring.push(frontOf(first, k));
+    for (const r of usable) ring.push(backOf(r, r.pts.length - 1));
+    for (let k = last.pts.length - 1; k >= 0; k--) ring.push(backOf(last, k));
+    for (let i = usable.length - 1; i >= 0; i--) ring.push(frontOf(usable[i], 0));
+    const deduped = dedupeAdjacent(ring);
+    let topY = Infinity;
+    for (const i of indices) if (rows[i].y < topY) topY = rows[i].y;
+    if (!Number.isFinite(topY)) continue;
+    const covers = deduped.length >= 3 && Math.abs(ringArea(deduped)) > 1e-6 && usable.every((r) => {
+      const mid = r.pts[Math.floor(r.pts.length / 2)];
+      return pointInRing(deduped, mid.x, mid.y);
+    });
+    if (covers) {
+      out.push({ outline: simplifyRing(deduped, FOOTPRINT_TOLERANCE_U), holes: [], topY });
+      continue;
+    }
+    for (const poly of unionRibbons(usable)) out.push({ outline: poly, holes: [], topY });
+  }
+  return out;
+}
+function unionRibbons(ribbons) {
+  const rings = [];
+  for (const r of ribbons) {
+    const f = [];
+    const b = [];
+    const rf = r.front + FOOTPRINT_MARGIN_U;
+    const rb = r.back + FOOTPRINT_MARGIN_U;
+    for (let k = 0; k < r.pts.length; k++) {
+      const p = r.pts[k], n = r.nrm[k];
+      f.push([p.x - n[0] * rf, p.y - n[1] * rf]);
+      b.push([p.x + n[0] * rb, p.y + n[1] * rb]);
+    }
+    const ring = [...f, ...b.reverse()];
+    if (ring.length < 3) continue;
+    ring.push(ring[0]);
+    rings.push([ring]);
+  }
+  if (!rings.length) return [];
+  try {
+    const merged = import_polygon_clipping2.default.union(rings[0], ...rings.slice(1));
+    const out = [];
+    for (const poly of merged) {
+      if (!poly.length || poly[0].length < 4) continue;
+      const pts = poly[0].map(([x, y]) => ({ x, y }));
+      const first = pts[0], last = pts[pts.length - 1];
+      if (pts.length > 1 && Math.abs(first.x - last.x) < 1e-9 && Math.abs(first.y - last.y) < 1e-9) pts.pop();
+      if (pts.length >= 3) out.push(simplifyRing(pts, FOOTPRINT_TOLERANCE_U));
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function ringArea(ring) {
+  let a = 0;
+  for (let i = 0, n = ring.length; i < n; i++) {
+    const p = ring[i], q = ring[(i + 1) % n];
+    a += p.x * q.y - q.x * p.y;
+  }
+  return a / 2;
+}
+function dedupeAdjacent(ring) {
+  const out = [];
+  for (const p of ring) {
+    const last = out[out.length - 1];
+    if (last && Math.hypot(p.x - last.x, p.y - last.y) < 1e-9) continue;
+    out.push(p);
+  }
+  while (out.length > 2 && Math.hypot(out[0].x - out[out.length - 1].x, out[0].y - out[out.length - 1].y) < 1e-9) out.pop();
+  return out;
+}
 function pointInRing(ring, x, y) {
   let inside = false;
   for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
@@ -2093,106 +2475,351 @@ var ClipTest = class {
         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;
+  }
+  /** 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 emitClippedPoly(builder, clipRing, clipTest, poly, y, color) {
+  if (poly.length < 3) return;
+  if (clipTest.containsAll(poly)) {
+    const UPF = [0, 1, 0];
+    const a = poly[0];
+    for (let i = 1; i + 1 < poly.length; i++) {
+      const b = poly[i], c = poly[i + 1];
+      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);
+    }
+    return;
+  }
+  const ring = poly.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 poly2 of pieces) {
+    if (!poly2.length || poly2[0].length < 4) continue;
+    const outer = poly2[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, shared) {
+  if (rows.length < 2) return;
+  const nbrs = shared ?? rowNeighbourhoods(rows);
+  const UP = [0, 1, 0];
+  const clipRing = clip && clip.length >= 3 ? [[...clip.map((p) => [p.x, p.y]), [clip[0].x, clip[0].y]]] : null;
+  const clipTest = clip && clip.length >= 3 ? new ClipTest([[...clip]]) : null;
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    if (row.patch && row.patch.length >= 3) {
+      const patch = [...row.patch];
+      const belowY2 = nbrs[i].belowY ?? landingY;
+      if (clipRing && clipTest) emitClippedPoly(builder, clipRing, clipTest, patch, row.y, colors.tread);
+      else {
+        const a = patch[0];
+        for (let k = 1; k + 1 < patch.length; k++) {
+          const b = patch[k], c = patch[k + 1];
+          builder.tri([a.x * M, row.y, a.y * M], [b.x * M, row.y, b.y * M], [c.x * M, row.y, c.y * M], UP, colors.tread);
+        }
+      }
+      if (row.y > belowY2 + MIN_RISER_M) {
+        let cx = 0, cy = 0;
+        for (const p of patch) {
+          cx += p.x;
+          cy += p.y;
+        }
+        cx /= patch.length;
+        cy /= patch.length;
+        for (let k = 0; k < patch.length; k++) {
+          const p = patch[k], q = patch[(k + 1) % patch.length];
+          const dx = q.x - p.x, dy = q.y - p.y;
+          const len = Math.hypot(dx, dy);
+          if (len < 1e-6) continue;
+          let nx = dy / len, ny = -dx / len;
+          if ((p.x - cx) * nx + (p.y - cy) * ny < 0) {
+            nx = -nx;
+            ny = -ny;
+          }
+          const rn = [nx, 0, ny];
+          const pt = [p.x * M, row.y, p.y * M];
+          const qt = [q.x * M, row.y, q.y * M];
+          const pb = [p.x * M, belowY2, p.y * M];
+          const qb = [q.x * M, belowY2, q.y * M];
+          builder.tri(pt, qt, qb, rn, colors.riser);
+          builder.tri(pt, qb, pb, rn, colors.riser);
+        }
+      }
+      continue;
+    }
+    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) {
+        emitClippedPoly(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/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 };
+}
+function pointInRing2(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 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 = [];
+  const tableRowIds = /* @__PURE__ */ new Set();
+  for (const unit of units) {
+    for (const o of unit.objects) {
+      if (o.type === "table") tableRowIds.add(o.id);
+      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 structure = a.hasSeats ? resolveSection(id, seats, a.seatIndices, a.unit.focal) : { sectionId: id, rows: [], blockCount: 0 };
+    const needsRake = structure.rows.length < 2;
+    const rake = needsRake ? buildSectionRake([...a.rows.values()].map((points) => ({ points })), a.unit.focal) : null;
+    let frontU = Infinity;
+    if (rake) {
+      if (a.hasSeats) {
+        for (const pts of a.rows.values()) {
+          for (const p of pts) {
+            const d = rake.depthAt(p.x, p.y);
+            if (d < frontU) frontU = d;
+          }
+        }
+      }
+      if (!a.hasSeats || !Number.isFinite(frontU)) {
+        frontU = Infinity;
+        for (const p of a.section.outline) {
+          const d = rake.depthAt(p.x, p.y);
+          if (d < frontU) frontU = d;
+        }
+      }
+    }
+    const baseFloor = bottomY + FLAT_SLAB_TOP_M;
+    const flatTop = Math.max(baseFloor, geo.height);
+    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 rowLevels = flat ? [] : structure.rows.map((r) => ({
+      pts: r.pts,
+      y: levelForBlockDepth(r.blockDepth),
+      depth: r.blockDepth,
+      blockId: r.blockId,
+      ...tableRowIds.has(r.id) ? { patch: seatClusterPatch(r.pts, MIN_REACH_U) } : {}
+    }));
+    const landingY = rowLevels.length ? rowLevels[0].y : flatTop;
+    const rowBounds = rowLevels.map((r) => {
+      const ext = r.patch && r.patch.length >= 3 ? r.patch : r.pts;
+      let cx = 0, cy = 0;
+      for (const p of ext) {
+        cx += p.x;
+        cy += p.y;
+      }
+      const n = ext.length || 1;
+      cx /= n;
+      cy /= n;
+      let rad = 0;
+      for (const p of ext) {
+        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 patch = rowLevels[i].patch;
+        const d = patch && patch.length >= 3 ? pointInRing2(patch, x, y) ? 0 : distanceToPolyline(patch, x, y) : distanceToPolyline(rowLevels[i].pts, x, y);
+        if (d < best) {
+          best = d;
+          bestY = rowLevels[i].y;
+        }
+      }
+      return bestY;
+    } : (x, y) => rake ? levelFor(rake.depthAt(x, y)) : flatTop;
+    const UP = [0, 1, 0];
+    const normalAt = rowLevels.length >= 2 || flat ? () => UP : (x, y) => {
+      if (!rake) return UP;
+      const d = rake.depthAt(x, y);
+      if (d <= frontU) return UP;
+      const depthM = (d - frontU) * METRES_PER_CHART_UNIT;
+      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;
         }
       }
-      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
-      );
+      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 });
   }
-}
-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);
-      }
+  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/sceneModel.ts
@@ -2257,9 +2884,7 @@ function boxesOverlap(a, b) {
   return a.minX <= b.maxX && b.minX <= a.maxX && a.minY <= b.maxY && b.minY <= a.maxY;
 }
 function paddedFootprint(section, siblings) {
-  const __tp = performance.now();
   const padded = outsetRing(section.outline, SEAT_DOT_RADIUS_M * 1.5 * CHART_UNITS_PER_METRE);
-  __t("outsetRing", __tp);
   const box = bboxOfRing(padded);
   const others = siblings.filter((o) => o !== section && o.outline && o.outline.length >= 3 && boxesOverlap(box, bboxOfRing(o.outline)));
   if (!others.length) return [padded];
@@ -2323,9 +2948,8 @@ function buildTier(builder, section, unit, fill, surface, claimed, siblings, S)
   const footprint = paddedFootprint(section, siblings);
   const outline = footprint[0] ?? section.outline;
   if (surface.rowLevels.length >= 2) {
-    const __tf = performance.now();
-    const blocks = clipFootprints(deckFootprints(surface.rowLevels, unit.focal), footprint);
-    __t("deckFootprints", __tf);
+    const nbrs = rowNeighbourhoods(surface.rowLevels);
+    const blocks = clipFootprints(deckFootprints(surface.rowLevels, unit.focal, nbrs), footprint);
     const capUp = () => [0, 1, 0];
     for (const b of blocks) {
       extrudePrism(
@@ -2353,34 +2977,49 @@ function buildTier(builder, section, unit, fill, surface, claimed, siblings, S)
         AO
       );
     }
-    const __tb = performance.now();
     emitDeckBands(builder, surface.rowLevels, unit.focal, surface.landingY, {
       tread: [colTop[0] * AO.top, colTop[1] * AO.top, colTop[2] * AO.top],
       // Risers read as the structure they are, a shade below their tread, which
       // is what makes the stepping legible from a low angle.
       riser: [colTop[0] * 0.72, colTop[1] * 0.72, colTop[2] * 0.72]
-    }, footprint.length === 1 ? outline : footprint.flat());
-    __t("emitDeckBands", __tb);
+    }, footprint.length === 1 ? outline : footprint.flat(), nbrs);
     return;
   }
   const maxErr = surface.flat ? Infinity : CAP_MAX_ERROR_M;
   const topN = (p) => surface.normalAt(p.x, p.y);
-  for (const ring of claimed.subtract(outline)) {
+  const level = surface.flat ? surface.landingY : void 0;
+  for (const ring of claimed.subtract(outline, level)) {
     extrudePrism(builder, ring, section.holes, topY, bottomY, colTop, S.tierWall, AO, maxErr, topN);
   }
 }
+function coplanarLevels(a, b) {
+  if (a === void 0 || b === void 0) return true;
+  return Math.abs(a - b) < 1e-3;
+}
 var ClaimedArea = class {
   constructor() {
     this.rings = [];
     this.boxes = [];
+    /** Constant deck height of each claim, or undefined when it is not level. */
+    this.levels = [];
   }
-  /** `ring` minus everything claimed so far; then claim what is returned. */
-  subtract(ring) {
+  /**
+   * `ring` minus everything claimed so far AT THE SAME HEIGHT; then claim it.
+   *
+   * `level` is the claim's constant deck height when it has one. Two decks only
+   * z-fight when they are coplanar, so only a coplanar claim may take ground
+   * away — an elevated box hanging over a ground-level section overlaps it in
+   * plan and must still draw its whole floor, or the box loses the part of its
+   * deck that shares a footprint with whatever is underneath it. Passing
+   * undefined (a surface with no single height) keeps the original
+   * clip-against-everything behaviour.
+   */
+  subtract(ring, level) {
     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]));
+    const overlapping = this.rings.filter((_, i) => boxesOverlap(box, this.boxes[i]) && coplanarLevels(level, this.levels[i]));
     let pieces = [[closed]];
     if (overlapping.length) {
       try {
@@ -2392,6 +3031,7 @@ var ClaimedArea = class {
     }
     this.rings.push([closed]);
     this.boxes.push(box);
+    this.levels.push(level);
     const out = [];
     for (const poly of pieces) {
       if (!poly.length) continue;
@@ -2410,7 +3050,12 @@ var ZONE_LABEL_LIFT_M = 6;
 var SECTION_LABEL_LIFT_M = 2.2;
 var ANNOTATION_LIFT_M = 0.1;
 var BOOTH_LABEL_LIFT_M = 0.3;
+var GA_LABEL_LIFT_M = 1.8;
+var ROW_LABEL_LIFT_M = 0.9;
+var SEAT_LABEL_LIFT_M = 0.55;
+var SEAT_LABEL_MAX = 6e3;
 var TABLE_HEIGHT_M = 0.75;
+var DECOR_PLATE_M = 0.15;
 function boothPolygon(booth) {
   if (booth.points && booth.points.length >= 3) return booth.points;
   const { center, width, height, rotation } = booth;
@@ -2484,10 +3129,63 @@ function buildShape(builder, shape, base, S) {
   if (!poly) return;
   const isStage = shape.role === "stage";
   const height = isStage ? base + 1 : base + 0.25;
-  const colTop = isStage ? S.stageTop : S.decorTop;
+  const colTop = tintTop(hexToRgb(shape.fill), isStage ? S.stageTop : S.decorTop);
   const colWall = isStage ? S.stageWall : S.decorWall;
   extrudePrism(builder, poly, void 0, () => height, base, colTop, colWall, AO);
 }
+function decorPolygon(decor) {
+  const { x, y, width, height } = decor;
+  if (!width || !height) return null;
+  const cx = x + width / 2, cy = y + height / 2;
+  const a = (decor.rotation ?? 0) * Math.PI / 180;
+  const cos = Math.cos(a), sin = Math.sin(a);
+  const hw = width / 2, hh = height / 2;
+  return [[-hw, -hh], [hw, -hh], [hw, hh], [-hw, hh]].map(([lx, ly]) => ({
+    x: cx + lx * cos - ly * sin,
+    y: cy + lx * sin + ly * cos
+  }));
+}
+function decorPlatePaint(href) {
+  if (!href || !href.startsWith("data:image/svg+xml")) return null;
+  let svg = href.slice(href.indexOf(",") + 1);
+  if (/;base64/i.test(href.slice(0, href.indexOf(",")))) {
+    try {
+      svg = atob(svg);
+    } catch {
+      return null;
+    }
+  } else {
+    try {
+      svg = decodeURIComponent(svg);
+    } catch {
+    }
+  }
+  const covering = svg.match(/<(?:rect|path)\b[^>]*\bfill="([^"]+)"/i);
+  if (!covering) return null;
+  const paint = covering[1].trim();
+  if (paint === "none" || paint === "transparent") return null;
+  const gradient = paint.match(/^url\(#([^)]+)\)$/);
+  if (!gradient) return hexToRgb(paint);
+  const def = svg.match(new RegExp(`<(?:linear|radial)Gradient\\b[^>]*\\bid="${gradient[1]}"[^>]*>([\\s\\S]*?)</(?:linear|radial)Gradient>`, "i"));
+  if (!def) return null;
+  const stops = [];
+  for (const m of def[1].matchAll(/stop-color="([^"]+)"/gi)) {
+    const c = hexToRgb(m[1].trim());
+    if (c) stops.push(c);
+  }
+  if (!stops.length) return null;
+  return stops.reduce((acc, c, i) => mix(acc, c, 1 / (i + 1)), stops[0]);
+}
+function buildDecorImage(builder, decor, base, S) {
+  if (decor.layer === "foreground") return;
+  const poly = decorPolygon(decor);
+  if (!poly) return;
+  const top = base + DECOR_PLATE_M;
+  let paint = tintTop(decorPlatePaint(decor.href), S.decorTop);
+  const opacity = Math.max(0, Math.min(1, decor.opacity ?? 1));
+  if (opacity < 1) paint = mix(S.ground, paint, opacity);
+  extrudePrism(builder, poly, void 0, () => top, base, paint, mix(paint, S.decorWall, 0.5), AO);
+}
 function buildGa(builder, ga, base, fill, S) {
   if (!ga.points || ga.points.length < 3) return;
   const colTop = tintTop(fill, S.gaTop);
@@ -2513,6 +3211,9 @@ function chartFootprint(units, seats) {
       } else if (o.type === "table") {
         const t = tablePolygon(o);
         if (t) for (const p of t) acc(p.x, p.y);
+      } else if (o.type === "decorImage") {
+        const d = decorPolygon(o);
+        if (d) for (const p of d) acc(p.x, p.y);
       }
     }
   }
@@ -2524,12 +3225,7 @@ function chartFootprint(units, seats) {
   }
   return { minX, minY, maxX, maxY };
 }
-var __PROF = {};
-var __t = (k, t0) => {
-  __PROF[k] = (__PROF[k] ?? 0) + (performance.now() - t0);
-};
 function buildSceneModel(input) {
-  for (const k of Object.keys(__PROF)) delete __PROF[k];
   const { doc, seats } = input;
   const theme = resolveTheme3D(doc.theme);
   const S = theme.structure;
@@ -2542,9 +3238,7 @@ function buildSceneModel(input) {
   const sectionFills = resolveSectionFills(doc, seats);
   const catColor = /* @__PURE__ */ new Map();
   for (const c of doc.categories ?? []) catColor.set(c.key, c.color);
-  const __t0 = performance.now();
   const surfaces = buildVenueSurfaces(units, seats);
-  __t("surfaces", __t0);
   const seatFloor = new Float32Array(seats.length);
   for (let unitIndex = 0; unitIndex < units.length; unitIndex++) {
     const unit = units[unitIndex];
@@ -2552,23 +3246,17 @@ function buildSceneModel(input) {
     const claimed = new ClaimedArea();
     const siblings = unit.objects.filter((o) => o.type === "section" && !!o.outline && o.outline.length >= 3);
     for (const o of unit.objects) {
-      if (o.type === "section") {
-        const t = performance.now();
-        buildTier(builder, o, unit, sectionFill(o, sectionFills), surfaces.bySection.get(o.id), claimed, siblings, S);
-        __t("buildTier", t);
-      } else if (o.type === "shape") buildShape(builder, o, unit.baseHeightM, S);
+      if (o.type === "section") buildTier(builder, o, unit, sectionFill(o, sectionFills), surfaces.bySection.get(o.id), claimed, siblings, S);
+      else if (o.type === "shape") buildShape(builder, o, unit.baseHeightM, S);
       else if (o.type === "gaArea") buildGa(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)), S);
       else if (o.type === "booth") buildBooth(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)), S);
       else if (o.type === "table") buildTable(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)), S);
+      else if (o.type === "decorImage") buildDecorImage(builder, o, unit.baseHeightM, S);
     }
   }
   const focal = doc.focalPoint ?? { x: (fp.minX + fp.maxX) / 2, y: (fp.minY + fp.maxY) / 2 };
-  const __tm = performance.now();
   const solids = mergeMeshData([builder.build()]);
-  __t("meshBuild+merge", __tm);
-  const __ts = performance.now();
   const seatData = buildSeatInstances(seats, input.initialState, surfaces, seatFloor);
-  __t("seatInstances", __ts);
   const zoneDefs = doc.zones ?? [];
   const zones = [];
   if (zoneDefs.length) {
@@ -2628,6 +3316,7 @@ function buildSceneModel(input) {
     }
   }
   const labels = [];
+  const sections = [];
   for (const z of zones) {
     if (z.seatCount === 0) continue;
     labels.push({
@@ -2640,6 +3329,7 @@ function buildSceneModel(input) {
   }
   {
     const acc = /* @__PURE__ */ new Map();
+    const ext = /* @__PURE__ */ new Map();
     for (let i = 0; i < seats.length; i++) {
       const owner = surfaces.seatOwner[i];
       if (!owner) continue;
@@ -2652,18 +3342,87 @@ function buildSceneModel(input) {
       a.x += seats[i].x;
       a.y += seats[i].y;
       a.deck += surfaces.seatDeckY(i);
+      let e = ext.get(owner);
+      if (!e) {
+        e = { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity };
+        ext.set(owner, e);
+      }
+      if (seats[i].x < e.minX) e.minX = seats[i].x;
+      if (seats[i].x > e.maxX) e.maxX = seats[i].x;
+      if (seats[i].y < e.minY) e.minY = seats[i].y;
+      if (seats[i].y > e.maxY) e.maxY = seats[i].y;
     }
     for (const unit of units) {
       for (const o of unit.objects) {
         if (o.type !== "section") continue;
         const a = acc.get(o.id);
         if (!a || a.n === 0) continue;
+        const e = ext.get(o.id);
+        const centre = [a.x / a.n * M, a.deck / a.n, a.y / a.n * M];
+        sections.push({
+          id: o.id,
+          label: o.displayLabel || o.label || o.id,
+          seatCount: a.n,
+          center: centre,
+          // Half-diagonal of the seat extent — the same fit the zones use.
+          radius: Math.max(1, Math.hypot(e.maxX - e.minX, e.maxY - e.minY) * 0.5 * M),
+          // A section faces its floor's focal, which is what the camera should
+          // look along so the seats present their fronts.
+          focalWorld: [unit.focal.x * M, unit.baseHeightM + 1.5, unit.focal.y * M]
+        });
         labels.push({
           id: `section:${o.id}`,
           kind: "section",
           // The buyer-facing name wins over the technical one, as it does in 2D.
           text: o.displayLabel || o.label || o.id,
-          anchor: [a.x / a.n * M, a.deck / a.n + SECTION_LABEL_LIFT_M, a.y / a.n * M]
+          anchor: [centre[0], centre[1] + SECTION_LABEL_LIFT_M, centre[2]]
+        });
+      }
+    }
+  }
+  {
+    for (const unit of units) {
+      for (const o of unit.objects) {
+        if (o.type !== "gaArea") continue;
+        const c = centroidOf(o.points);
+        if (!c) continue;
+        const name = o.displayLabel || o.label || o.id;
+        labels.push({
+          id: `ga:${o.id}`,
+          kind: "ga",
+          text: o.capacity > 0 ? `${name} \xB7 ${o.capacity.toLocaleString()}` : name,
+          anchor: [c.x * M, unit.baseHeightM + GA_LABEL_LIFT_M, c.y * M]
+        });
+      }
+    }
+    const rowEnds = /* @__PURE__ */ new Map();
+    for (let i = 0; i < seats.length; i++) {
+      const s = seats[i];
+      const far = Math.hypot(s.x - focal.x, s.y - focal.y);
+      const cur = rowEnds.get(s.rowId);
+      if (!cur || far > cur.far) rowEnds.set(s.rowId, { seat: s, index: i, far });
+    }
+    for (const [rowId, end] of rowEnds) {
+      const cut = end.seat.label ? end.seat.label.lastIndexOf("-") : -1;
+      const text = cut > 0 ? end.seat.label.slice(0, cut) : rowId;
+      if (!text) continue;
+      labels.push({
+        id: `row:${rowId}`,
+        kind: "row",
+        text,
+        anchor: [end.seat.x * M, surfaces.seatDeckY(end.index) + ROW_LABEL_LIFT_M, end.seat.y * M]
+      });
+    }
+    if (seats.length <= SEAT_LABEL_MAX) {
+      for (let i = 0; i < seats.length; i++) {
+        const s = seats[i];
+        const text = s.displayLabel || s.label;
+        if (!text) continue;
+        labels.push({
+          id: `seat:${s.id}`,
+          kind: "seat",
+          text,
+          anchor: [s.x * M, surfaces.seatDeckY(i) + SEAT_LABEL_LIFT_M, s.y * M]
         });
       }
     }
@@ -2728,6 +3487,15 @@ function buildSceneModel(input) {
       });
     }
   }
+  seatData.iYaw = computeSeatYaw(
+    seatData.iPosition,
+    seats.length,
+    (i) => seats[i].rowId,
+    (i) => {
+      const f = units[seatFloor[i]]?.focal ?? focal;
+      return [f.x * M, f.y * M];
+    }
+  );
   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;
@@ -2741,6 +3509,7 @@ function buildSceneModel(input) {
     // Look-at target ~1.5 m up so a seated camera aims slightly down at the stage.
     focalWorld: [focal.x * M, 1.5, focal.y * M],
     zones,
+    sections,
     labels,
     floors
   };
@@ -2752,8 +3521,23 @@ var SEPARATION_Y_PX = 20;
 var KIND_STYLE = {
   zone: { size: 15, weight: "600", opacity: 0.95 },
   section: { size: 12, weight: "500", opacity: 0.88 },
+  ga: { size: 12, weight: "500", opacity: 0.88 },
   booth: { size: 11, weight: "500", opacity: 0.85 },
-  annotation: { size: 11, weight: "400", opacity: 0.75 }
+  annotation: { size: 11, weight: "400", opacity: 0.75 },
+  // Row and seat identity are quieter than the structure they sit inside: at
+  // this range the venue is already understood and the label is a detail, so it
+  // must not compete with the seating it is printed over.
+  row: { size: 10.5, weight: "600", opacity: 0.8 },
+  seat: { size: 9.5, weight: "500", opacity: 0.72 }
+};
+var DENSE_KINDS = /* @__PURE__ */ new Set(["row", "seat"]);
+var DENSE_SEPARATION = {
+  row: { x: 62, y: 16 },
+  // Widened from 24: at close range seat labels stopped overlapping at all, so
+  // the separation had no work left to do and the budget was carrying the whole
+  // load. A wider box means the few labels that ARE kept are spread across the
+  // seating instead of clustering into one stack.
+  seat: { x: 46, y: 18 }
 };
 var LabelOverlay = class {
   constructor(container, opts = {}) {
@@ -2784,7 +3568,7 @@ var LabelOverlay = class {
    *
    * `viewProjection` is column-major, as OGL supplies it.
    */
-  update(viewProjection, width, height, cameraDistance, venueRadius) {
+  update(viewProjection, width, height, cameraDistance, venueRadius, cameraWorld) {
     if (!this.labels.length) return;
     const kinds = visibleLabelKinds(cameraDistance, venueRadius);
     const candidates = [];
@@ -2792,9 +3576,26 @@ var LabelOverlay = class {
       if (!kinds.has(label.kind)) continue;
       const screen = projectToScreen(viewProjection, label.anchor, width, height);
       if (!screen.visible) continue;
-      candidates.push({ label, screen });
+      const world = cameraWorld ? Math.hypot(
+        label.anchor[0] - cameraWorld[0],
+        label.anchor[1] - cameraWorld[1],
+        label.anchor[2] - cameraWorld[2]
+      ) : 1;
+      candidates.push({ label, screen, focus: focusScore(screen, world, width, height) });
     }
-    const kept = cullOverlapping(candidates, SEPARATION_X_PX, SEPARATION_Y_PX);
+    const structure = candidates.filter((c) => !DENSE_KINDS.has(c.label.kind));
+    const kept = [
+      ...cullOverlapping(structure, SEPARATION_X_PX, SEPARATION_Y_PX),
+      // The dense rungs are BUDGETED, not merely deduplicated — see
+      // DENSE_LABEL_BUDGET for why the overlap test alone gets worse the closer
+      // the camera gets.
+      ...["row", "seat"].flatMap((kind) => pickDenseLabels(
+        candidates.filter((c) => c.label.kind === kind),
+        DENSE_SEPARATION[kind].x,
+        DENSE_SEPARATION[kind].y,
+        DENSE_LABEL_BUDGET[kind]
+      ))
+    ];
     const keptIds = new Set(kept.map((k) => k.label.id));
     for (const { label, screen } of kept) {
       const node = this.nodeFor(label);
@@ -2841,6 +3642,13 @@ var import_ogl4 = require("ogl");
 
 // src/view3d/scene/materials.ts
 var import_ogl3 = require("ogl");
+var CHAIR_WEIGHT_GLSL = (
+  /* glsl */
+  `
+float chairWeight(float depth) {
+  return 1.0 - smoothstep(uChairFull, uChairNone, depth);
+}`
+);
 var SOLID_VERT = (
   /* glsl */
   `#version 300 es
@@ -2920,14 +3728,23 @@ uniform float uSeatScale;
 uniform float uMinPixels;
 uniform float uPixelToWorld;   // (2*tan(fovY/2)) / viewportHeightPx
 uniform float uFocusFloor;     // -1 = show every floor
+uniform float uChairFull;      // view depth at which the chair mesh is full size
+uniform float uChairNone;      // ...and at which it has scaled away entirely
 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;
+out float vDotWeight;  // 1 = the dot IS this seat, 0 = the chair has taken over
+${CHAIR_WEIGHT_GLSL}
 void main() {
   vec4 mv = modelViewMatrix * vec4(iOffset, 1.0);
   float depth = max(-mv.z, 0.001);
+  // Hand the seat over to the chair mesh as it comes into range. Derived from
+  // this instance's OWN depth rather than from a global uniform, so a row two
+  // metres away and the far side of the bowl resolve differently in the same
+  // frame \u2014 which is the entire point of a ladder over a switch.
+  vDotWeight = 1.0 - chairWeight(depth);
   float minR = uMinPixels * depth * uPixelToWorld;      // screen-space floor
   // 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.
@@ -2961,6 +3778,7 @@ in vec3 vColor;
 in float vBudget;
 in vec3 vRing;
 in float vDim;
+in float vDotWeight;
 uniform float uSeatFade;      // fade toward tier colour with distance (LOD)
 uniform vec3 uFadeColor;
 out vec4 fragColor;
@@ -2985,9 +3803,131 @@ void main() {
   // Seats on an unfocused floor recede with their structure.
   c = mix(c, uFadeColor, vDim * 0.75);
   alpha *= mix(1.0, 0.30, vDim);
+  // Yield to the chair. The chair grows out of this exact point, so through the
+  // band the dot is always at least as big as the chair inside it and the seat
+  // never thins out to nothing in between.
+  alpha *= vDotWeight;
+  if (alpha <= 0.0) discard;
   fragColor = vec4(c, alpha);
 }`
 );
+var CHAIR_VERT = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec3 position;      // local: x/z in units of the seat radius, y in METRES
+in vec3 normal;
+in float part;         // 0 = pedestal, 1 = pad, 2 = back
+in vec3 iOffset;       // per-instance world deck point (identical to the dot's)
+in vec3 iColor;        // per-instance state colour
+in float iRadius;      // per-instance horizontal half-width, world metres
+in float iYaw;         // per-instance facing, radians (local +Z -> facing dir)
+in vec3 iRing;         // accommodation ring colour; (0,0,0) = not accessible
+in float iFloor;
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform float uChairFull;
+uniform float uChairNone;
+uniform float uFocusFloor;
+uniform float uBackRake;   // metres of z per metre of rise, above uBackBase
+uniform float uBackBase;   // local height at which the back starts
+out vec3 vColor;
+out vec3 vNormalWorld;
+out vec3 vNormalView;
+out vec3 vPosView;
+out float vPart;
+out float vHeight;   // local height in metres, for the vertical occlusion ramp
+out vec3 vRing;
+out float vDim;
+${CHAIR_WEIGHT_GLSL}
+void main() {
+  vec4 anchor = modelViewMatrix * vec4(iOffset, 1.0);
+  float w = chairWeight(max(-anchor.z, 0.001));
+  // 1. Local units -> world metres. Only x/z scale: narrow rows get narrow
+  //    chairs, but nobody gets a short one (people are the same height at every
+  //    seat pitch).
+  vec3 p = position;
+  p.xz *= iRadius;
+  // 2. Lean the back. Done here rather than in the base mesh so the lean is a
+  //    real angle in METRES \u2014 baked into the mesh it would scale with the seat's
+  //    width and the same chair would lean 20 degrees on a wide stadium row and
+  //    6 on a tight theatre one.
+  float rake = (part > 1.5) ? max(p.y - uBackBase, 0.0) * uBackRake : 0.0;
+  p.z -= rake;
+  // 3. Scale-in. At w=0 the chair is a point at the seat, under a dot at full
+  //    opacity \u2014 which is what makes the handover invisible. sqrt front-loads
+  //    the growth so the chair is already near full size while the dot is still
+  //    half there; see chairScale() in lod.ts.
+  p *= sqrt(w);
+  float c = cos(iYaw), s = sin(iYaw);
+  vec3 rp = vec3(p.x * c + p.z * s, p.y, -p.x * s + p.z * c);
+  // Normals under the same two transforms, in reverse and inverted-transposed.
+  // The xz scale is non-uniform, so an axis-aligned normal does NOT survive it
+  // unchanged; and the rake is a shear, whose normal transform adds a y term.
+  // Skipping either lights the raked back as though it were still vertical.
+  vec3 n = vec3(normal.x / iRadius, normal.y, normal.z / iRadius);
+  if (part > 1.5) n.y += uBackRake * n.z;
+  n = normalize(n);
+  vec3 rn = vec3(n.x * c + n.z * s, n.y, -n.x * s + n.z * c);
+  vec4 mv = modelViewMatrix * vec4(iOffset + rp, 1.0);
+  vPosView = mv.xyz;
+  vNormalWorld = rn;
+  vNormalView = normalize(mat3(modelViewMatrix) * rn);
+  vColor = iColor;
+  vPart = part;
+  vHeight = position.y;
+  vRing = iRing;
+  vDim = (uFocusFloor < -0.5 || abs(iFloor - uFocusFloor) < 0.5) ? 0.0 : 1.0;
+  gl_Position = projectionMatrix * mv;
+}`
+);
+var CHAIR_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec3 vColor;
+in vec3 vNormalWorld;
+in vec3 vNormalView;
+in vec3 vPosView;
+in float vPart;
+in float vHeight;
+in vec3 vRing;
+in float vDim;
+uniform vec3 uKeyDir;
+uniform vec3 uFadeColor;
+out vec4 fragColor;
+void main() {
+  vec3 N = normalize(vNormalWorld);
+  vec3 V = normalize(-vPosView);
+  // The solids' rig, unchanged, so the chairs sit in the venue's light.
+  float hemi = 0.5 + 0.5 * N.y;
+  float key = max(dot(N, uKeyDir), 0.0);
+  vec3 fillDir = normalize(vec3(-uKeyDir.x, 0.25, -uKeyDir.z));
+  float fill = max(dot(N, fillDir), 0.0);
+  vec3 tint = vColor;
+  // The accommodation ring, kept legible once the dot (which drew it) is gone:
+  // an accessible seat's PEDESTAL is painted in the ring colour, so the marker
+  // survives to close range instead of vanishing exactly when the buyer arrives.
+  float ringMask = step(0.001, dot(vRing, vRing));
+  if (vPart < 0.5 && ringMask > 0.5) tint = vRing;
+  // Pad brightest, back a step below it, pedestal darkest. Three untextured
+  // boxes only read as one object if they are separated tonally \u2014 with a single
+  // flat colour the chair silhouettes as a crate.
+  float partShade = vPart < 0.5 ? 0.50 : (vPart < 1.5 ? 1.10 : 0.80);
+  // Cheap vertical occlusion: a chair is in a dense row, so the closer a surface
+  // sits to the deck the less sky it can actually see. This is the depth cue \u2014
+  // without it the pad top, the back and the deck all resolve to the same flat
+  // value and the row loses its form entirely.
+  float ao = mix(0.58, 1.0, clamp(vHeight / 0.92, 0.0, 1.0));
+  vec3 base = tint * partShade * ao * (0.52 + 0.40 * hemi) + tint * key * 0.38 + tint * fill * 0.10;
+  float fres = pow(1.0 - max(dot(normalize(vNormalView), V), 0.0), 3.0);
+  // A brighter rim than the solids get: it picks out every chair's own edge,
+  // which is what stops a block of them merging into one mass up close.
+  base += vec3(0.26, 0.31, 0.38) * fres * 0.55;
+  base = mix(base, uFadeColor, vDim * 0.75);
+  fragColor = vec4(base, 1.0);
+}`
+);
 var BG_VERT = (
   /* glsl */
   `#version 300 es
@@ -3084,7 +4024,7 @@ function createSeatPickProgram(gl) {
     uniforms: {
       uSeatRadius: { value: SEAT_DOT_RADIUS_M },
       uSeatScale: { value: 1 },
-      uMinPixels: { value: 2.5 },
+      uMinPixels: { value: SEAT_MIN_PIXELS_NEAR },
       uPixelToWorld: { value: 2e-3 }
     }
   });
@@ -3129,11 +4069,32 @@ function createSeatProgram(gl) {
     uniforms: {
       uSeatRadius: { value: SEAT_DOT_RADIUS_M },
       uSeatScale: { value: 1 },
-      uMinPixels: { value: 2.5 },
+      uMinPixels: { value: SEAT_MIN_PIXELS_NEAR },
       uPixelToWorld: { value: 2e-3 },
       uSeatFade: { value: 0 },
       uFocusFloor: { value: -1 },
-      uFadeColor: { value: new Float32Array([0.32, 0.37, 0.43]) }
+      uFadeColor: { value: new Float32Array([0.32, 0.37, 0.43]) },
+      uChairFull: { value: CHAIR_FULL_M },
+      uChairNone: { value: CHAIR_NONE_M }
+    }
+  });
+}
+function createChairProgram(gl) {
+  return new import_ogl3.Program(gl, {
+    vertex: CHAIR_VERT,
+    fragment: CHAIR_FRAG,
+    transparent: false,
+    depthTest: true,
+    depthWrite: true,
+    cullFace: false,
+    uniforms: {
+      uKeyDir: { value: new Float32Array([0.38, 0.86, 0.34]) },
+      uFadeColor: { value: new Float32Array([0.32, 0.37, 0.43]) },
+      uChairFull: { value: CHAIR_FULL_M },
+      uChairNone: { value: CHAIR_NONE_M },
+      uBackRake: { value: BACK_RAKE_SLOPE },
+      uBackBase: { value: BACK_BASE_M },
+      uFocusFloor: { value: -1 }
     }
   });
 }
@@ -3199,16 +4160,90 @@ function buildGpuScene(gl, model) {
   seatMesh.frustumCulled = false;
   if (model.seats.count > 0) seatMesh.setParent(main);
   const colorAttr = seatGeo.attributes.iColor;
-  return {
+  const chairBase = buildChairMesh();
+  const chairProg = createChairProgram(gl);
+  const CAP = CHAIR_MAX_INSTANCES;
+  const cOffset = new Float32Array(CAP * 3);
+  const cColor = new Float32Array(CAP * 3);
+  const cRadius = new Float32Array(CAP);
+  const cYaw = new Float32Array(CAP);
+  const cRing = new Float32Array(CAP * 3);
+  const cFloor = new Float32Array(CAP);
+  const chairGeo = new import_ogl4.Geometry(gl, {
+    position: { size: 3, data: chairBase.position },
+    normal: { size: 3, data: chairBase.normal },
+    part: { size: 1, data: chairBase.part },
+    index: { data: chairBase.index },
+    iOffset: { size: 3, data: cOffset, instanced: 1 },
+    iColor: { size: 3, data: cColor, instanced: 1 },
+    iRadius: { size: 1, data: cRadius, instanced: 1 },
+    iYaw: { size: 1, data: cYaw, instanced: 1 },
+    iRing: { size: 3, data: cRing, instanced: 1 },
+    iFloor: { size: 1, data: cFloor, instanced: 1 }
+  });
+  const chairMesh = new import_ogl4.Mesh(gl, { geometry: chairGeo, program: chairProg });
+  chairMesh.frustumCulled = false;
+  let nearCount = 0;
+  let nearIndices = new Int32Array(0);
+  const writeChairColors = () => {
+    const src = model.seats;
+    for (let k = 0; k < nearCount; k++) {
+      const i = nearIndices[k];
+      const c = stateColors[src.iState[i]] ?? stateColors[0];
+      cColor[k * 3] = c[0];
+      cColor[k * 3 + 1] = c[1];
+      cColor[k * 3 + 2] = c[2];
+    }
+    chairGeo.attributes.iColor.needsUpdate = true;
+  };
+  const scene = {
     main,
     background,
     seatProgram: seatProg,
     solidProgram: solidProg,
+    chairProgram: chairProg,
     seatGeometry: seatGeo,
     solidGeometry: solidGeo,
     drawCalls: 3,
+    setNearSeats(indices, count) {
+      const n = Math.min(count, CAP);
+      nearIndices = indices;
+      nearCount = n;
+      if (n === 0) {
+        if (chairMesh.parent) chairMesh.setParent(null);
+        chairGeo.instancedCount = 0;
+        scene.drawCalls = 3;
+        return;
+      }
+      const src = model.seats;
+      for (let k = 0; k < n; k++) {
+        const i = indices[k];
+        cOffset[k * 3] = src.iPosition[i * 3];
+        cOffset[k * 3 + 1] = src.iPosition[i * 3 + 1];
+        cOffset[k * 3 + 2] = src.iPosition[i * 3 + 2];
+        cRadius[k] = src.iChairWidth[i];
+        cYaw[k] = src.iYaw[i];
+        cRing[k * 3] = src.iRing[i * 3];
+        cRing[k * 3 + 1] = src.iRing[i * 3 + 1];
+        cRing[k * 3 + 2] = src.iRing[i * 3 + 2];
+        cFloor[k] = src.iFloor[i];
+      }
+      writeChairColors();
+      chairGeo.attributes.iOffset.needsUpdate = true;
+      chairGeo.attributes.iRadius.needsUpdate = true;
+      chairGeo.attributes.iYaw.needsUpdate = true;
+      chairGeo.attributes.iRing.needsUpdate = true;
+      chairGeo.attributes.iFloor.needsUpdate = true;
+      chairGeo.instancedCount = n;
+      if (!chairMesh.parent) chairMesh.setParent(main);
+      scene.drawCalls = 4;
+    },
+    nearSeatCount() {
+      return nearCount;
+    },
     uploadSeatStateRuns(runs) {
       if (!runs.length) return;
+      if (nearCount) writeChairColors();
       for (const run of runs) writeSeatColors(iColor, model.seats.iState, run.start, run.length, stateColors);
       const buffer = colorAttr.buffer;
       if (!buffer) {
@@ -3228,8 +4263,11 @@ function buildGpuScene(gl, model) {
       solidProg.remove();
       seatGeo.remove();
       seatProg.remove();
+      chairGeo.remove();
+      chairProg.remove();
     }
   };
+  return scene;
 }
 
 // src/view3d/pick/pickPipeline.ts
@@ -3797,6 +4835,28 @@ function mountVenue3D(container, input, opts = {}) {
     gpu.seatProgram.uniforms.uSeatRadius.value = SEAT_DOT_RADIUS_M * model.theme.seatScale;
     gpu.seatProgram.uniforms.uFocusFloor.value = focusedFloor;
     gpu.solidProgram.uniforms.uFocusFloor.value = focusedFloor;
+    gpu.chairProgram.uniforms.uFocusFloor.value = focusedFloor;
+    lastGatherX = Infinity;
+  };
+  const nearIndex = new NearFieldIndex(model.seats.iPosition, model.seats.count);
+  const nearBuf = new Int32Array(CHAIR_MAX_INSTANCES);
+  let lastGatherX = Infinity;
+  let lastGatherZ = Infinity;
+  const updateNearField = () => {
+    if (!gpu) return;
+    const cam = orbit.camera.position;
+    const moved2 = Math.hypot(cam.x - lastGatherX, cam.z - lastGatherZ);
+    if (moved2 < CHAIR_REBUILD_M) return;
+    lastGatherX = cam.x;
+    lastGatherZ = cam.z;
+    const outside = Math.hypot(cam.x - model.bounds.center[0], cam.z - model.bounds.center[2]) - model.bounds.radius;
+    if (outside > CHAIR_GATHER_M) {
+      if (gpu.nearSeatCount()) gpu.setNearSeats(nearBuf, 0);
+      return;
+    }
+    const n = nearIndex.gather(cam.x, cam.z, CHAIR_GATHER_M, nearBuf);
+    if (n === 0 && gpu.nearSeatCount() === 0) return;
+    gpu.setNearSeats(nearBuf, n);
   };
   const glctx = new GLContext(container, {
     onContextLost: () => {
@@ -3843,7 +4903,9 @@ function mountVenue3D(container, input, opts = {}) {
     const u = gpu.seatProgram.uniforms;
     u.uSeatScale.value = lod.scale;
     u.uSeatFade.value = lod.fade;
+    u.uMinPixels.value = lod.minPixels;
     u.uPixelToWorld.value = 2 * Math.tan(orbit.camera.fov * DEG3 / 2) / Math.max(1, glctx.pixelHeight);
+    updateNearField();
     glctx.renderer.render({ scene: gpu.background, clear: true });
     glctx.renderer.render({ scene: gpu.main, camera: orbit.camera, clear: false });
     labelOverlay.update(
@@ -3851,7 +4913,10 @@ function mountVenue3D(container, input, opts = {}) {
       glctx.canvas.clientWidth || 1,
       glctx.canvas.clientHeight || 1,
       orbit.currentDistance,
-      model.bounds.radius
+      model.bounds.radius,
+      // The dense label rungs rank by real distance from the eye, not by the
+      // orbit radius — at the arrival pose those are wildly different numbers.
+      [orbit.camera.position.x, orbit.camera.position.y, orbit.camera.position.z]
     );
     return moving;
   });
@@ -4124,6 +5189,7 @@ function mountVenue3D(container, input, opts = {}) {
       if (gpu) {
         gpu.seatProgram.uniforms.uFocusFloor.value = value;
         gpu.solidProgram.uniforms.uFocusFloor.value = value;
+        gpu.chairProgram.uniforms.uFocusFloor.value = value;
       }
       focusedFloor = value;
       if (index !== null) {
@@ -4150,6 +5216,20 @@ function mountVenue3D(container, input, opts = {}) {
       loop.requestRender();
       return true;
     },
+    sections() {
+      return model.sections;
+    },
+    focusSection(sectionId) {
+      const sec = model.sections.find((s) => s.id === sectionId);
+      if (!sec || sec.seatCount === 0) return false;
+      cinematic.cancel();
+      const dx = sec.focalWorld[0] - sec.center[0];
+      const dz = sec.focalWorld[2] - sec.center[2];
+      const azimuth = Math.hypot(dx, dz) > sec.radius * 0.12 ? Math.atan2(dx, dz) : void 0;
+      orbit.frame({ center: sec.center, radius: sec.radius * 1.45 }, false, azimuth);
+      loop.requestRender();
+      return true;
+    },
     setReducedMotionForTest(value) {
       reducedForced = value;
     },