@seatlayer/core 0.50.2 → 0.52.0

package/dist/view3d/index.js

@@ -4,10 +4,11 @@ import {
   SEATED_EYE_HEIGHT_M,
   accessibilityRingColor,
   distanceToPolyline,
+  fitCircle,
   pointInPolygonWithHoles,
   resolveSection,
   sectionGeometry
-} from "../chunk-GD267BFB.js";
+} from "../chunk-UID7KN44.js";
 import {
   MAX_PITCH_DEG,
   VFOV_DEG,
@@ -455,7 +456,7 @@ var OrbitCamera = class {
    * then the damped `update()` eases it up into the 3/4 architectural angle and
    * dollies in — the venue "stands up" instead of teleporting (~600ms).
    */
-  frame(bounds, intro = false, stageAzimuth, portraitCrop = false) {
+  frame(bounds, intro = false, stageAzimuth, portraitCrop = false, framing) {
     this.target.set(bounds.center[0], bounds.center[1], bounds.center[2]);
     this.targetT.copy(this.target);
     this.panAnchor.copy(this.target);
@@ -465,9 +466,9 @@ var OrbitCamera = class {
     const aspect = portraitCrop ? Math.max(0.82, this.camera.aspect || 1) : this.camera.aspect || 1;
     const halfH = Math.atan(Math.tan(halfV) * aspect);
     this.azT = stageAzimuth ?? -30 * DEG;
-    this.polT = 55 * DEG;
+    this.polT = Math.max(15, Math.min(80, framing?.polarDeg ?? 55)) * DEG;
     const fit = this.fitDistance(bounds, halfV, halfH, this.azT, this.polT);
-    this.distT = fit * FRAME_MARGIN;
+    this.distT = fit * Math.max(1.05, Math.min(2, framing?.margin ?? FRAME_MARGIN));
     this.minDist = Math.max(2, r * 0.12);
     this.maxDist = fit * 4;
     if (intro) {
@@ -489,7 +490,7 @@ var OrbitCamera = class {
    * seat, behind the shell, anywhere): re-pivot on the venue centre without
    * moving the camera, then glide targets back to the 3/4 architectural pose.
    */
-  frameSoft(bounds, stageAzimuth, portraitCrop = false) {
+  frameSoft(bounds, stageAzimuth, portraitCrop = false, framing) {
     this.target.set(bounds.center[0], bounds.center[1], bounds.center[2]);
     this.targetT.copy(this.target);
     this.panAnchor.copy(this.target);
@@ -500,9 +501,9 @@ var OrbitCamera = class {
     const aspect = portraitCrop ? Math.max(0.82, this.camera.aspect || 1) : this.camera.aspect || 1;
     const halfH = Math.atan(Math.tan(halfV) * aspect);
     this.azT = stageAzimuth ?? this.azimuth;
-    this.polT = 55 * DEG;
+    this.polT = Math.max(15, Math.min(80, framing?.polarDeg ?? 55)) * DEG;
     const fit = this.fitDistance(bounds, halfV, halfH, this.azT, this.polT);
-    this.distT = fit * FRAME_MARGIN;
+    this.distT = fit * Math.max(1.05, Math.min(2, framing?.margin ?? FRAME_MARGIN));
   }
   /**
    * Distance from the bounds centre at which the venue fits the frustum at
@@ -518,14 +519,14 @@ var OrbitCamera = class {
    * every corner does. Clamped to the sphere fit (which always contains the
    * box) and floored so a degenerate box cannot glue the camera to the floor.
    */
-  fitDistance(bounds, halfV, halfH, azimuth, polar) {
+  fitDistance(bounds, halfV, halfH, azimuth, polar2) {
     const r = Math.max(1, bounds.radius);
     const sphereFit = Math.max(r / Math.tan(halfV), r / Math.tan(halfH));
     const box = bounds.box;
     if (!box) return sphereFit;
-    const sp = Math.sin(polar);
+    const sp = Math.sin(polar2);
     const fx = -sp * Math.sin(azimuth);
-    const fy = -Math.cos(polar);
+    const fy = -Math.cos(polar2);
     const fz = -sp * Math.cos(azimuth);
     if (Math.abs(fy) > 0.999) return sphereFit;
     let rx = -fz, rz = fx;
@@ -602,9 +603,9 @@ var OrbitCamera = class {
     const dy = this.camera.position.y - this.target.y;
     const dz = this.camera.position.z - this.target.z;
     const dist = Math.hypot(dx, dy, dz) || 1;
-    const polar = Math.max(POLAR_MIN, Math.min(POLAR_MAX, Math.acos(Math.max(-1, Math.min(1, dy / dist)))));
+    const polar2 = Math.max(POLAR_MIN, Math.min(POLAR_MAX, Math.acos(Math.max(-1, Math.min(1, dy / dist)))));
     this.distance = this.distT = dist;
-    this.polar = this.polT = polar;
+    this.polar = this.polT = polar2;
     this.azimuth = this.azT = Math.atan2(dx, dz);
   }
   /** Point the orbit pivot at a new world target without moving the camera. */
@@ -710,6 +711,20 @@ function computeSeatLod(distance, radius) {
     minPixels: SEAT_MIN_PIXELS_NEAR + t * (SEAT_MIN_PIXELS_FAR - SEAT_MIN_PIXELS_NEAR)
   };
 }
+function floorOverviewSeatDetailVisible(seatCount, viewportWidth, viewportHeight) {
+  if (!(seatCount > 0) || !(viewportWidth > 0) || !(viewportHeight > 0)) return false;
+  const pixelsPerSeat = viewportWidth * viewportHeight / seatCount;
+  return pixelsPerSeat >= 64;
+}
+function projectedSeatDetailVisible(seatCount, venueRadius, cameraDistance, fovYDeg, viewportHeightPx) {
+  if (!(seatCount > 0) || !(venueRadius > 0) || !(cameraDistance > 0)) return false;
+  if (!(fovYDeg > 0) || !(viewportHeightPx > 0)) return false;
+  const halfFov = Math.tan(fovYDeg / 2 * Math.PI / 180);
+  if (!(halfFov > 0)) return false;
+  const rPx = venueRadius / (cameraDistance * halfFov) * (viewportHeightPx / 2);
+  const projectedArea = Math.PI * rPx * rPx;
+  return projectedArea / seatCount >= 64;
+}
 
 // src/view3d/scene/nearField.ts
 var SEATS_PER_CELL = 4;
@@ -1661,17 +1676,45 @@ function themeSeatColorLUT(theme, order) {
 }
 
 // src/view3d/labels.ts
+function labelsForFloorView(labels, floorCount, focusedFloor) {
+  if (focusedFloor < 0) {
+    return floorCount > 1 ? labels.filter((label) => label.kind === "floor") : [...labels];
+  }
+  return labels.filter((label) => label.floorIndex === void 0 || label.floorIndex === focusedFloor);
+}
+function spreadFloorLabels(items, viewportWidth) {
+  const ordered = [...items].sort((left, right) => left.screen.y - right.screen.y);
+  const clusters = [];
+  for (const item of ordered) {
+    const cluster = clusters.find((candidate) => candidate.some((member) => Math.abs(member.screen.x - item.screen.x) < 104 && Math.abs(member.screen.y - item.screen.y) < 34));
+    if (cluster) cluster.push(item);
+    else clusters.push([item]);
+  }
+  return clusters.flatMap((cluster) => {
+    if (cluster.length < 2) return cluster;
+    return cluster.map((item, index) => ({
+      ...item,
+      screen: {
+        ...item.screen,
+        x: Math.max(54, Math.min(viewportWidth - 54, item.screen.x + (index - (cluster.length - 1) / 2) * 104))
+      }
+    }));
+  });
+}
 var ZONE_MIN_DISTANCE = 1.15;
-var SECTION_MAX_DISTANCE = 2.2;
+var SECTION_MAX_DISTANCE = 3.25;
+var SECTION_MAX_DISTANCE_NO_ZONES = 4.5;
 var NEAR_MAX_DISTANCE = 0.85;
 var ROW_MAX_DISTANCE = 0.5;
 var SEAT_MAX_DISTANCE = 0.26;
-function visibleLabelKinds(distance, venueRadius) {
+function visibleLabelKinds(distance, venueRadius, opts) {
   const r = Math.max(1e-6, venueRadius);
   const d = distance / r;
+  const hasZones = opts?.hasZoneLabels ?? true;
   const out = /* @__PURE__ */ new Set();
+  if (d >= 0.75) out.add("floor");
   if (d >= ZONE_MIN_DISTANCE) out.add("zone");
-  if (d <= SECTION_MAX_DISTANCE) {
+  if (d <= (hasZones ? SECTION_MAX_DISTANCE : SECTION_MAX_DISTANCE_NO_ZONES)) {
     out.add("section");
     out.add("ga");
   }
@@ -2455,7 +2498,7 @@ function pointInRing2(ring, x, y) {
   return inside;
 }
 var MAX_TIER_RISE_M = 25;
-function buildVenueSurfaces(units, seats) {
+function buildVenueSurfaces(units, seats, seatFloorIndices) {
   const bySection = /* @__PURE__ */ new Map();
   const seatOwner = new Array(seats.length).fill(null);
   const seatDeck = new Float64Array(seats.length);
@@ -2464,18 +2507,20 @@ function buildVenueSurfaces(units, seats) {
   const acc = /* @__PURE__ */ new Map();
   const boxes = [];
   const tableRowIds = /* @__PURE__ */ new Set();
-  for (const unit of units) {
+  for (let floorIndex = 0; floorIndex < units.length; floorIndex += 1) {
+    const unit = units[floorIndex];
     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 });
+      boxes.push({ id: o.id, floorIndex, 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 (seatFloorIndices && b.floorIndex !== seatFloorIndices[i]) continue;
       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;
@@ -2633,6 +2678,634 @@ function buildVenueSurfaces(units, seats) {
   };
 }
 
+// src/core/bowlProfile.ts
+var DEG2 = Math.PI / 180;
+var BIN_COUNT = 96;
+var GAP_FILL_BINS = 6;
+var MIN_ARC_DEG = 60;
+var MIN_RING_DEG = 150;
+var MIN_HOLE_RATIO = 0.2;
+var RING_OVERLAP_RATIO = 0.35;
+function bearingDeg(c, p) {
+  const d = Math.atan2(p.x - c.x, p.y - c.y) / DEG2;
+  return d < 0 ? d + 360 : d;
+}
+function median(values) {
+  if (!values.length) return NaN;
+  const s = [...values].sort((a, b) => a - b);
+  return s[Math.floor(s.length / 2)];
+}
+function smoothRun(values, wrap, window2 = 2) {
+  const n = values.length;
+  const out = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    let sum = 0, cnt = 0;
+    for (let k = -window2; k <= window2; k++) {
+      let j = i + k;
+      if (wrap) j = (j % n + n) % n;
+      else if (j < 0 || j >= n) continue;
+      sum += values[j];
+      cnt++;
+    }
+    out[i] = sum / cnt;
+  }
+  return out;
+}
+function fitBowlProfile(sections, focal) {
+  const usable = sections.filter((s) => s.rows.length >= 1);
+  if (usable.length < 1) return null;
+  const centres = [];
+  let cx = 0, cy = 0, np = 0;
+  for (const s of usable) {
+    for (const row of s.rows) {
+      for (const p of row.pts) {
+        cx += p.x;
+        cy += p.y;
+        np++;
+      }
+      if (row.pts.length >= 4) {
+        const c = fitCircle(row.pts);
+        if (c && Number.isFinite(c.cx) && Number.isFinite(c.cy)) centres.push({ x: c.cx, y: c.cy });
+      }
+    }
+  }
+  if (!np) return null;
+  const centroid2 = { x: cx / np, y: cy / np };
+  let centre = centroid2;
+  if (centres.length >= 8) {
+    const mx = median(centres.map((c) => c.x));
+    const my = median(centres.map((c) => c.y));
+    let spread = 0;
+    for (const s of usable) for (const row of s.rows) for (const p of row.pts) {
+      const d = Math.hypot(p.x - centroid2.x, p.y - centroid2.y);
+      if (d > spread) spread = d;
+    }
+    let near = 0;
+    const nearR = spread * 0.2;
+    for (const s of usable) for (const row of s.rows) for (const p of row.pts) {
+      if (Math.hypot(p.x - mx, p.y - my) < nearR) near++;
+    }
+    if (Math.hypot(mx - centroid2.x, my - centroid2.y) <= spread && near / np < 0.01) centre = { x: mx, y: my };
+  }
+  const stats = [];
+  for (const s of usable) {
+    const st = { sectionId: s.sectionId, rMin: Infinity, rMax: -Infinity, samples: [] };
+    for (const row of s.rows) {
+      for (const p of row.pts) {
+        const r = Math.hypot(p.x - centre.x, p.y - centre.y);
+        const bin = Math.min(BIN_COUNT - 1, Math.floor(bearingDeg(centre, p) / (360 / BIN_COUNT)));
+        st.samples.push({ r, bin, levelM: row.levelM });
+        if (r < st.rMin) st.rMin = r;
+        if (r > st.rMax) st.rMax = r;
+      }
+    }
+    if (st.samples.length) stats.push(st);
+  }
+  if (!stats.length) return null;
+  stats.sort((a, b) => a.rMin + a.rMax - (b.rMin + b.rMax));
+  const ringAccs = [];
+  for (const st of stats) {
+    let joined = false;
+    for (const ring of ringAccs) {
+      const overlap = Math.min(st.rMax, ring.rMax) - Math.max(st.rMin, ring.rMin);
+      const thinner = Math.min(st.rMax - st.rMin, ring.rMax - ring.rMin);
+      if (thinner > 1e-9 && overlap >= RING_OVERLAP_RATIO * thinner) {
+        ring.members.push(st);
+        ring.rMin = Math.min(ring.rMin, st.rMin);
+        ring.rMax = Math.max(ring.rMax, st.rMax);
+        joined = true;
+        break;
+      }
+    }
+    if (!joined) ringAccs.push({ members: [st], rMin: st.rMin, rMax: st.rMax });
+  }
+  const rings = [];
+  for (const ring of ringAccs) {
+    const bins = new Array(BIN_COUNT).fill(null);
+    for (const st of ring.members) {
+      for (const s of st.samples) {
+        let b = bins[s.bin];
+        if (!b) {
+          b = { samples: [] };
+          bins[s.bin] = b;
+        }
+        b.samples.push({ r: s.r, levelM: s.levelM });
+      }
+    }
+    const covered = bins.map((b) => !!b);
+    const coveredCount = covered.filter(Boolean).length;
+    if (!coveredCount) continue;
+    const innerSeed = [];
+    const outerSeed = [];
+    for (const b of bins) {
+      if (!b) continue;
+      let lo = Infinity, hi = -Infinity;
+      for (const s of b.samples) {
+        if (s.r < lo) lo = s.r;
+        if (s.r > hi) hi = s.r;
+      }
+      innerSeed.push(lo);
+      outerSeed.push(hi);
+    }
+    const innerRMedian = median(innerSeed);
+    const outerRMedian = median(outerSeed);
+    if (!(innerRMedian >= MIN_HOLE_RATIO * outerRMedian) || !(outerRMedian > 0)) continue;
+    const sortedInner = [...innerSeed].sort((a, b) => a - b);
+    const innerP10 = sortedInner[Math.floor(sortedInner.length * 0.1)];
+    if (!(innerP10 >= MIN_HOLE_RATIO * outerRMedian)) continue;
+    const vals = bins.map((b) => {
+      if (!b) return null;
+      const sorted = [...b.samples].sort((u, v) => u.r - v.r);
+      const inner = sorted[0].r;
+      const outer = sorted[sorted.length - 1].r;
+      const front = sorted[0].levelM;
+      let top = -Infinity;
+      for (const s of sorted) if (s.levelM > top) top = s.levelM;
+      const hull = [];
+      for (const s of sorted) {
+        const pt = { r: s.r, l: s.levelM };
+        while (hull.length && Math.abs(hull[hull.length - 1].r - pt.r) < 1e-9) {
+          if (hull[hull.length - 1].l <= pt.l) {
+            pt.skip = true;
+            break;
+          }
+          hull.pop();
+        }
+        if (pt.skip) continue;
+        while (hull.length >= 2) {
+          const a = hull[hull.length - 2], b2 = hull[hull.length - 1];
+          if ((b2.r - a.r) * (pt.l - a.l) - (b2.l - a.l) * (pt.r - a.r) <= 0) hull.pop();
+          else break;
+        }
+        hull.push(pt);
+      }
+      const rs = hull.map((p) => p.r);
+      const ls = hull.map((p) => p.l);
+      return { inner, outer, front, top, profile: { rs, ls } };
+    });
+    const filled = covered.slice();
+    for (let i = 0; i < BIN_COUNT; i++) {
+      if (filled[i]) continue;
+      let before = -1, after = -1, gap = 0;
+      for (let k = 1; k <= BIN_COUNT; k++) {
+        const j = (i - k + BIN_COUNT * 2) % BIN_COUNT;
+        if (filled[j]) {
+          before = j;
+          break;
+        }
+      }
+      for (let k = 1; k <= BIN_COUNT; k++) {
+        const j = (i + k) % BIN_COUNT;
+        if (filled[j]) {
+          after = j;
+          gap = k;
+          break;
+        }
+      }
+      if (before < 0 || after < 0) continue;
+      let back = 0;
+      for (let k = 1; k <= BIN_COUNT; k++) {
+        const j = (i - k + BIN_COUNT * 2) % BIN_COUNT;
+        if (covered[j]) {
+          back = k;
+          break;
+        }
+      }
+      const gapLen = back - 1 + gap;
+      if (gapLen > GAP_FILL_BINS) continue;
+      const a = vals[before], b = vals[after];
+      const t = back / (back + gap);
+      const inner = a.inner + (b.inner - a.inner) * t;
+      const outer = a.outer + (b.outer - a.outer) * t;
+      const front = a.front + (b.front - a.front) * t;
+      const top = a.top + (b.top - a.top) * t;
+      vals[i] = { inner, outer, front, top, profile: { rs: [inner, outer], ls: [front, top] } };
+    }
+    for (let i = 0; i < BIN_COUNT; i++) if (vals[i]) filled[i] = true;
+    const stepDeg = 360 / BIN_COUNT;
+    const arcs = [];
+    const filledCount = filled.filter(Boolean).length;
+    const runs = [];
+    if (filledCount === BIN_COUNT) {
+      runs.push({ start: 0, len: BIN_COUNT });
+    } else {
+      let scan = 0;
+      while (filled[scan]) scan = (scan + 1) % BIN_COUNT;
+      let runStart = -1;
+      for (let k = 0; k <= BIN_COUNT; k++) {
+        const j = (scan + k) % BIN_COUNT;
+        const on = k < BIN_COUNT && filled[j];
+        if (on && runStart < 0) runStart = j;
+        else if (!on && runStart >= 0) {
+          const len = (j - runStart + BIN_COUNT) % BIN_COUNT || BIN_COUNT;
+          runs.push({ start: runStart, len });
+          runStart = -1;
+        }
+      }
+    }
+    for (const run of runs) {
+      if (run.len * stepDeg < MIN_ARC_DEG && run.len < BIN_COUNT) continue;
+      const closed = run.len === BIN_COUNT;
+      const innerR = new Float64Array(run.len);
+      const outerR = new Float64Array(run.len);
+      const frontL = new Float64Array(run.len);
+      const topL = new Float64Array(run.len);
+      const profiles = [];
+      for (let k = 0; k < run.len; k++) {
+        const v = vals[(run.start + k) % BIN_COUNT];
+        innerR[k] = v.inner;
+        outerR[k] = v.outer;
+        frontL[k] = v.front;
+        topL[k] = v.top;
+        profiles.push(v.profile ?? { rs: [v.inner, v.outer], ls: [v.front, v.top] });
+      }
+      const sInner = smoothRun(innerR, closed);
+      const sOuter = smoothRun(outerR, closed);
+      const sFront = smoothRun(frontL, closed);
+      const sTop = smoothRun(topL, closed);
+      for (let k = 0; k < run.len; k++) {
+        if (sInner[k] > innerR[k]) sInner[k] = innerR[k];
+        if (sOuter[k] < outerR[k]) sOuter[k] = outerR[k];
+        if (sInner[k] > sOuter[k] - 1e-6) sInner[k] = Math.max(0, sOuter[k] - 1e-6);
+        if (sTop[k] < sFront[k]) sTop[k] = sFront[k];
+      }
+      const arc = { startBin: run.start, binCount: run.len, closed, innerR: sInner, outerR: sOuter, frontLevelM: sFront, topLevelM: sTop, profiles };
+      const clampProfile = (k, r, levelM) => {
+        const prof = profiles[k];
+        const rs = prof.rs, ls = prof.ls;
+        if (r <= rs[0]) {
+          if (ls[0] > levelM) ls[0] = levelM;
+          return;
+        }
+        if (r >= rs[rs.length - 1]) {
+          if (ls[ls.length - 1] > levelM) ls[ls.length - 1] = levelM;
+          return;
+        }
+        for (let j = 0; j + 1 < rs.length; j++) {
+          if (r <= rs[j + 1]) {
+            if (ls[j] > levelM) ls[j] = levelM;
+            if (ls[j + 1] > levelM) ls[j + 1] = levelM;
+            return;
+          }
+        }
+      };
+      for (let k = 0; k < run.len; k++) {
+        const b = bins[(run.start + k) % BIN_COUNT];
+        if (!b) continue;
+        for (const s of b.samples) {
+          clampProfile(k, s.r, s.levelM);
+          const prev = closed ? (k - 1 + run.len) % run.len : k - 1;
+          const next = closed ? (k + 1) % run.len : k + 1;
+          if (prev >= 0) clampProfile(prev, s.r, s.levelM);
+          if (next < run.len) clampProfile(next, s.r, s.levelM);
+        }
+      }
+      arcs.push(arc);
+    }
+    const totalDeg = arcs.reduce((sum, a) => sum + a.binCount * stepDeg, 0);
+    if (totalDeg < MIN_RING_DEG) continue;
+    rings.push({
+      arcs,
+      sectionIds: ring.members.map((m) => m.sectionId),
+      innerRMedian,
+      outerRMedian
+    });
+  }
+  if (!rings.length) return null;
+  rings.sort((a, b) => a.innerRMedian - b.innerRMedian);
+  if (focal) {
+    const outermost = rings[rings.length - 1].outerRMedian;
+    if (Math.hypot(focal.x - centre.x, focal.y - centre.y) > 0.9 * outermost) return null;
+  }
+  return { centre, binCount: BIN_COUNT, binStepDeg: 360 / BIN_COUNT, rings };
+}
+function arcLevelAt(fit, arc, bearing, r) {
+  const step = fit.binStepDeg;
+  let f = bearing / step - 0.5 - arc.startBin;
+  f = (f % fit.binCount + fit.binCount) % fit.binCount;
+  if (f > arc.binCount - 1) {
+    if (arc.closed) f = f - arc.binCount < arc.binCount - f ? 0 : arc.binCount - 1;
+    else f = f - (arc.binCount - 1) < fit.binCount - f ? arc.binCount - 1 : 0;
+  }
+  const i0 = Math.floor(f);
+  const i1 = arc.closed ? (i0 + 1) % arc.binCount : Math.min(arc.binCount - 1, i0 + 1);
+  const t = f - i0;
+  const sample = (i) => {
+    const prof = arc.profiles[i];
+    const rs = prof.rs, ls = prof.ls;
+    if (r <= rs[0]) return ls[0];
+    if (r >= rs[rs.length - 1]) return ls[ls.length - 1];
+    for (let k = 0; k + 1 < rs.length; k++) {
+      if (r <= rs[k + 1]) {
+        const span = rs[k + 1] - rs[k];
+        const u = span > 1e-9 ? (r - rs[k]) / span : 0;
+        return ls[k] + (ls[k + 1] - ls[k]) * u;
+      }
+    }
+    return ls[ls.length - 1];
+  };
+  return sample(i0) * (1 - t) + sample(i1) * t;
+}
+
+// src/view3d/scene/bowlShell.ts
+var BAND_RECESS_M = 0.25;
+var BAND_MIN_RELIEF_M = 1.2;
+var SHELL_GAP_M = 0.6;
+var SHELL_THICKNESS_M = 0.45;
+var SHELL_PARAPET_M = 2.3;
+var DEG3 = Math.PI / 180;
+function polar(c, r, thetaDeg) {
+  const t = thetaDeg * DEG3;
+  return { x: c.x + r * Math.sin(t), y: c.y + r * Math.cos(t) };
+}
+function hasAuthoredPerimeter(shapes, fit) {
+  const outer = fit.rings[fit.rings.length - 1];
+  if (!outer) return false;
+  const threshold = outer.outerRMedian * 0.85;
+  for (const s of shapes) {
+    if (s.role !== "wall") continue;
+    const pts = s.points && s.points.length >= 2 ? s.points : s.x !== void 0 && s.y !== void 0 && s.width !== void 0 && s.height !== void 0 ? [
+      { x: s.x, y: s.y },
+      { x: s.x + s.width, y: s.y },
+      { x: s.x + s.width, y: s.y + s.height },
+      { x: s.x, y: s.y + s.height }
+    ] : [];
+    if (pts.length < 2) continue;
+    let beyond = 0;
+    for (const p of pts) {
+      if (Math.hypot(p.x - fit.centre.x, p.y - fit.centre.y) >= threshold) beyond++;
+    }
+    if (beyond >= pts.length / 2) return true;
+  }
+  return false;
+}
+var BAND_RADIAL_CELLS = 24;
+function emitBandGrid(builder, fit, arc, innerEdge, outerEdge, bottomY, colors, ao, seatGuards) {
+  const K = arc.binCount;
+  const M2 = BAND_RADIAL_CELLS;
+  const U = METRES_PER_CHART_UNIT;
+  const floorY = bottomY + 0.02;
+  const h = [];
+  for (let k = 0; k < K; k++) {
+    const bearing = (arc.startBin + k + 0.5) * fit.binStepDeg;
+    const row = new Float64Array(M2 + 1);
+    for (let j = 0; j <= M2; j++) {
+      const r = innerEdge[k] + (outerEdge[k] - innerEdge[k]) * j / M2;
+      row[j] = Math.max(floorY, arcLevelAt(fit, arc, bearing, r) - BAND_RECESS_M);
+    }
+    h.push(row);
+  }
+  for (const g of seatGuards) {
+    const bearing = bearingDeg(fit.centre, g);
+    const r = Math.hypot(g.x - fit.centre.x, g.y - fit.centre.y);
+    let f = bearing / fit.binStepDeg - 0.5 - arc.startBin;
+    f = (f % fit.binCount + fit.binCount) % fit.binCount;
+    if (f > K - 1 && !arc.closed) {
+      if (f < K - 0.5 || f > fit.binCount - 0.5) {
+      } else continue;
+    }
+    const cap = g.deckY - BAND_RECESS_M;
+    const k0 = Math.min(K - 1, Math.max(0, Math.floor(f)));
+    const kk = [k0, arc.closed ? (k0 + 1) % K : Math.min(K - 1, k0 + 1)];
+    for (const k of kk) {
+      const span = outerEdge[k] - innerEdge[k];
+      if (!(span > 1e-9)) continue;
+      const jf = (r - innerEdge[k]) / span * M2;
+      if (jf < -0.75 || jf > M2 + 0.75) continue;
+      const j0 = Math.min(M2, Math.max(0, Math.floor(jf)));
+      const j1 = Math.min(M2, j0 + 1);
+      if (h[k][j0] > cap) h[k][j0] = Math.max(floorY, cap);
+      if (h[k][j1] > cap) h[k][j1] = Math.max(floorY, cap);
+    }
+  }
+  const cTop = [colors.bandTop[0] * ao.top, colors.bandTop[1] * ao.top, colors.bandTop[2] * ao.top];
+  const cBot = [colors.bandTop[0] * ao.bottomCap, colors.bandTop[1] * ao.bottomCap, colors.bandTop[2] * ao.bottomCap];
+  const cWallTop = [colors.bandWall[0] * ao.top, colors.bandWall[1] * ao.top, colors.bandWall[2] * ao.top];
+  const cWallBot = [colors.bandWall[0] * ao.wallBottom, colors.bandWall[1] * ao.wallBottom, colors.bandWall[2] * ao.wallBottom];
+  const point = (k, j) => {
+    const bearing = (arc.startBin + k + 0.5) * fit.binStepDeg;
+    const r = innerEdge[k] + (outerEdge[k] - innerEdge[k]) * j / M2;
+    const p = polar(fit.centre, r, bearing);
+    return [p.x * U, h[k][j], p.y * U];
+  };
+  {
+    const TAN_LIMIT = Math.tan(12 * Math.PI / 180);
+    for (let pass = 0; pass < 6; pass++) {
+      let changed = false;
+      for (let k = 0; k < K; k++) {
+        for (let j = M2 - 1; j >= 0; j--) {
+          if (h[k][j] > h[k][j + 1]) {
+            h[k][j] = h[k][j + 1];
+            changed = true;
+          }
+        }
+      }
+      const lastPair = arc.closed ? K : K - 1;
+      for (let k = 0; k < lastPair; k++) {
+        const k1 = (k + 1) % K;
+        for (let j = 0; j <= M2; j++) {
+          const d = h[k1][j] - h[k][j];
+          if (Math.abs(d) > 1) continue;
+          const r0 = innerEdge[k] + (outerEdge[k] - innerEdge[k]) * j / M2;
+          const r1 = innerEdge[k1] + (outerEdge[k1] - innerEdge[k1]) * j / M2;
+          const b0 = polar(fit.centre, r0, (arc.startBin + k + 0.5) * fit.binStepDeg);
+          const b1 = polar(fit.centre, r1, (arc.startBin + k1 + 0.5) * fit.binStepDeg);
+          const lim = TAN_LIMIT * Math.hypot(b1.x - b0.x, b1.y - b0.y) * U;
+          if (d > lim) {
+            h[k1][j] = h[k][j] + lim;
+            changed = true;
+          } else if (-d > lim) {
+            h[k][j] = h[k1][j] + lim;
+            changed = true;
+          }
+        }
+      }
+      if (!changed) break;
+    }
+  }
+  const JUMP_M = 1;
+  const cliffBetween = (k, k1) => {
+    for (let j = 0; j <= M2; j += 4) {
+      if (Math.abs(h[k][j] - h[k1][j]) > JUMP_M) return true;
+    }
+    return Math.abs(h[k][M2] - h[k1][M2]) > JUMP_M;
+  };
+  const TAN_WALL = Math.tan(38 * Math.PI / 180);
+  const radialCellM = (k) => (outerEdge[k] - innerEdge[k]) / M2 * U;
+  const radialStep = (k, j) => h[k][j + 1] - h[k][j] > TAN_WALL * Math.max(1e-6, radialCellM(k));
+  const vertexNormal = (k, j) => {
+    let kPrev = arc.closed ? (k - 1 + K) % K : Math.max(0, k - 1);
+    let kNext = arc.closed ? (k + 1) % K : Math.min(K - 1, k + 1);
+    if (Math.abs(h[kPrev][j] - h[k][j]) > JUMP_M) kPrev = k;
+    if (Math.abs(h[kNext][j] - h[k][j]) > JUMP_M) kNext = k;
+    let jPrev = Math.max(0, j - 1);
+    let jNext = Math.min(M2, j + 1);
+    if (jPrev < j && radialStep(k, jPrev)) jPrev = j;
+    if (jNext > j && radialStep(k, j)) jNext = j;
+    const pk0 = point(kPrev, j), pk1 = point(kNext, j);
+    const pj0 = point(k, jPrev), pj1 = point(k, jNext);
+    const ux = pk1[0] - pk0[0], uy = pk1[1] - pk0[1], uz = pk1[2] - pk0[2];
+    const vx = pj1[0] - pj0[0], vy = pj1[1] - pj0[1], vz = pj1[2] - pj0[2];
+    let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+    const len = Math.hypot(nx, ny, nz);
+    if (!(len > 1e-12)) return [0, 1, 0];
+    nx /= len;
+    ny /= len;
+    nz /= len;
+    if (ny < 0) {
+      nx = -nx;
+      ny = -ny;
+      nz = -nz;
+    }
+    return [nx, ny, nz];
+  };
+  const wallQuad = (a, b) => {
+    const a0 = [a[0], bottomY, a[2]];
+    const b0 = [b[0], bottomY, b[2]];
+    const ex = b[0] - a[0], ez = b[2] - a[2];
+    const len = Math.hypot(ex, ez);
+    if (!(len > 1e-12)) return;
+    const n = [ez / len, 0, -ex / len];
+    builder.tri(a, b, b0, n, cWallTop, cWallTop, cWallBot);
+    builder.tri(a, b0, a0, n, cWallTop, cWallBot, cWallBot);
+  };
+  const MIN_SPAN_U = 0.05 * CHART_UNITS_PER_METRE;
+  const pinched = (k) => outerEdge[k] - innerEdge[k] < MIN_SPAN_U;
+  const lastK = arc.closed ? K : K - 1;
+  for (let k = 0; k < lastK; k++) {
+    const k1 = (k + 1) % K;
+    if (pinched(k) || pinched(k1)) continue;
+    if (cliffBetween(k, k1)) {
+      const bearingMid = (arc.startBin + k + 1) * fit.binStepDeg;
+      const midAt = (side, j) => {
+        const rIn = (innerEdge[k] + innerEdge[k1]) / 2;
+        const rOut = (outerEdge[k] + outerEdge[k1]) / 2;
+        const r = rIn + (rOut - rIn) * j / M2;
+        const p = polar(fit.centre, r, bearingMid);
+        return [p.x * U, h[side][j], p.y * U];
+      };
+      for (let j = 0; j < M2; j++) {
+        const aL = point(k, j), dL = point(k, j + 1);
+        const bL = midAt(k, j), cL = midAt(k, j + 1);
+        const nL0 = vertexNormal(k, j), nL1 = vertexNormal(k, j + 1);
+        builder.triN(aL, bL, cL, nL0, nL0, nL1, cTop);
+        builder.triN(aL, cL, dL, nL0, nL1, nL1, cTop);
+        const bR = point(k1, j), cR = point(k1, j + 1);
+        const aR = midAt(k1, j), dR = midAt(k1, j + 1);
+        const nR0 = vertexNormal(k1, j), nR1 = vertexNormal(k1, j + 1);
+        builder.triN(aR, bR, cR, nR0, nR0, nR1, cTop);
+        builder.triN(aR, cR, dR, nR0, nR1, nR1, cTop);
+        const w0 = midAt(k, j), w1 = midAt(k, j + 1), w2 = midAt(k1, j + 1), w3 = midAt(k1, j);
+        const ex = w1[0] - w0[0], ez = w1[2] - w0[2];
+        const el = Math.hypot(ex, ez);
+        if (el > 1e-12) {
+          const n = [ez / el, 0, -ex / el];
+          builder.tri(w0, w1, w2, n, cWallTop);
+          builder.tri(w0, w2, w3, n, cWallTop);
+        }
+      }
+      const ai2 = point(k, 0), bi2 = point(k1, 0), ao_2 = point(k1, M2), di2 = point(k, M2);
+      const flat2 = (p) => [p[0], bottomY, p[2]];
+      builder.tri(flat2(ai2), flat2(ao_2), flat2(bi2), [0, -1, 0], cBot);
+      builder.tri(flat2(ai2), flat2(di2), flat2(ao_2), [0, -1, 0], cBot);
+      wallQuad(ai2, bi2);
+      wallQuad(di2, ao_2);
+      continue;
+    }
+    for (let j = 0; j < M2; j++) {
+      const na = vertexNormal(k, j), nb = vertexNormal(k1, j), nc = vertexNormal(k1, j + 1), nd = vertexNormal(k, j + 1);
+      if (radialStep(k, j) || radialStep(k1, j)) {
+        const midPt = (kk, hh) => {
+          const bearing = (arc.startBin + kk + 0.5) * fit.binStepDeg;
+          const r = innerEdge[kk] + (outerEdge[kk] - innerEdge[kk]) * (j + 0.5) / M2;
+          const p = polar(fit.centre, r, bearing);
+          return [p.x * U, hh, p.y * U];
+        };
+        const a2 = point(k, j), b2 = point(k1, j);
+        const mLo0 = midPt(k, h[k][j]), mLo1 = midPt(k1, h[k1][j]);
+        builder.triN(a2, b2, mLo1, na, nb, nb, cTop);
+        builder.triN(a2, mLo1, mLo0, na, nb, na, cTop);
+        const c2 = point(k1, j + 1), d2 = point(k, j + 1);
+        const mHi0 = midPt(k, h[k][j + 1]), mHi1 = midPt(k1, h[k1][j + 1]);
+        builder.triN(mHi0, mHi1, c2, nd, nc, nc, cTop);
+        builder.triN(mHi0, c2, d2, nd, nc, nd, cTop);
+        const ex = mLo1[0] - mLo0[0], ez = mLo1[2] - mLo0[2];
+        const el = Math.hypot(ex, ez);
+        if (el > 1e-12) {
+          const n = [-ez / el, 0, ex / el];
+          builder.tri(mLo0, mLo1, mHi1, n, cWallTop);
+          builder.tri(mLo0, mHi1, mHi0, n, cWallTop);
+        }
+        continue;
+      }
+      const a = point(k, j), b = point(k1, j), c = point(k1, j + 1), d = point(k, j + 1);
+      builder.triN(a, b, c, na, nb, nc, cTop);
+      builder.triN(a, c, d, na, nc, nd, cTop);
+    }
+    const ai = point(k, 0), bi = point(k1, 0), ao_ = point(k1, M2), di = point(k, M2);
+    const flat = (p) => [p[0], bottomY, p[2]];
+    builder.tri(flat(ai), flat(ao_), flat(bi), [0, -1, 0], cBot);
+    builder.tri(flat(ai), flat(di), flat(ao_), [0, -1, 0], cBot);
+    wallQuad(ai, bi);
+    wallQuad(di, ao_);
+  }
+  if (!arc.closed) {
+    for (const k of [0, K - 1]) {
+      for (let j = 0; j < M2; j++) wallQuad(point(k, j), point(k, j + 1));
+    }
+  }
+}
+function emitBowlGeometry(builder, fit, opts) {
+  const { bottomY, colors, ao } = opts;
+  const drawnOuter = new Float64Array(fit.binCount).fill(-Infinity);
+  for (const ring of fit.rings) {
+    for (const arc of ring.arcs) {
+      const innerEdge = new Float64Array(arc.binCount);
+      const outerEdge = new Float64Array(arc.binCount);
+      for (let k = 0; k < arc.binCount; k++) {
+        const bin = (arc.startBin + k) % fit.binCount;
+        const inner = Math.max(0, arc.innerR[k] - SEAT_OWNERSHIP_PAD_U);
+        innerEdge[k] = Math.max(inner, drawnOuter[bin] + 1e-3);
+        outerEdge[k] = Math.max(innerEdge[k] + 1e-3, arc.outerR[k] + SEAT_OWNERSHIP_PAD_U);
+      }
+      let relief = 0;
+      for (let k = 0; k < arc.binCount; k++) {
+        const d = arc.topLevelM[k] - bottomY;
+        if (d > relief) relief = d;
+      }
+      if (relief >= BAND_MIN_RELIEF_M) {
+        emitBandGrid(builder, fit, arc, innerEdge, outerEdge, bottomY, colors, ao, opts.seatGuards);
+      }
+      for (let k = 0; k < arc.binCount; k++) {
+        const bin = (arc.startBin + k) % fit.binCount;
+        if (outerEdge[k] > drawnOuter[bin]) drawnOuter[bin] = outerEdge[k];
+      }
+    }
+  }
+  if (hasAuthoredPerimeter(opts.shapes, fit)) return;
+  const outerRing = fit.rings[fit.rings.length - 1];
+  const gapU = SHELL_GAP_M * CHART_UNITS_PER_METRE;
+  const thickU = SHELL_THICKNESS_M * CHART_UNITS_PER_METRE;
+  for (const arc of outerRing.arcs) {
+    const inner = [];
+    const outer = [];
+    for (let k = 0; k < arc.binCount; k++) {
+      const bearing = (arc.startBin + k + 0.5) * fit.binStepDeg;
+      const r0 = arc.outerR[k] + SEAT_OWNERSHIP_PAD_U + gapU;
+      inner.push(polar(fit.centre, r0, bearing));
+      outer.push(polar(fit.centre, r0 + thickU, bearing));
+    }
+    let crest = -Infinity;
+    for (let k = 0; k < arc.binCount; k++) if (arc.topLevelM[k] > crest) crest = arc.topLevelM[k];
+    const topY = () => crest + SHELL_PARAPET_M;
+    if (arc.closed) {
+      extrudePrism(builder, outer, [inner.slice().reverse()], topY, bottomY, colors.shellTop, colors.shellWall, ao);
+    } else {
+      extrudePrism(builder, [...outer, ...inner.slice().reverse()], void 0, topY, bottomY, colors.shellTop, colors.shellWall, ao);
+    }
+  }
+}
+
 // src/view3d/scene/sceneModel.ts
 function shapeVisibleInConfiguration(shape, activeConfigurationId) {
   const ids = shape.eventConfigurationIds;
@@ -2642,14 +3315,28 @@ function visibleObjects(objects, activeConfigurationId) {
   return objects.filter((object) => object.type !== "shape" || shapeVisibleInConfiguration(object, activeConfigurationId));
 }
 function floorUnits(doc, activeConfigurationId) {
+  const docFocal = doc.focalPoint ?? { x: 0, y: 0 };
   if (doc.floors?.length) {
-    return doc.floors.map((f) => ({
+    return doc.floors.map((f, index) => ({
       objects: visibleObjects(f.objects, activeConfigurationId),
-      focal: f.focalPoint ?? doc.focalPoint,
-      baseHeightM: f.baseHeightM ?? 0
+      focal: {
+        x: (f.focalPoint ?? docFocal).x,
+        y: (f.focalPoint ?? docFocal).y
+      },
+      baseHeightM: f.baseHeightM ?? 0,
+      index
+      // 2D deliberately packs levels into a non-overlapping grid. In 3D the
+      // physical datum already separates them, so retaining each floor's
+      // authored x/z registration is what turns independent drawings into one
+      // coherent building stack. The source scene graph is never rewritten.
     }));
   }
-  return [{ objects: visibleObjects(doc.objects, activeConfigurationId), focal: doc.focalPoint, baseHeightM: 0 }];
+  return [{
+    objects: visibleObjects(doc.objects, activeConfigurationId),
+    focal: docFocal,
+    baseHeightM: 0,
+    index: 0
+  }];
 }
 var AO = { top: 1, wallBottom: 0.5, bottomCap: 0.4 };
 function tintTop(fill, neutral) {
@@ -2824,6 +3511,79 @@ function buildTier(builder, section, unit, fill, surface, claimed, siblings, S)
     extrudePrism(builder, ring, section.holes, topY, bottomY, colTop, S.tierWall, AO, maxErr, topN);
   }
 }
+function collectBowlSamples(unit, seats, surfaces) {
+  const unitSections = /* @__PURE__ */ new Set();
+  for (const o of unit.objects) if (o.type === "section") unitSections.add(o.id);
+  const flatRows = /* @__PURE__ */ new Map();
+  for (let i = 0; i < seats.length; i++) {
+    const owner = surfaces.seatOwner[i];
+    if (!owner || !unitSections.has(owner)) continue;
+    const surf = surfaces.bySection.get(owner);
+    if (surf && surf.rowLevels.length >= 2) continue;
+    const s = seats[i];
+    let rows = flatRows.get(owner);
+    if (!rows) {
+      rows = /* @__PURE__ */ new Map();
+      flatRows.set(owner, rows);
+    }
+    const key = s.rowId || `__seat-${i}`;
+    let row = rows.get(key);
+    if (!row) {
+      row = { pts: [], levelM: 0, n: 0 };
+      rows.set(key, row);
+    }
+    row.pts.push({ x: s.x, y: s.y });
+    row.levelM += surfaces.seatDeckY(i);
+    row.n++;
+  }
+  const samples = [];
+  for (const o of unit.objects) {
+    if (o.type !== "section") continue;
+    const surf = surfaces.bySection.get(o.id);
+    if (surf && surf.rowLevels.length >= 2) {
+      const rows2 = surf.rowLevels.filter((r) => !r.patch).map((r) => ({ pts: r.pts, levelM: r.y }));
+      if (rows2.length >= 2) samples.push({ sectionId: o.id, rows: rows2 });
+      continue;
+    }
+    const rows = flatRows.get(o.id);
+    if (!rows) continue;
+    samples.push({
+      sectionId: o.id,
+      rows: [...rows.values()].map((r) => ({ pts: r.pts, levelM: r.levelM / r.n }))
+    });
+  }
+  return samples;
+}
+function buildBowl(builder, unit, seats, surfaces, S) {
+  const samples = collectBowlSamples(unit, seats, surfaces);
+  if (!samples.length) return;
+  const fit = fitBowlProfile(samples, unit.focal);
+  if (!fit) return;
+  const unitSections = /* @__PURE__ */ new Set();
+  for (const o of unit.objects) if (o.type === "section") unitSections.add(o.id);
+  const seatGuards = [];
+  for (let i = 0; i < seats.length; i++) {
+    const owner = surfaces.seatOwner[i];
+    if (owner ? unitSections.has(owner) : true) {
+      seatGuards.push({ x: seats[i].x, y: seats[i].y, deckY: surfaces.seatDeckY(i) });
+    }
+  }
+  builder.setMaterial(0);
+  emitBowlGeometry(builder, fit, {
+    bottomY: unit.baseHeightM,
+    colors: {
+      // A shade below the tier caps, so stands read as decks resting ON the
+      // bowl rather than the bowl swallowing them.
+      bandTop: scaleRgb(S.tierTop, 0.8),
+      bandWall: S.tierWall,
+      shellTop: scaleRgb(S.tierWall, 1.15),
+      shellWall: S.tierWall
+    },
+    ao: AO,
+    shapes: unit.objects.filter((o) => o.type === "shape"),
+    seatGuards
+  });
+}
 function coplanarLevels(a, b) {
   if (a === void 0 || b === void 0) return true;
   return Math.abs(a - b) < 1e-3;
@@ -2989,7 +3749,11 @@ function architectureForShape(shape) {
     restroom: { kind: "solid", heightM: 2.4 },
     bar: { kind: "solid", heightM: 1.1 },
     concession: { kind: "solid", heightM: 1.1 },
-    coat: { kind: "solid", heightM: 1.1 }
+    coat: { kind: "solid", heightM: 1.1 },
+    // Sports-surface imports describe a goal as one thin rectangular portal.
+    // It therefore becomes a real open goal frame in 3D without a bespoke
+    // chart model or a copied bitmap.
+    goal: { kind: "portal", heightM: 1.8 }
   };
   const resolved = defaults[role] ?? { kind: "plate", heightM: 0.25 };
   return { ...resolved, heightM: shape.heightM ?? resolved.heightM };
@@ -3188,20 +3952,46 @@ function chartFootprint(units, seats) {
   return { minX, minY, maxX, maxY };
 }
 function buildSceneModel(input) {
-  const { doc, seats } = input;
+  const { doc } = input;
   const theme = resolveTheme3D(doc.theme);
   const S = theme.structure;
   const units = floorUnits(doc, input.eventConfigurationId ?? doc.eventConfigurationId);
+  const seats = input.seats;
   const builder = new MeshBuilder();
+  const floorByOwner = /* @__PURE__ */ new Map();
+  for (const unit of units) {
+    for (const object of unit.objects) {
+      floorByOwner.set(object.id, unit.index);
+      if (object.type === "section") floorByOwner.set(object.logicalSectionId ?? object.id, unit.index);
+    }
+  }
+  const hintedSeatFloor = seats.map((seat) => floorByOwner.get(seat.sectionId ?? "") ?? floorByOwner.get(seat.rowId ?? "") ?? 0);
   const fp = chartFootprint(units, seats);
-  const padU = Math.max(60, (fp.maxX - fp.minX + fp.maxY - fp.minY) * 0.06);
-  const groundPoly = rectPolygon(fp.minX - padU, fp.minY - padU, fp.maxX - fp.minX + padU * 2, fp.maxY - fp.minY + padU * 2);
-  extrudePrism(builder, groundPoly, void 0, () => 0, -0.4, S.ground, S.ground, AO);
+  if (units.length === 1) {
+    const padU = Math.max(60, (fp.maxX - fp.minX + fp.maxY - fp.minY) * 0.06);
+    const groundPoly = rectPolygon(fp.minX - padU, fp.minY - padU, fp.maxX - fp.minX + padU * 2, fp.maxY - fp.minY + padU * 2);
+    extrudePrism(builder, groundPoly, void 0, () => 0, -0.4, S.ground, S.ground, AO);
+  } else {
+    const unit = units.reduce((lowest, candidate) => candidate.baseHeightM < lowest.baseHeightM ? candidate : lowest);
+    builder.setFloor(unit.index);
+    const unitSeats = seats.filter((_seat, index) => hintedSeatFloor[index] === unit.index);
+    const floorFp = chartFootprint([unit], unitSeats);
+    const span = Math.hypot(floorFp.maxX - floorFp.minX, floorFp.maxY - floorFp.minY);
+    const padU = Math.max(28, Math.min(80, span * 0.04));
+    const plinth = rectPolygon(
+      floorFp.minX - padU,
+      floorFp.minY - padU,
+      floorFp.maxX - floorFp.minX + padU * 2,
+      floorFp.maxY - floorFp.minY + padU * 2
+    );
+    const top = unit.baseHeightM - 0.03;
+    extrudePrism(builder, plinth, void 0, () => top, top - 0.22, S.ground, S.ground, AO);
+  }
   const sectionFills = resolveSectionFills(doc, seats);
   const catColor = /* @__PURE__ */ new Map();
   for (const c of doc.categories ?? []) catColor.set(c.key, c.color);
   const stageBounds = [];
-  const surfaces = buildVenueSurfaces(units, seats);
+  const surfaces = buildVenueSurfaces(units, seats, hintedSeatFloor);
   const seatFloor = new Float32Array(seats.length);
   for (let unitIndex = 0; unitIndex < units.length; unitIndex++) {
     const unit = units[unitIndex];
@@ -3228,8 +4018,12 @@ function buildSceneModel(input) {
       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);
     }
+    buildBowl(builder, unit, seats, surfaces, S);
   }
-  const focal = doc.focalPoint ?? { x: (fp.minX + fp.maxX) / 2, y: (fp.minY + fp.maxY) / 2 };
+  const focal = units.length > 1 ? {
+    x: units.reduce((sum, unit) => sum + unit.focal.x, 0) / units.length,
+    y: units.reduce((sum, unit) => sum + unit.focal.y, 0) / units.length
+  } : doc.focalPoint ?? { x: (fp.minX + fp.maxX) / 2, y: (fp.minY + fp.maxY) / 2 };
   const solids = mergeMeshData([builder.build()]);
   const seatData = buildSeatInstances(seats, input.initialState, surfaces, seatFloor, catColor);
   const zoneDefs = doc.zones ?? [];
@@ -3335,9 +4129,11 @@ function buildSceneModel(input) {
         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];
+        const sectionLabel = o.displayLabel || o.label || o.id;
         sections.push({
           id: o.id,
-          label: o.displayLabel || o.label || o.id,
+          floorIndex: unit.index,
+          label: sectionLabel,
           seatCount: a.n,
           center: centre,
           // Half-diagonal of the seat extent — the same fit the zones use.
@@ -3346,13 +4142,17 @@ function buildSceneModel(input) {
           // 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: [centre[0], centre[1] + SECTION_LABEL_LIFT_M, centre[2]]
-        });
+        const floorLabel = doc.floors?.[unit.index]?.name?.trim().toLocaleLowerCase();
+        if (!(units.length > 1 && floorLabel === sectionLabel.trim().toLocaleLowerCase())) {
+          labels.push({
+            id: `section:${o.id}`,
+            kind: "section",
+            // The buyer-facing name wins over the technical one, as it does in 2D.
+            text: sectionLabel,
+            anchor: [centre[0], centre[1] + SECTION_LABEL_LIFT_M, centre[2]],
+            floorIndex: unit.index
+          });
+        }
       }
     }
   }
@@ -3367,7 +4167,8 @@ function buildSceneModel(input) {
           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]
+          anchor: [c.x * M, unit.baseHeightM + GA_LABEL_LIFT_M, c.y * M],
+          floorIndex: unit.index
         });
       }
     }
@@ -3386,7 +4187,8 @@ function buildSceneModel(input) {
         id: `row:${rowId}`,
         kind: "row",
         text,
-        anchor: [end.seat.x * M, surfaces.seatDeckY(end.index) + ROW_LABEL_LIFT_M, end.seat.y * M]
+        anchor: [end.seat.x * M, surfaces.seatDeckY(end.index) + ROW_LABEL_LIFT_M, end.seat.y * M],
+        floorIndex: hintedSeatFloor[end.index]
       });
     }
     const rowAcc = /* @__PURE__ */ new Map();
@@ -3441,7 +4243,8 @@ function buildSceneModel(input) {
           id: `seat:${s.id}`,
           kind: "seat",
           text,
-          anchor: [s.x * M, surfaces.seatDeckY(i) + SEAT_LABEL_LIFT_M, s.y * M]
+          anchor: [s.x * M, surfaces.seatDeckY(i) + SEAT_LABEL_LIFT_M, s.y * M],
+          floorIndex: hintedSeatFloor[i]
         });
       }
     }
@@ -3457,7 +4260,8 @@ function buildSceneModel(input) {
           kind: "annotation",
           text: o.label,
           anchor: [centre.x * M, unit.baseHeightM + architectureForShape(o).heightM + ANNOTATION_LIFT_M, centre.y * M],
-          color: o.fill
+          color: o.fill,
+          floorIndex: unit.index
         });
       } else if (o.type === "text") {
         if (!o.text) continue;
@@ -3467,7 +4271,8 @@ function buildSceneModel(input) {
           text: o.text,
           anchor: [o.position.x * M, unit.baseHeightM + ANNOTATION_LIFT_M, o.position.y * M],
           color: o.color,
-          rotation: o.rotation
+          rotation: o.rotation,
+          floorIndex: unit.index
         });
       } else if (o.type === "booth") {
         const poly = boothPolygon(o);
@@ -3478,21 +4283,52 @@ function buildSceneModel(input) {
           id: `booth:${o.id}`,
           kind: "booth",
           text: o.displayLabel || o.label || o.id,
-          anchor: [c.x * M, unit.baseHeightM + BOOTH_HEIGHT_M + BOOTH_LABEL_LIFT_M, c.y * M]
+          anchor: [c.x * M, unit.baseHeightM + BOOTH_HEIGHT_M + BOOTH_LABEL_LIFT_M, c.y * M],
+          floorIndex: unit.index
         });
       }
     }
   }
   const floors = [];
   {
+    const solidBounds = units.map(() => ({
+      minX: Infinity,
+      minY: Infinity,
+      minZ: Infinity,
+      maxX: -Infinity,
+      maxY: -Infinity,
+      maxZ: -Infinity
+    }));
+    for (let vertex = 0; vertex < solids.floor.length; vertex += 1) {
+      const floorIndex = Math.max(0, Math.min(units.length - 1, Math.round(solids.floor[vertex])));
+      const offset = vertex * 3;
+      const bound = solidBounds[floorIndex];
+      bound.minX = Math.min(bound.minX, solids.position[offset]);
+      bound.minY = Math.min(bound.minY, solids.position[offset + 1]);
+      bound.minZ = Math.min(bound.minZ, solids.position[offset + 2]);
+      bound.maxX = Math.max(bound.maxX, solids.position[offset]);
+      bound.maxY = Math.max(bound.maxY, solids.position[offset + 1]);
+      bound.maxZ = Math.max(bound.maxZ, solids.position[offset + 2]);
+    }
     const sectionFloor = /* @__PURE__ */ new Map();
     for (let ui = 0; ui < units.length; ui++) {
       for (const o of units[ui].objects) if (o.type === "section") sectionFloor.set(o.id, ui);
     }
-    const acc = units.map(() => ({ n: 0, minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity, sumY: 0 }));
+    const acc = units.map(() => ({
+      n: 0,
+      minX: Infinity,
+      minY: Infinity,
+      minDeck: Infinity,
+      maxX: -Infinity,
+      maxY: -Infinity,
+      maxDeck: -Infinity,
+      sumX: 0,
+      sumDeck: 0,
+      sumZ: 0
+    }));
     for (let i = 0; i < seats.length; i++) {
       const owner = surfaces.seatOwner[i];
-      const ui = owner !== null ? sectionFloor.get(owner) : void 0;
+      const ui = (owner !== null ? sectionFloor.get(owner) : void 0) ?? hintedSeatFloor[i];
       if (ui === void 0) continue;
       const a = acc[ui];
       const s = seats[i];
@@ -3501,19 +4337,78 @@ function buildSceneModel(input) {
       if (s.y < a.minY) a.minY = s.y;
       if (s.x > a.maxX) a.maxX = s.x;
       if (s.y > a.maxY) a.maxY = s.y;
-      a.sumY += surfaces.seatDeckY(i);
+      const deck = surfaces.seatDeckY(i);
+      a.sumX += s.x * M;
+      a.sumDeck += deck;
+      a.sumZ += s.y * M;
+      a.minDeck = Math.min(a.minDeck, deck);
+      a.maxDeck = Math.max(a.maxDeck, deck + 1.6);
       seatFloor[i] = ui;
     }
     for (let ui = 0; ui < units.length; ui++) {
       const a = acc[ui];
       const f = doc.floors?.[ui];
+      const solid = solidBounds[ui];
+      const minWorldX = Math.min(
+        a.n ? a.minX * M : units[ui].focal.x * M - 1,
+        Number.isFinite(solid.minX) ? solid.minX : Infinity
+      );
+      const maxWorldX = Math.max(
+        a.n ? a.maxX * M : units[ui].focal.x * M + 1,
+        Number.isFinite(solid.maxX) ? solid.maxX : -Infinity
+      );
+      const minWorldZ = Math.min(
+        a.n ? a.minY * M : units[ui].focal.y * M - 1,
+        Number.isFinite(solid.minZ) ? solid.minZ : Infinity
+      );
+      const maxWorldZ = Math.max(
+        a.n ? a.maxY * M : units[ui].focal.y * M + 1,
+        Number.isFinite(solid.maxZ) ? solid.maxZ : -Infinity
+      );
+      const minWorldY = Math.min(
+        a.n ? Math.min(units[ui].baseHeightM, a.minDeck) : units[ui].baseHeightM,
+        Number.isFinite(solid.minY) ? solid.minY : Infinity
+      );
+      const maxWorldY = Math.max(
+        a.n ? Math.max(a.maxDeck, minWorldY + 0.5) : minWorldY + 0.5,
+        Number.isFinite(solid.maxY) ? solid.maxY : -Infinity
+      );
+      const center = [
+        // Aim the floor camera at its sellable topology rather than the centre
+        // of a generous imported outline/plinth. The complete box is still
+        // fitted below, so stages, annotations and deck edges cannot clip.
+        a.n ? a.sumX / a.n : (minWorldX + maxWorldX) / 2,
+        a.n ? a.sumDeck / a.n : (minWorldY + maxWorldY) / 2,
+        a.n ? a.sumZ / a.n : (minWorldZ + maxWorldZ) / 2
+      ];
+      const radius2 = Math.max(1, 0.5 * Math.hypot(
+        maxWorldX - minWorldX,
+        maxWorldY - minWorldY,
+        maxWorldZ - minWorldZ
+      ));
       floors.push({
         index: ui,
         id: f?.id ?? `floor-${ui}`,
         label: f?.name ?? (units.length > 1 ? `Floor ${ui + 1}` : "Venue"),
         seatCount: a.n,
-        center: a.n ? [(a.minX + a.maxX) / 2 * M, a.sumY / a.n, (a.minY + a.maxY) / 2 * M] : [0, 0, 0],
-        radius: a.n ? 0.5 * Math.hypot((a.maxX - a.minX) * M, (a.maxY - a.minY) * M) || 1 : 0
+        center,
+        radius: radius2,
+        box: {
+          min: [minWorldX, minWorldY, minWorldZ],
+          max: [maxWorldX, maxWorldY, maxWorldZ]
+        },
+        focalWorld: [units[ui].focal.x * M, units[ui].baseHeightM + 1.5, units[ui].focal.y * M]
+      });
+    }
+  }
+  if (floors.length > 1) {
+    for (const floor of floors) {
+      labels.push({
+        id: `floor:${floor.id}`,
+        kind: "floor",
+        text: floor.label,
+        anchor: [floor.center[0], floor.box.max[1] + 1.2, floor.center[2]],
+        floorIndex: floor.index
       });
     }
   }
@@ -3591,18 +4486,20 @@ function buildSceneModel(input) {
     boxMinZ = Math.max(fpMinZ, contentMinZ - pad);
     boxMaxZ = Math.min(fpMaxZ, contentMaxZ + pad);
   }
+  const boxMinY = Math.min(0, renderMinY);
+  const boxMaxY = Math.max(renderMaxY, radius * 0.05);
   return {
     solids,
     seats: seatData,
     bounds: {
       // Centred on the CONTENT box, so an off-centre table cluster arrives
       // centred on screen instead of wherever the floor's midpoint put it.
-      center: [(boxMinX + boxMaxX) / 2, radius * 0.08, (boxMinZ + boxMaxZ) / 2],
+      center: [(boxMinX + boxMaxX) / 2, (boxMinY + boxMaxY) / 2, (boxMinZ + boxMaxZ) / 2],
       radius,
       groundY: 0,
       box: {
-        min: [boxMinX, Math.min(0, renderMinY), boxMinZ],
-        max: [boxMaxX, Math.max(renderMaxY, radius * 0.05), boxMaxZ]
+        min: [boxMinX, boxMinY, boxMinZ],
+        max: [boxMaxX, boxMaxY, boxMaxZ]
       }
     },
     renderBounds: { center: renderCenter, radius: renderRadius },
@@ -3624,6 +4521,7 @@ function buildSceneModel(input) {
 var SEPARATION_X_PX = 88;
 var SEPARATION_Y_PX = 20;
 var KIND_STYLE = {
+  floor: { size: 14, weight: "700", opacity: 0.98 },
   zone: { size: 15, weight: "600", opacity: 0.95 },
   section: { size: 12, weight: "500", opacity: 0.88 },
   ga: { size: 12, weight: "500", opacity: 0.88 },
@@ -3644,6 +4542,27 @@ var DENSE_SEPARATION = {
   // seating instead of clustering into one stack.
   seat: { x: 46, y: 18 }
 };
+function hexRgb(value) {
+  const match = /^#([0-9a-f]{6})$/i.exec(value?.trim() ?? "");
+  if (!match) return null;
+  return [0, 2, 4].map((offset) => Number.parseInt(match[1].slice(offset, offset + 2), 16) / 255);
+}
+function luminance(rgb) {
+  const linear = (channel) => channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * linear(rgb[0]) + 0.7152 * linear(rgb[1]) + 0.0722 * linear(rgb[2]);
+}
+function ratio(left, right) {
+  const a = luminance(left);
+  const b = luminance(right);
+  return (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
+}
+function resolve3dLabelTreatment(preferredInk, backgroundRgb = [0.04, 0.06, 0.1]) {
+  const darkScene = luminance(backgroundRgb) < 0.42;
+  const fallbackInk = darkScene ? "#f4f7fb" : "#0b1220";
+  const authored = hexRgb(preferredInk);
+  const ink = authored && ratio(authored, backgroundRgb) >= 4.5 ? preferredInk : fallbackInk;
+  return darkScene ? { ink, backing: "rgba(8,12,22,.78)", border: "rgba(210,222,245,.24)" } : { ink, backing: "rgba(255,255,255,.84)", border: "rgba(11,18,32,.22)" };
+}
 var LabelOverlay = class {
   constructor(container, opts = {}) {
     this.nodes = /* @__PURE__ */ new Map();
@@ -3702,7 +4621,9 @@ var LabelOverlay = class {
    */
   update(viewProjection, width, height, cameraDistance, venueRadius, cameraWorld) {
     if (!this.labels.length) return;
-    const kinds = visibleLabelKinds(cameraDistance, venueRadius);
+    const kinds = visibleLabelKinds(cameraDistance, venueRadius, {
+      hasZoneLabels: this.labels.some((label) => label.kind === "zone")
+    });
     if (this.forcedDense) {
       kinds.add("row");
       kinds.add("seat");
@@ -3724,7 +4645,14 @@ var LabelOverlay = class {
         ...this.selectedSeatLabelIds.has(label.id) ? { priority: 1 } : {}
       });
     }
-    const structure = candidates.filter((c) => !DENSE_KINDS.has(c.label.kind));
+    const floorLabels = spreadFloorLabels(
+      candidates.filter((candidate) => candidate.label.kind === "floor"),
+      width
+    );
+    const structure = [
+      ...candidates.filter((candidate) => !DENSE_KINDS.has(candidate.label.kind) && candidate.label.kind !== "floor"),
+      ...floorLabels
+    ];
     const kept = [
       ...cullOverlapping(structure, SEPARATION_X_PX, SEPARATION_Y_PX),
       // The dense rungs are BUDGETED, not merely deduplicated — see
@@ -3771,14 +4699,16 @@ var LabelOverlay = class {
     s.fontSize = `${style.size}px`;
     s.fontWeight = selected ? "800" : style.weight;
     s.opacity = selected ? "1" : String(style.opacity);
-    s.color = selected ? "#ecf8ff" : label.color ?? this.opts.ink ?? "#e8edf5";
-    s.background = selected ? "rgba(10,28,45,.9)" : "";
-    s.border = selected ? "1px solid rgba(89,199,255,.92)" : "";
-    s.borderRadius = selected ? "999px" : "";
-    s.padding = selected ? "3px 7px" : "";
-    s.boxShadow = selected ? "0 0 0 2px rgba(41,176,255,.18), 0 5px 14px rgba(0,0,0,.35)" : "";
-    s.letterSpacing = label.kind === "zone" ? "0.08em" : "0.02em";
-    if (label.kind === "zone") s.textTransform = "uppercase";
+    const treatment = resolve3dLabelTreatment(label.color ?? this.opts.ink, this.opts.backgroundRgb);
+    const backed = !DENSE_KINDS.has(label.kind);
+    s.color = selected ? "#ecf8ff" : treatment.ink;
+    s.background = selected ? "rgba(10,28,45,.9)" : backed ? treatment.backing : "";
+    s.border = selected ? "1px solid rgba(89,199,255,.92)" : backed ? `1px solid ${treatment.border}` : "";
+    s.borderRadius = selected || backed ? "999px" : "";
+    s.padding = selected ? "3px 7px" : backed ? "3px 7px" : "";
+    s.boxShadow = selected ? "0 0 0 2px rgba(41,176,255,.18), 0 5px 14px rgba(0,0,0,.35)" : backed ? "0 3px 10px rgba(0,0,0,.24)" : "";
+    s.letterSpacing = label.kind === "zone" || label.kind === "floor" ? "0.08em" : "0.02em";
+    if (label.kind === "zone" || label.kind === "floor") s.textTransform = "uppercase";
     return node;
   }
   dispose() {
@@ -3832,8 +4762,7 @@ out float vDim;
 out float vMaterial;
 void main() {
   // Per-floor isolation without splitting the merged mesh into a draw call per
-  // floor: a floor that is not the focused one is dimmed, not hidden, so the
-  // buyer keeps the whole venue as context while looking at one level.
+  // floor. The fragment pass removes non-focused floors for a clean level view.
   vDim = (uFocusFloor < -0.5 || abs(floorIndex - uFocusFloor) < 0.5) ? 0.0 : 1.0;
   vMaterial = materialIndex;
   vec4 world = modelMatrix * vec4(position, 1.0);
@@ -3864,13 +4793,19 @@ uniform vec3 uKeyDir;                           // WORLD space, unit, points at
 uniform float uStructureDetail;
 out vec4 fragColor;
 void main() {
+  if (vDim > 0.5) discard;
   // Row treads/risers are honest and useful when the buyer is inside a stand.
   // At whole-venue scale their overlapping centimetre-scale surfaces quantise
   // and alias into camera-dependent radial combs. The clean structural block
   // cap remains, so overview keeps every stand without pretending to show row
   // detail below a useful pixel size.
   float rowDetail = step(1.5, vMaterial);
-  if (rowDetail > 0.5 && uStructureDetail < 0.5) discard;
+  // The rung DISSOLVES rather than popping: uStructureDetail eases 0..1 over a
+  // few frames (see the render loop) and each pixel holds a stable screen-door
+  // threshold against it, so free-zooming across the handover reads as detail
+  // developing instead of the venue changing in a single frame.
+  float stipple = fract(sin(dot(gl_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453);
+  if (rowDetail > 0.5 && stipple >= uStructureDetail) discard;
   vec3 N = normalize(vNormalWorld);
   vec3 V = normalize(-vPosView);
   float hemi = 0.5 + 0.5 * N.y;                 // sky/ground gradient about WORLD up
@@ -3906,8 +4841,6 @@ void main() {
     + vec3(0.62, 0.46, 0.20) * band * 0.28
     + vec3(0.20, 0.10, 0.34) * focalHalo;
   base = mix(base, display, poweredDisplay * verticalFace * 0.92);
-  // Unfocused floors fall back toward the background rather than vanishing.
-  base = mix(base, base * 0.45, vDim);
   fragColor = vec4(base, 1.0);
 }`
 );
@@ -3991,7 +4924,11 @@ uniform float uSeatDetail;    // 0 for venue/area overview; 1 in section/row/sea
 uniform vec3 uFadeColor;
 out vec4 fragColor;
 void main() {
-  if (uSeatDetail < 0.5) discard;
+  if (vDim > 0.5) discard;
+  // Same screen-door dissolve as the structure rung (uStructureDetail): the
+  // dot layer develops over ~a quarter second instead of appearing at once.
+  float stipple = fract(sin(dot(gl_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453);
+  if (stipple >= uSeatDetail) discard;
   // Empty wheelchair provision is a square bay, never a round chair marker.
   float d = mix(max(abs(vUv.x), abs(vUv.y)), length(vUv), vPhysicalSeat);
   if (d > 1.0) discard;
@@ -4024,9 +4961,6 @@ void main() {
   // while zooming. uSeatFade already measures this exact LOD transition: let
   // the category-tinted tier carry the overview, then reveal individual live
   // availability as the buyer approaches a section.
-  // 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.
@@ -4171,6 +5105,7 @@ uniform vec3 uKeyDir;
 uniform vec3 uFadeColor;
 out vec4 fragColor;
 void main() {
+  if (vDim > 0.5) discard;
   vec3 N = normalize(vNormalWorld);
   vec3 V = normalize(-vPosView);
   // The solids' rig, unchanged, so the chairs sit in the venue's light.
@@ -4203,7 +5138,6 @@ void main() {
   // 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);
 }`
 );
@@ -4241,6 +5175,7 @@ in vec2 position;
 in vec3 iOffset;
 in float iMaxRadius;
 in float iPhysicalSeat;
+in float iFloor;
 uniform mat4 modelViewMatrix;
 uniform mat4 projectionMatrix;
 uniform float uSeatRadius;
@@ -4249,9 +5184,11 @@ uniform float uMinPixels;
 uniform float uPixelToWorld;
 uniform float uChairFull;
 uniform float uChairNone;
+uniform float uFocusFloor;
 out vec2 vUv;
 out float vPhysicalSeat;
 out float vDotWeight;
+out float vHidden;
 flat out vec3 vPick;
 ${CHAIR_WEIGHT_GLSL}
 void main() {
@@ -4267,6 +5204,7 @@ void main() {
   mv.xy += normalize(vec3(modelViewMatrix * vec4(0.0, 1.0, 0.0, 0.0))).xy * r;
   vUv = position;
   vPhysicalSeat = iPhysicalSeat;
+  vHidden = (uFocusFloor > -0.5 && abs(iFloor - uFocusFloor) > 0.5) ? 1.0 : 0.0;
   gl_Position = projectionMatrix * mv;
 }`
 );
@@ -4277,9 +5215,11 @@ precision highp float;
 in vec2 vUv;
 in float vPhysicalSeat;
 in float vDotWeight;
+in float vHidden;
 flat in vec3 vPick;
 out vec4 fragColor;
 void main() {
+  if (vHidden > 0.5) discard;
   if (vDotWeight <= 0.02) discard;              // invisible dot cannot steal a chair tap
   float d = mix(max(abs(vUv.x), abs(vUv.y)), length(vUv), vPhysicalSeat);
   if (d > 1.0) discard;                        // hit-mask matches chair/bay shape
@@ -4298,18 +5238,22 @@ in float iYaw;
 in float iSeed;
 in float iPhysicalSeat;
 in float iPickIndex;
+in float iFloor;
 uniform mat4 modelViewMatrix;
 uniform mat4 projectionMatrix;
 uniform float uChairFull;
 uniform float uChairNone;
 uniform float uBackRake;
 uniform float uBackBase;
+uniform float uFocusFloor;
 flat out vec3 vPick;
+out float vHidden;
 ${CHAIR_WEIGHT_GLSL}
 ${OCCUPANT_WEIGHT_GLSL}
 void main() {
   int id = int(iPickIndex + 0.5);             // already global index + 1
   vPick = vec3(float(id & 255), float((id >> 8) & 255), float((id >> 16) & 255)) / 255.0;
+  vHidden = (uFocusFloor > -0.5 && abs(iFloor - uFocusFloor) > 0.5) ? 1.0 : 0.0;
   vec4 anchor = modelViewMatrix * vec4(iOffset, 1.0);
   float viewDepth = -anchor.z;
   float depth = max(viewDepth, 0.001);
@@ -4342,17 +5286,25 @@ var CHAIR_PICK_FRAG = (
   `#version 300 es
 precision highp float;
 flat in vec3 vPick;
+in float vHidden;
 out vec4 fragColor;
-void main() { fragColor = vec4(vPick, 1.0); }`
+void main() {
+  if (vHidden > 0.5) discard;
+  fragColor = vec4(vPick, 1.0);
+}`
 );
 var PICK_DEPTH_VERT = (
   /* glsl */
   `#version 300 es
 precision highp float;
 in vec3 position;
+in float floorIndex;
 uniform mat4 modelViewMatrix;
 uniform mat4 projectionMatrix;
+uniform float uFocusFloor;
+out float vHidden;
 void main() {
+  vHidden = (uFocusFloor > -0.5 && abs(floorIndex - uFocusFloor) > 0.5) ? 1.0 : 0.0;
   gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
 }`
 );
@@ -4360,8 +5312,12 @@ var PICK_DEPTH_FRAG = (
   /* glsl */
   `#version 300 es
 precision highp float;
+in float vHidden;
 out vec4 fragColor;
-void main() { fragColor = vec4(0.0, 0.0, 0.0, 1.0); }`
+void main() {
+  if (vHidden > 0.5) discard;
+  fragColor = vec4(0.0, 0.0, 0.0, 1.0);
+}`
 );
 function createSeatPickProgram(gl) {
   return new Program(gl, {
@@ -4377,7 +5333,8 @@ function createSeatPickProgram(gl) {
       uMinPixels: { value: SEAT_MIN_PIXELS_NEAR },
       uPixelToWorld: { value: 2e-3 },
       uChairFull: { value: CHAIR_FULL_M },
-      uChairNone: { value: CHAIR_NONE_M }
+      uChairNone: { value: CHAIR_NONE_M },
+      uFocusFloor: { value: -1 }
     }
   });
 }
@@ -4393,7 +5350,8 @@ function createChairPickProgram(gl) {
       uChairFull: { value: CHAIR_FULL_M },
       uChairNone: { value: CHAIR_NONE_M },
       uBackRake: { value: BACK_RAKE_SLOPE },
-      uBackBase: { value: BACK_BASE_M }
+      uBackBase: { value: BACK_BASE_M },
+      uFocusFloor: { value: -1 }
     }
   });
 }
@@ -4404,7 +5362,10 @@ function createPickDepthProgram(gl) {
     transparent: false,
     depthTest: true,
     depthWrite: true,
-    cullFace: false
+    cullFace: false,
+    uniforms: {
+      uFocusFloor: { value: -1 }
+    }
   });
 }
 function createSolidProgram(gl) {
@@ -4738,6 +5699,10 @@ var PickPipeline = class {
   /** Match the display seat sizing so the pick mask lines up with the dots. */
   syncFromSeatProgram(seatProgram) {
     for (const k of SYNC_KEYS) this.seatProg.uniforms[k].value = seatProgram.uniforms[k].value;
+    const focusFloor = seatProgram.uniforms.uFocusFloor.value;
+    this.seatProg.uniforms.uFocusFloor.value = focusFloor;
+    this.chairProg.uniforms.uFocusFloor.value = focusFloor;
+    this.depthProg.uniforms.uFocusFloor.value = focusFloor;
   }
   ensureTarget() {
     const w = this.gl.drawingBufferWidth;
@@ -4995,9 +5960,9 @@ function buildPanoSphere(segmentsLon = PANO_SEGMENTS_LON, segmentsLat = PANO_SEG
   const uv = new Float32Array(vertexCount * 2);
   for (let iLat = 0; iLat < latCount; iLat++) {
     const v = iLat / segmentsLat;
-    const polar = v * Math.PI;
-    const sinPolar = Math.sin(polar);
-    const cosPolar = Math.cos(polar);
+    const polar2 = v * Math.PI;
+    const sinPolar = Math.sin(polar2);
+    const cosPolar = Math.cos(polar2);
     for (let iLon = 0; iLon < lonCount; iLon++) {
       const u = iLon / segmentsLon;
       const azimuth = (u - 0.5) * Math.PI * 2;
@@ -5025,8 +5990,8 @@ function buildPanoSphere(segmentsLon = PANO_SEGMENTS_LON, segmentsLat = PANO_SEG
   }
   return { position, uv, index };
 }
-function bearingPitchToDirection(bearingDeg, pitchDeg) {
-  const yaw = bearingDeg * Math.PI / 180;
+function bearingPitchToDirection(bearingDeg2, pitchDeg) {
+  const yaw = bearingDeg2 * Math.PI / 180;
   const pitch = pitchDeg * Math.PI / 180;
   const cosPitch = Math.cos(pitch);
   return [cosPitch * Math.sin(yaw), Math.sin(pitch), -cosPitch * Math.cos(yaw)];
@@ -5530,7 +6495,7 @@ function prepareVenue3D(input) {
 }
 
 // src/view3d/index.ts
-var DEG2 = Math.PI / 180;
+var DEG4 = Math.PI / 180;
 var TAP_SLOP = 6;
 var TAP_MS = 500;
 function mountVenue3D(container, input, opts = {}) {
@@ -5598,11 +6563,11 @@ function mountVenue3D(container, input, opts = {}) {
   const nearBuf = new Int32Array(CHAIR_MAX_INSTANCES);
   let lastGatherX = Infinity;
   let lastGatherZ = Infinity;
-  let nearFieldDetailEnabled = false;
   let cameraDetailVisible = false;
+  let seatDetailMix = 0;
+  let structureDetailMix = 0;
   let panoramaSphereVisible = false;
   const setNearFieldDetailEnabled = (enabled) => {
-    nearFieldDetailEnabled = enabled;
     if (!enabled) cameraDetailVisible = false;
     lastGatherX = Infinity;
     lastGatherZ = Infinity;
@@ -5651,27 +6616,36 @@ function mountVenue3D(container, input, opts = {}) {
     // first real drag/wheel/pinch (not the intro ease)
   );
   orbit.setAspect(glctx.aspect);
+  const inferredImportedGeometry = (input.doc.floors?.flatMap((floor) => floor.objects) ?? input.doc.objects).some((object) => object.type === "section" && object.physical3dProvenance?.surfaceKind?.status === "inferred");
   const stageAzimuth = (() => {
+    if (inferredImportedGeometry && model.stages.length === 0) return void 0;
     const dx = model.focalWorld[0] - model.bounds.center[0];
     const dz = model.focalWorld[2] - model.bounds.center[2];
     return Math.hypot(dx, dz) > model.bounds.radius * 0.12 ? Math.atan2(dx, dz) : void 0;
   })();
+  const overviewFraming = model.floors.length > 1 ? { polarDeg: 48, margin: 1.1 } : void 0;
   const reduceMotionOnMount = typeof window !== "undefined" && !!window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
-  orbit.frame(model.bounds, !reduceMotionOnMount, stageAzimuth, opts.portraitOverviewCrop === true);
+  orbit.frame(model.bounds, !reduceMotionOnMount, stageAzimuth, opts.portraitOverviewCrop === true, overviewFraming);
   const cinematic = new Cinematic(orbit.camera);
   const restoreContainerPosition = establishPositioningContext(container);
   const labelOverlay = new LabelOverlay(container, {
     fontFamily: input.doc.theme?.fontFamily,
-    ink: input.doc.theme?.textColor
+    ink: input.doc.theme?.textColor,
+    backgroundRgb: model.theme.background.top
   });
-  labelOverlay.setLabels(model.labels);
   const baseLabels = model.labels;
+  const labelsForFocusedFloor = () => labelsForFloorView(
+    baseLabels,
+    model.floors.length,
+    focusedFloor
+  );
+  labelOverlay.setLabels(labelsForFocusedFloor());
   let focusedSectionId = null;
   const showSectionSeatLabels = (sectionId) => {
     focusedSectionId = sectionId;
     labelOverlay.setForcedDense(!!sectionId);
     if (!sectionId) {
-      labelOverlay.setLabels(baseLabels);
+      labelOverlay.setLabels(labelsForFocusedFloor());
       return;
     }
     const sectionSeats = input.seats.filter((seat) => seat.sectionId === sectionId);
@@ -5679,7 +6653,7 @@ function mountVenue3D(container, input, opts = {}) {
     const rowIds = new Set(sectionSeats.map((seat) => seat.rowId));
     const selectedIds = new Set(selection.keys());
     const selectedInSection = new Set(sectionSeats.filter((seat) => selectedIds.has(seat.id)).map((seat) => seat.id));
-    const focusedBase = baseLabels.filter((label) => label.kind !== "row" && label.kind !== "seat" || (label.kind === "row" ? rowIds.has(label.id.slice("row:".length)) : seatIds.has(label.id.slice("seat:".length)) && (selectedInSection.size === 0 || selectedInSection.has(label.id.slice("seat:".length)))));
+    const focusedBase = labelsForFocusedFloor().filter((label) => label.kind !== "row" && label.kind !== "seat" || (label.kind === "row" ? rowIds.has(label.id.slice("row:".length)) : seatIds.has(label.id.slice("seat:".length)) && (selectedInSection.size === 0 || selectedInSection.has(label.id.slice("seat:".length)))));
     if (model.seatCount <= 6e3 && selectedInSection.size === 0) {
       labelOverlay.setLabels(focusedBase);
       return;
@@ -5710,29 +6684,58 @@ function mountVenue3D(container, input, opts = {}) {
     ]);
   };
   rebuildGpu();
-  const loop = new RenderLoop(() => {
+  const loop = new RenderLoop((dt) => {
     if (contextLost || !gpu || frozen) return false;
     const flying = cinematic.active;
     const moving = flying ? cinematic.update(performance.now()) : orbit.update();
-    const lod = computeSeatLod(orbit.currentDistance, model.bounds.radius);
+    const activeFloorBounds = focusedFloor >= 0 ? model.floors[focusedFloor] : null;
+    const lodRadius = activeFloorBounds?.radius ?? model.bounds.radius;
+    const lod = computeSeatLod(orbit.currentDistance, lodRadius);
     const clippingBounds = panoramaSphereVisible ? { center: [orbit.camera.position.x, orbit.camera.position.y, orbit.camera.position.z], radius: 520 } : model.renderBounds;
     orbit.updateClipping(clippingBounds);
-    const cameraDx = orbit.camera.position.x - model.renderBounds.center[0];
-    const cameraDy = orbit.camera.position.y - model.renderBounds.center[1];
-    const cameraDz = orbit.camera.position.z - model.renderBounds.center[2];
-    const cameraVenueDistance = Math.hypot(cameraDx, cameraDy, cameraDz);
-    const detailEnter = model.renderBounds.radius * 1.55;
-    const detailExit = model.renderBounds.radius * 1.8;
-    if (!nearFieldDetailEnabled) cameraDetailVisible = false;
-    else if (cameraDetailVisible) cameraDetailVisible = cameraVenueDistance <= detailExit;
-    else cameraDetailVisible = cameraVenueDistance <= detailEnter;
+    const detailCenter = activeFloorBounds?.center ?? model.renderBounds.center;
+    const detailRadius = activeFloorBounds?.radius ?? model.renderBounds.radius;
+    const withinScope = (center, radius) => {
+      const d = Math.hypot(
+        orbit.camera.position.x - center[0],
+        orbit.camera.position.y - center[1],
+        orbit.camera.position.z - center[2]
+      );
+      return d <= radius * (cameraDetailVisible ? 1.8 : 1.55);
+    };
+    let withinDetail = withinScope(detailCenter, detailRadius);
+    if (!withinDetail && focusedSectionId) {
+      const sec = model.sections.find((candidate) => candidate.id === focusedSectionId);
+      if (sec) withinDetail = withinScope(sec.center, Math.max(12, sec.radius * 2));
+    }
+    cameraDetailVisible = withinDetail;
     const u = gpu.seatProgram.uniforms;
     u.uSeatScale.value = lod.scale;
     u.uSeatFade.value = lod.fade;
-    u.uSeatDetail.value = cameraDetailVisible ? 1 : 0;
-    gpu.solidProgram.uniforms.uStructureDetail.value = cameraDetailVisible ? 1 : 0;
+    const floorSeatDetail = !!activeFloorBounds && floorOverviewSeatDetailVisible(
+      activeFloorBounds.seatCount,
+      glctx.canvas.clientWidth || 1,
+      glctx.canvas.clientHeight || 1
+    );
+    const venueSeatDetail = projectedSeatDetailVisible(
+      model.seats.count,
+      lodRadius,
+      orbit.currentDistance,
+      orbit.camera.fov,
+      glctx.canvas.clientHeight || 1
+    );
+    const seatDetailTarget = cameraDetailVisible || floorSeatDetail || venueSeatDetail ? 1 : 0;
+    const structureDetailTarget = cameraDetailVisible || focusedFloor >= 0 || model.floors.length > 1 ? 1 : 0;
+    const easeIn = 1 - Math.exp(-dt * 9);
+    const easeOut = 1 - Math.exp(-dt * 20);
+    seatDetailMix += (seatDetailTarget - seatDetailMix) * (seatDetailTarget > seatDetailMix ? easeIn : easeOut);
+    structureDetailMix += (structureDetailTarget - structureDetailMix) * (structureDetailTarget > structureDetailMix ? easeIn : easeOut);
+    if (Math.abs(seatDetailTarget - seatDetailMix) < 0.01) seatDetailMix = seatDetailTarget;
+    if (Math.abs(structureDetailTarget - structureDetailMix) < 0.01) structureDetailMix = structureDetailTarget;
+    u.uSeatDetail.value = seatDetailMix;
+    gpu.solidProgram.uniforms.uStructureDetail.value = structureDetailMix;
     u.uMinPixels.value = lod.minPixels;
-    u.uPixelToWorld.value = 2 * Math.tan(orbit.camera.fov * DEG2 / 2) / Math.max(1, glctx.pixelHeight);
+    u.uPixelToWorld.value = 2 * Math.tan(orbit.camera.fov * DEG4 / 2) / Math.max(1, glctx.pixelHeight);
     updateNearField(cameraDetailVisible);
     glctx.renderer.render({ scene: gpu.background, clear: true });
     glctx.renderer.render({ scene: gpu.main, camera: orbit.camera, clear: false });
@@ -5741,12 +6744,12 @@ function mountVenue3D(container, input, opts = {}) {
       glctx.canvas.clientWidth || 1,
       glctx.canvas.clientHeight || 1,
       orbit.currentDistance,
-      model.bounds.radius,
+      lodRadius,
       // 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;
+    return moving || seatDetailMix !== seatDetailTarget || structureDetailMix !== structureDetailTarget;
   });
   const ro = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => handle.resize()) : null;
   ro?.observe(container);
@@ -5790,14 +6793,20 @@ function mountVenue3D(container, input, opts = {}) {
   const resolvedSeatViewPose = (seatId, idx) => {
     const seat = expandedSeatById.get(seatId);
     const floorIndex = Math.max(0, Math.round(model.seats.iFloor[idx] ?? 0));
-    const floor = input.doc.floors?.[floorIndex];
-    const focalPoint = seat?.focalPoint ?? floor?.focalPoint ?? input.doc.focalPoint;
+    const sourceFloor = input.doc.floors?.[floorIndex];
+    const sceneFloor = model.floors[floorIndex];
+    const sourceFocal = sourceFloor?.focalPoint ?? input.doc.focalPoint;
+    const sceneFocal = sceneFloor ? { x: sceneFloor.focalWorld[0] / M, y: sceneFloor.focalWorld[2] / M } : sourceFocal;
+    const focalPoint = seat?.focalPoint ? {
+      x: seat.focalPoint.x + sceneFocal.x - sourceFocal.x,
+      y: seat.focalPoint.y + sceneFocal.y - sourceFocal.y
+    } : sceneFocal;
     const deck = [
       model.seats.iPosition[idx * 3],
       model.seats.iPosition[idx * 3 + 1],
       model.seats.iPosition[idx * 3 + 2]
     ];
-    return seatViewPose(deck, focalPoint, floor?.baseHeightM ?? 0, seat?.eyeHeightM);
+    return seatViewPose(deck, focalPoint, sourceFloor?.baseHeightM ?? 0, seat?.eyeHeightM);
   };
   const placeCameraFinal = (finalPos, focal, fov = FOV_END) => {
     orbit.camera.position.set(finalPos[0], finalPos[1], finalPos[2]);
@@ -6027,8 +7036,8 @@ function mountVenue3D(container, input, opts = {}) {
   overviewChip.className = "sl-3d-overview-control sl-3d-icon-control";
   overviewChip.type = "button";
   overviewChip.textContent = "\u2302";
-  overviewChip.setAttribute("aria-label", "Fit the whole venue in view");
-  overviewChip.dataset.tooltip = "Fit venue";
+  overviewChip.setAttribute("aria-label", "Fit the active level or whole venue in view");
+  overviewChip.dataset.tooltip = "Fit view";
   Object.assign(overviewChip.style, {
     width: "44px",
     minWidth: "44px",
@@ -6047,6 +7056,15 @@ function mountVenue3D(container, input, opts = {}) {
     overviewChip.textContent = "\u2302";
   };
   layoutOverviewChip();
+  const applyFloorFocus = (value) => {
+    focusedFloor = value;
+    if (gpu) {
+      gpu.seatProgram.uniforms.uFocusFloor.value = value;
+      gpu.solidProgram.uniforms.uFocusFloor.value = value;
+      gpu.chairProgram.uniforms.uFocusFloor.value = value;
+    }
+    showSectionSeatLabels(null);
+  };
   const focusOverview = () => {
     if (disposed) return;
     opts.onViewTargetChange?.(null);
@@ -6063,13 +7081,25 @@ function mountVenue3D(container, input, opts = {}) {
     overviewChip.style.display = "";
     labelOverlay.setVisible(true);
     frozen = false;
-    setNearFieldDetailEnabled(false);
+    const activeFloor = focusedFloor >= 0 ? model.floors[focusedFloor] : null;
+    setNearFieldDetailEnabled(!!activeFloor);
     setSeatViewLocked(false);
     cancelFlight();
     removeArriveChip();
     setNavigationMode("orbit");
-    if (reducedMotion()) orbit.frame(model.bounds, false, stageAzimuth, opts.portraitOverviewCrop === true);
-    else orbit.frameSoft(model.bounds, stageAzimuth, opts.portraitOverviewCrop === true);
+    if (activeFloor) {
+      const dx = activeFloor.focalWorld[0] - activeFloor.center[0];
+      const dz = activeFloor.focalWorld[2] - activeFloor.center[2];
+      const azimuth = Math.hypot(dx, dz) > activeFloor.radius * 0.12 ? Math.atan2(dx, dz) : stageAzimuth;
+      const floorBounds = { center: activeFloor.center, radius: activeFloor.radius, box: activeFloor.box };
+      const floorFraming = { polarDeg: 58, margin: 1.12 };
+      if (reducedMotion()) orbit.frame(floorBounds, false, azimuth, false, floorFraming);
+      else orbit.frameSoft(floorBounds, azimuth, false, floorFraming);
+    } else if (reducedMotion()) {
+      orbit.frame(model.bounds, false, stageAzimuth, opts.portraitOverviewCrop === true, overviewFraming);
+    } else {
+      orbit.frameSoft(model.bounds, stageAzimuth, opts.portraitOverviewCrop === true, overviewFraming);
+    }
     showSectionSeatLabels(null);
     loop.requestRender();
   };
@@ -6256,6 +7286,7 @@ function mountVenue3D(container, input, opts = {}) {
     setSeatViewLocked(false);
     cinematic.cancel();
     removeArriveChip();
+    if (model.floors.length > 1 && focusedFloor !== sec.floorIndex) applyFloorFocus(sec.floorIndex);
     setNavigationMode("pan");
     showSectionSeatLabels(sectionId);
     const dx = sec.focalWorld[0] - sec.center[0];
@@ -6438,20 +7469,25 @@ function mountVenue3D(container, input, opts = {}) {
     focusFloor(index) {
       if (index !== null && !model.floors.some((f) => f.index === index)) return false;
       const value = index ?? -1;
-      setNearFieldDetailEnabled(false);
+      setNearFieldDetailEnabled(index !== null);
       setSeatViewLocked(false);
-      if (gpu) {
-        gpu.seatProgram.uniforms.uFocusFloor.value = value;
-        gpu.solidProgram.uniforms.uFocusFloor.value = value;
-        gpu.chairProgram.uniforms.uFocusFloor.value = value;
-      }
-      focusedFloor = value;
+      applyFloorFocus(value);
       setNavigationMode("orbit");
-      if (index !== null) {
+      if (index === null) {
+        cinematic.cancel();
+        if (reducedMotion()) orbit.frame(model.bounds, false, stageAzimuth, opts.portraitOverviewCrop === true, overviewFraming);
+        else orbit.frameSoft(model.bounds, stageAzimuth, opts.portraitOverviewCrop === true, overviewFraming);
+      } else {
         const f = model.floors[index];
         if (f.seatCount > 0) {
           cinematic.cancel();
-          orbit.frame({ center: f.center, radius: f.radius * 1.25 });
+          const dx = f.focalWorld[0] - f.center[0];
+          const dz = f.focalWorld[2] - f.center[2];
+          const azimuth = Math.hypot(dx, dz) > f.radius * 0.12 ? Math.atan2(dx, dz) : stageAzimuth;
+          orbit.frame({ center: f.center, radius: f.radius, box: f.box }, false, azimuth, false, {
+            polarDeg: 58,
+            margin: 1.12
+          });
         }
       }
       loop.requestRender();