@seatlayer/core 0.28.4 → 0.30.0

package/dist/view3d/index.cjs

@@ -0,0 +1,4188 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/view3d/index.ts
+var view3d_exports = {};
+__export(view3d_exports, {
+  buildSceneModel: () => buildSceneModel,
+  mountVenue3D: () => mountVenue3D
+});
+module.exports = __toCommonJS(view3d_exports);
+var import_ogl7 = require("ogl");
+
+// src/view3d/gl/context.ts
+var import_ogl = require("ogl");
+
+// src/view3d/palette.ts
+var SEAT_STATES = ["available", "held", "sold", "selected", "dimmed"];
+function seatStateIndex(state) {
+  const i = SEAT_STATES.indexOf(state);
+  return i < 0 ? 0 : i;
+}
+var SEAT_STATE_COLORS = {
+  available: [0.24, 0.82, 0.52],
+  held: [0.95, 0.66, 0.22],
+  sold: [0.34, 0.39, 0.45],
+  selected: [0.24, 0.74, 1],
+  dimmed: [0.28, 0.32, 0.37]
+};
+var STRUCTURE = {
+  ground: [0.07, 0.085, 0.11],
+  tierTop: [0.24, 0.28, 0.34],
+  tierWall: [0.17, 0.2, 0.25],
+  stageTop: [0.42, 0.36, 0.26],
+  // warm, slightly emissive read
+  stageWall: [0.26, 0.22, 0.16],
+  decorTop: [0.22, 0.25, 0.29],
+  decorWall: [0.15, 0.17, 0.2],
+  gaTop: [0.24, 0.28, 0.33],
+  gaWall: [0.16, 0.19, 0.23],
+  /** Exhibition / trade-show booth stand. */
+  boothTop: [0.3, 0.33, 0.38],
+  boothWall: [0.2, 0.23, 0.27],
+  /** Banquet table top — warmer, so a laid table reads apart from structure. */
+  tableTop: [0.38, 0.34, 0.29],
+  tableWall: [0.24, 0.21, 0.18]
+};
+var BACKGROUND = {
+  top: [0.05, 0.06, 0.08],
+  bottom: [0.1, 0.12, 0.15]
+};
+function hexToRgb(hex) {
+  if (!hex) return null;
+  let h = hex.trim();
+  if (h[0] === "#") h = h.slice(1);
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  if (h.length !== 6 || /[^0-9a-fA-F]/.test(h)) return null;
+  const n = parseInt(h, 16);
+  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+}
+function mix(a, b, t) {
+  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+}
+function desaturate(c, amount) {
+  const l = 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
+  return mix(c, [l, l, l], amount);
+}
+function scaleRgb(c, k) {
+  return [Math.min(1, c[0] * k), Math.min(1, c[1] * k), Math.min(1, c[2] * k)];
+}
+
+// src/view3d/gl/context.ts
+function computeDpr() {
+  const raw = typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1;
+  const mem = navigator.deviceMemory;
+  const cap = typeof mem === "number" && mem <= 4 ? 1.5 : 2;
+  return Math.min(raw, cap);
+}
+var GLContext = class {
+  constructor(container, opts) {
+    /** Current clear colour, so a context restore repaints the themed background. */
+    this.clearRgb = [0, 0, 0];
+    this.container = container;
+    this.canvas = document.createElement("canvas");
+    this.canvas.style.display = "block";
+    this.canvas.style.width = "100%";
+    this.canvas.style.height = "100%";
+    this.canvas.style.touchAction = "none";
+    this.renderer = new import_ogl.Renderer({
+      canvas: this.canvas,
+      dpr: computeDpr(),
+      alpha: false,
+      antialias: false,
+      depth: true,
+      stencil: false,
+      powerPreference: "high-performance",
+      webgl: 2
+    });
+    this.gl = this.renderer.gl;
+    this.clearRgb = [BACKGROUND.top[0], BACKGROUND.top[1], BACKGROUND.top[2]];
+    this.gl.clearColor(this.clearRgb[0], this.clearRgb[1], this.clearRgb[2], 1);
+    container.appendChild(this.canvas);
+    this.lostHandler = (e) => {
+      e.preventDefault();
+      opts.onContextLost();
+    };
+    this.restoredHandler = () => opts.onContextRestored();
+    this.canvas.addEventListener("webglcontextlost", this.lostHandler, false);
+    this.canvas.addEventListener("webglcontextrestored", this.restoredHandler, false);
+    this.resize();
+  }
+  /**
+   * Repaint the clear colour from the chart's theme.
+   *
+   * The clear shows for one frame before the background triangle draws, and on
+   * any frame the scene does not cover — so leaving it at the library default
+   * flashes SeatLayer grey into a white-labelled venue.
+   */
+  setClearColor(rgb) {
+    this.clearRgb = [rgb[0], rgb[1], rgb[2]];
+    this.gl.clearColor(rgb[0], rgb[1], rgb[2], 1);
+  }
+  /** The clear colour currently set (the pick pass restores through this). */
+  get clearColor() {
+    return this.clearRgb;
+  }
+  /** Match the drawing buffer to the container's CSS box. */
+  resize() {
+    const w = Math.max(1, this.container.clientWidth || this.canvas.clientWidth || 1);
+    const h = Math.max(1, this.container.clientHeight || this.canvas.clientHeight || 1);
+    this.renderer.setSize(w, h);
+    return { width: w, height: h };
+  }
+  get pixelHeight() {
+    return this.renderer.height * this.renderer.dpr;
+  }
+  get aspect() {
+    return this.renderer.width / Math.max(1, this.renderer.height);
+  }
+  dispose() {
+    this.canvas.removeEventListener("webglcontextlost", this.lostHandler, false);
+    this.canvas.removeEventListener("webglcontextrestored", this.restoredHandler, false);
+    const ext = this.gl.getExtension("WEBGL_lose_context");
+    if (ext) ext.loseContext();
+    if (this.canvas.parentNode) this.canvas.parentNode.removeChild(this.canvas);
+  }
+  /**
+   * Test hook: force a full loss→restore cycle. `restoreContext()` must be called
+   * only AFTER the browser has dispatched `webglcontextlost` (calling it too soon
+   * makes the browser drop the restore request), so we sequence it off a one-shot
+   * listener rather than a fixed timeout.
+   */
+  simulateContextLossCycle() {
+    const ext = this.gl.getExtension("WEBGL_lose_context");
+    if (!ext) return;
+    ext.loseContext();
+    setTimeout(() => {
+      if (ext.restoreContext) ext.restoreContext();
+    }, 300);
+  }
+};
+
+// src/view3d/camera/orbit.ts
+var import_ogl2 = require("ogl");
+var DEG = Math.PI / 180;
+var POLAR_MIN = 15 * DEG;
+var POLAR_MAX = 80 * DEG;
+var DAMP = 0.12;
+var FOV = 35;
+var FRAME_MARGIN = 1.25;
+var OrbitCamera = class {
+  constructor(gl, canvas, requestRender, onGesture) {
+    this.fovY = FOV;
+    this.target = new import_ogl2.Vec3();
+    this.azimuth = -30 * DEG;
+    this.polar = 55 * DEG;
+    this.distance = 10;
+    this.azT = -30 * DEG;
+    this.polT = 55 * DEG;
+    this.distT = 10;
+    this.minDist = 1;
+    this.maxDist = 100;
+    this.gestureFired = false;
+    this.dragging = false;
+    this.lastX = 0;
+    this.lastY = 0;
+    this.activePointers = /* @__PURE__ */ new Map();
+    this.pinchDist = 0;
+    this.camera = new import_ogl2.Camera(gl, { fov: FOV, near: 0.1, far: 5e3, aspect: 1 });
+    this.canvas = canvas;
+    this.requestRender = requestRender;
+    this.onGesture = onGesture;
+    this.onPointerDown = (e) => {
+      try {
+        this.canvas.setPointerCapture?.(e.pointerId);
+      } catch {
+      }
+      this.activePointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
+      if (this.activePointers.size === 1) {
+        this.dragging = true;
+        this.lastX = e.clientX;
+        this.lastY = e.clientY;
+      } else if (this.activePointers.size === 2) {
+        this.dragging = false;
+        this.pinchDist = this.currentPinchDistance();
+      }
+    };
+    this.onPointerMove = (e) => {
+      if (!this.activePointers.has(e.pointerId)) return;
+      this.activePointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
+      if (this.activePointers.size >= 2) {
+        const d = this.currentPinchDistance();
+        if (this.pinchDist > 0) {
+          this.dollyBy(Math.exp((this.pinchDist - d) * 5e-3));
+          this.fireGesture();
+        }
+        this.pinchDist = d;
+        return;
+      }
+      if (!this.dragging) return;
+      const dx = e.clientX - this.lastX;
+      const dy = e.clientY - this.lastY;
+      this.lastX = e.clientX;
+      this.lastY = e.clientY;
+      if (dx !== 0 || dy !== 0) this.fireGesture();
+      this.azT -= dx * 6e-3;
+      this.polT = Math.max(POLAR_MIN, Math.min(POLAR_MAX, this.polT - dy * 6e-3));
+      this.requestRender();
+    };
+    this.onPointerUp = (e) => {
+      this.activePointers.delete(e.pointerId);
+      try {
+        this.canvas.releasePointerCapture?.(e.pointerId);
+      } catch {
+      }
+      if (this.activePointers.size < 2) this.pinchDist = 0;
+      if (this.activePointers.size === 0) this.dragging = false;
+    };
+    this.onWheel = (e) => {
+      e.preventDefault();
+      const unit = e.deltaMode === 1 ? 16 : e.deltaMode === 2 ? 100 : 1;
+      const norm2 = e.deltaY * unit / 100;
+      this.dollyBy(Math.exp(norm2 * 0.4));
+      this.fireGesture();
+    };
+    canvas.addEventListener("pointerdown", this.onPointerDown);
+    canvas.addEventListener("pointermove", this.onPointerMove);
+    canvas.addEventListener("pointerup", this.onPointerUp);
+    canvas.addEventListener("pointercancel", this.onPointerUp);
+    canvas.addEventListener("wheel", this.onWheel, { passive: false });
+  }
+  /** One-shot: notify the first real user gesture (drives 3d_orbit_engaged). */
+  fireGesture() {
+    if (this.gestureFired) return;
+    this.gestureFired = true;
+    this.onGesture?.();
+  }
+  currentPinchDistance() {
+    const pts = [...this.activePointers.values()];
+    if (pts.length < 2) return 0;
+    return Math.hypot(pts[0].x - pts[1].x, pts[0].y - pts[1].y);
+  }
+  /** Multiply target distance by `factor` (proportional zoom — same feel near
+   * and far), clamped so you can swoop right down among the seats. */
+  dollyBy(factor) {
+    this.distT = Math.max(this.minDist, Math.min(this.maxDist, this.distT * factor));
+    this.requestRender();
+  }
+  /**
+   * Fit a flattering 3/4 view to the bounds sphere. With `intro`, the camera
+   * STARTS nearly top-down (matching the 2D map's orientation) and further out,
+   * 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) {
+    this.target.set(bounds.center[0], bounds.center[1], bounds.center[2]);
+    const r = Math.max(1, bounds.radius);
+    const halfV = this.fovY * DEG / 2;
+    const aspect = this.camera.aspect || 1;
+    const halfH = Math.atan(Math.tan(halfV) * aspect);
+    const fit = Math.max(r / Math.tan(halfV), r / Math.tan(halfH));
+    this.azT = stageAzimuth ?? -30 * DEG;
+    this.polT = 55 * DEG;
+    this.distT = fit * FRAME_MARGIN;
+    this.minDist = Math.max(2, r * 0.12);
+    this.maxDist = fit * 4;
+    if (intro) {
+      this.azimuth = this.azT;
+      this.polar = 12 * DEG;
+      this.distance = this.distT * 1.7;
+    } else {
+      this.azimuth = this.azT;
+      this.polar = this.polT;
+      this.distance = this.distT;
+    }
+    this.applyPosition();
+  }
+  setAspect(aspect) {
+    this.camera.perspective({ aspect });
+  }
+  /**
+   * Damped return to the framed overview from wherever the camera is now (a
+   * seat, behind the shell, anywhere): re-pivot on the venue centre without
+   * moving the camera, then glide targets back to the 3/4 architectural pose.
+   */
+  frameSoft(bounds, stageAzimuth) {
+    this.target.set(bounds.center[0], bounds.center[1], bounds.center[2]);
+    this.syncFromCamera();
+    this.camera.perspective({ fov: this.fovY, aspect: this.camera.aspect });
+    const r = Math.max(1, bounds.radius);
+    const halfV = this.fovY * DEG / 2;
+    const aspect = this.camera.aspect || 1;
+    const halfH = Math.atan(Math.tan(halfV) * aspect);
+    const fit = Math.max(r / Math.tan(halfV), r / Math.tan(halfH));
+    this.azT = stageAzimuth ?? this.azimuth;
+    this.polT = 55 * DEG;
+    this.distT = fit * FRAME_MARGIN;
+  }
+  /** Damp toward targets; returns true while still moving. */
+  update() {
+    const da = this.azT - this.azimuth;
+    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;
+    this.azimuth += da * DAMP;
+    this.polar += dp * DAMP;
+    this.distance += dd * DAMP;
+    if (moving) this.applyPosition();
+    return moving;
+  }
+  /** Distance from camera to target (for LOD). */
+  get currentDistance() {
+    return this.distance;
+  }
+  /**
+   * Re-derive the orbit's spherical state from the camera's CURRENT pose (after a
+   * cinematic flight leaves it somewhere arbitrary), so a subsequent drag damps
+   * from where it actually is with no snap. Does not move the camera.
+   */
+  syncFromCamera() {
+    const dx = this.camera.position.x - this.target.x;
+    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)))));
+    this.distance = this.distT = dist;
+    this.polar = this.polT = polar;
+    this.azimuth = this.azT = Math.atan2(dx, dz);
+  }
+  /** Point the orbit pivot at a new world target without moving the camera. */
+  setTarget(target) {
+    this.target.set(target[0], target[1], target[2]);
+  }
+  /** 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 —
+   * otherwise the first drag would `lookAt(bounds.center)` and pop the aim. */
+  resumeAfterFlight(target) {
+    this.camera.perspective({ fov: this.fovY, aspect: this.camera.aspect });
+    if (target) this.target.set(target[0], target[1], target[2]);
+    this.syncFromCamera();
+  }
+  applyPosition() {
+    const sp = Math.sin(this.polar);
+    const x = this.target.x + this.distance * sp * Math.sin(this.azimuth);
+    const y = this.target.y + this.distance * Math.cos(this.polar);
+    const z = this.target.z + this.distance * sp * Math.cos(this.azimuth);
+    this.camera.position.set(x, y, z);
+    this.camera.lookAt(this.target);
+  }
+  dispose() {
+    this.canvas.removeEventListener("pointerdown", this.onPointerDown);
+    this.canvas.removeEventListener("pointermove", this.onPointerMove);
+    this.canvas.removeEventListener("pointerup", this.onPointerUp);
+    this.canvas.removeEventListener("pointercancel", this.onPointerUp);
+    this.canvas.removeEventListener("wheel", this.onWheel);
+    this.activePointers.clear();
+  }
+};
+
+// src/view3d/loop.ts
+var RenderLoop = class {
+  /** `frame(dt)` renders one frame and returns true if another is needed. */
+  constructor(frame) {
+    this.rafId = 0;
+    this.running = false;
+    this.lastTime = 0;
+    this.fpsEma = 0;
+    this.rendered = 0;
+    this.tick = (now2) => {
+      const dt = this.lastTime ? (now2 - this.lastTime) / 1e3 : 1 / 60;
+      this.lastTime = now2;
+      if (dt > 0) {
+        const instFps = 1 / dt;
+        this.fpsEma = this.fpsEma ? this.fpsEma * 0.9 + instFps * 0.1 : instFps;
+      }
+      this.rendered++;
+      const again = this.frame(dt);
+      if (again) {
+        this.rafId = requestAnimationFrame(this.tick);
+      } else {
+        this.running = false;
+        this.rafId = 0;
+      }
+    };
+    this.frame = frame;
+  }
+  requestRender() {
+    if (this.running) return;
+    this.running = true;
+    this.lastTime = 0;
+    this.rafId = requestAnimationFrame(this.tick);
+  }
+  stats() {
+    return { fps: this.running ? Math.round(this.fpsEma) : 0, rendered: this.rendered, idle: !this.running };
+  }
+  stop() {
+    if (this.rafId) cancelAnimationFrame(this.rafId);
+    this.rafId = 0;
+    this.running = false;
+  }
+};
+
+// src/view3d/lod.ts
+function computeSeatLod(distance, radius) {
+  const near = radius * 1.4;
+  const far = radius * 3.2;
+  if (distance <= near) return { scale: 1, fade: 0 };
+  const t = Math.min(1, (distance - near) / Math.max(1e-3, far - near));
+  return {
+    scale: 1 - t * 0.4,
+    fade: t * 0.55
+  };
+}
+
+// src/core/types.ts
+var ACCESSIBILITY_TYPES = [
+  { key: "wheelchair", label: "Wheelchair space", short: "Wheelchair", icon: "\u267F" },
+  { key: "companion", label: "Companion seat", short: "Companion", icon: "\u{1F9D1}\u200D\u{1F91D}\u200D\u{1F9D1}" },
+  { key: "semi-ambulatory", label: "Semi-ambulatory (limited mobility)", short: "Limited mobility", icon: "\u{1F9AF}" },
+  { key: "hearing", label: "Assistive listening", short: "Hearing", icon: "\u{1F9BB}" },
+  { key: "cart", label: "CART live-caption view", short: "CART captions", icon: "CC" },
+  { key: "sign-language", label: "Sign-language view", short: "Sign language", icon: "\u{1F91F}" },
+  { key: "plus-size", label: "Plus-size seat", short: "Plus-size", icon: "\u{1F4BA}" },
+  { key: "lift-armrest", label: "Lift-up armrest", short: "Lift armrest", icon: "\u2195\uFE0F" }
+];
+var ACCESSIBILITY_LABEL = new Map(ACCESSIBILITY_TYPES.map((a) => [a.key, a]));
+var ACCESSIBILITY_RING_COLOR = {
+  wheelchair: "#3b82f6",
+  companion: "#8b5cf6",
+  "semi-ambulatory": "#0ea5e9",
+  hearing: "#14b8a6",
+  cart: "#7c3aed",
+  "sign-language": "#f59e0b",
+  "plus-size": "#ec4899",
+  "lift-armrest": "#22c55e"
+};
+function accessibilityRingColor(types) {
+  const primary = types?.[0];
+  return primary && ACCESSIBILITY_RING_COLOR[primary] || "#3b82f6";
+}
+var SURROUNDINGS_SHAPE_ROLES = [
+  "reference-focal",
+  "bar",
+  "entrance",
+  "exit",
+  "restroom",
+  "screen",
+  "sound",
+  "concession",
+  "coat",
+  "wall"
+];
+var SURROUNDINGS_SHAPE_ROLE_SET = new Set(SURROUNDINGS_SHAPE_ROLES);
+
+// src/core/units.ts
+var METRES_PER_CHART_UNIT = 0.55 / 24;
+var CHART_UNITS_PER_METRE = 1 / METRES_PER_CHART_UNIT;
+var LIFT_PER_STEP_WORLD = 58;
+var TIER_HEIGHT_M = LIFT_PER_STEP_WORLD * METRES_PER_CHART_UNIT;
+var SECTION_ELEVATION_TIER_MAX = 3;
+var SECTION_HEIGHT_MIN_M = 0;
+var SECTION_HEIGHT_MAX_M = 120;
+var SECTION_RAKE_MIN_DEG = 0;
+var SECTION_RAKE_MAX_DEG = 45;
+var LEGACY_SECTION_ELEVATION_TIER_MAX = 7;
+var SEATED_EYE_HEIGHT_M = 1.2;
+function finiteClamped(value, min, max, fallback) {
+  return Number.isFinite(value) ? Math.max(min, Math.min(max, value)) : fallback;
+}
+function compatibleAutomaticTier(value) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) return 0;
+  if (value <= LEGACY_SECTION_ELEVATION_TIER_MAX) return value;
+  return SECTION_ELEVATION_TIER_MAX;
+}
+function sectionGeometry(section, context = {}) {
+  const floorBaseHeightM = finiteClamped(
+    context.floorBaseHeightM,
+    SECTION_HEIGHT_MIN_M,
+    SECTION_HEIGHT_MAX_M,
+    0
+  );
+  const automaticHeight = Math.min(
+    SECTION_HEIGHT_MAX_M,
+    floorBaseHeightM + compatibleAutomaticTier(section.elevation) * TIER_HEIGHT_M
+  );
+  const height = section.height === void 0 ? automaticHeight : finiteClamped(section.height, SECTION_HEIGHT_MIN_M, SECTION_HEIGHT_MAX_M, automaticHeight);
+  const rake = finiteClamped(section.rake, SECTION_RAKE_MIN_DEG, SECTION_RAKE_MAX_DEG, 0);
+  return { height, rake };
+}
+
+// src/view3d/scene/geometry.ts
+var import_earcut = __toESM(require("earcut"), 1);
+var import_polygon_clipping = __toESM(require("polygon-clipping"), 1);
+var M = METRES_PER_CHART_UNIT;
+var MIN_TRI_ALTITUDE_M = 2e-3;
+function isDegenerate(p0, p1, p2) {
+  const e0 = Math.hypot(p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2]);
+  const e1 = Math.hypot(p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]);
+  const e2 = Math.hypot(p0[0] - p2[0], p0[1] - p2[1], p0[2] - p2[2]);
+  const longest = Math.max(e0, e1, e2);
+  if (longest < 1e-9) return true;
+  const s = (e0 + e1 + e2) / 2;
+  const area = Math.sqrt(Math.max(0, s * (s - e0) * (s - e1) * (s - e2)));
+  return 2 * area / longest < MIN_TRI_ALTITUDE_M;
+}
+var MeshBuilder = class {
+  constructor() {
+    this.pos = [];
+    this.nor = [];
+    this.col = [];
+    this.flr = [];
+    /** Floor index stamped onto every triangle emitted from now on. */
+    this.currentFloor = 0;
+  }
+  /** Stamp subsequent triangles as belonging to `index`. */
+  setFloor(index) {
+    this.currentFloor = index;
+  }
+  /** One triangle with a shared (flat) normal and per-vertex colours. */
+  tri(p0, p1, p2, n, c0, c1 = c0, c2 = c0) {
+    if (isDegenerate(p0, p1, p2)) return;
+    this.pos.push(p0[0], p0[1], p0[2], p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]);
+    this.nor.push(n[0], n[1], n[2], n[0], n[1], n[2], n[0], n[1], n[2]);
+    this.col.push(c0[0], c0[1], c0[2], c1[0], c1[1], c1[2], c2[0], c2[1], c2[2]);
+    this.flr.push(this.currentFloor, this.currentFloor, this.currentFloor);
+  }
+  /** One triangle with independent per-vertex normals (smooth shading). */
+  triN(p0, p1, p2, n0, n1, n2, c0, c1 = c0, c2 = c0) {
+    if (isDegenerate(p0, p1, p2)) return;
+    this.pos.push(p0[0], p0[1], p0[2], p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]);
+    this.nor.push(n0[0], n0[1], n0[2], n1[0], n1[1], n1[2], n2[0], n2[1], n2[2]);
+    this.col.push(c0[0], c0[1], c0[2], c1[0], c1[1], c1[2], c2[0], c2[1], c2[2]);
+    this.flr.push(this.currentFloor, this.currentFloor, this.currentFloor);
+  }
+  get vertexCount() {
+    return this.pos.length / 3;
+  }
+  build() {
+    return {
+      position: new Float32Array(this.pos),
+      normal: new Float32Array(this.nor),
+      color: new Float32Array(this.col),
+      floor: new Float32Array(this.flr),
+      count: this.pos.length / 3
+    };
+  }
+};
+function faceNormal(a, b, c) {
+  const ux = b[0] - a[0], uy = b[1] - a[1], uz = b[2] - a[2];
+  const vx = c[0] - a[0], vy = c[1] - a[1], vz = c[2] - a[2];
+  let nx = uy * vz - uz * vy;
+  let ny = uz * vx - ux * vz;
+  let nz = ux * vy - uy * vx;
+  const len = Math.hypot(nx, ny, nz) || 1;
+  nx /= len;
+  ny /= len;
+  nz /= len;
+  return [nx, ny, nz];
+}
+function triangulate(outline, holes) {
+  const pts = [...outline];
+  const flat = [];
+  for (const p of outline) flat.push(p.x, p.y);
+  const holeIndices = [];
+  if (holes) {
+    for (const hole of holes) {
+      if (hole.length < 3) continue;
+      holeIndices.push(pts.length);
+      for (const p of hole) {
+        pts.push(p);
+        flat.push(p.x, p.y);
+      }
+    }
+  }
+  const tris = (0, import_earcut.default)(flat, holeIndices.length ? holeIndices : void 0, 2);
+  return { pts, tris };
+}
+function centroid(pts) {
+  let x = 0, y = 0;
+  for (const p of pts) {
+    x += p.x;
+    y += p.y;
+  }
+  const n = pts.length || 1;
+  return { x: x / n, y: y / n };
+}
+function signedArea(pts) {
+  let a = 0;
+  for (let i = 0, n = pts.length; i < n; i++) {
+    const p = pts[i], q = pts[(i + 1) % n];
+    a += p.x * q.y - q.x * p.y;
+  }
+  return a / 2;
+}
+function toCCW(pts) {
+  return signedArea(pts) < 0 ? [...pts].reverse() : pts;
+}
+var MAX_CAP_SPLIT_DEPTH = 3;
+function capDeviation(a, b, c, topY) {
+  const ya = topY(a), yb = topY(b), yc = topY(c);
+  const edge = (p, q, yp, yq) => Math.abs(topY({ x: (p.x + q.x) / 2, y: (p.y + q.y) / 2 }) - (yp + yq) / 2);
+  const cx3 = (a.x + b.x + c.x) / 3, cy3 = (a.y + b.y + c.y) / 3;
+  const yCen = (ya + yb + yc) / 3;
+  let worst = Math.max(
+    edge(a, b, ya, yb),
+    edge(b, c, yb, yc),
+    edge(c, a, yc, ya),
+    Math.abs(topY({ x: cx3, y: cy3 }) - yCen)
+  );
+  const probe = (px, py, yp) => {
+    const d = Math.abs(topY({ x: (px + cx3) / 2, y: (py + cy3) / 2 }) - (yp + yCen) / 2);
+    if (d > worst) worst = d;
+  };
+  probe((a.x + b.x) / 2, (a.y + b.y) / 2, (ya + yb) / 2);
+  probe((b.x + c.x) / 2, (b.y + c.y) / 2, (yb + yc) / 2);
+  probe((c.x + a.x) / 2, (c.y + a.y) / 2, (yc + ya) / 2);
+  return worst;
+}
+function maxDevAtDepth(a, b, c, topY, depth) {
+  if (depth <= 0) return capDeviation(a, b, c, topY);
+  const ab = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+  const bc = { x: (b.x + c.x) / 2, y: (b.y + c.y) / 2 };
+  const ca = { x: (c.x + a.x) / 2, y: (c.y + a.y) / 2 };
+  return Math.max(
+    maxDevAtDepth(a, ab, ca, topY, depth - 1),
+    maxDevAtDepth(ab, b, bc, topY, depth - 1),
+    maxDevAtDepth(ca, bc, c, topY, depth - 1),
+    maxDevAtDepth(ab, bc, ca, topY, depth - 1)
+  );
+}
+function emitCapUniform(builder, a, b, c, topY, colTop, depth, topN) {
+  if (depth > 0) {
+    const ab = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+    const bc = { x: (b.x + c.x) / 2, y: (b.y + c.y) / 2 };
+    const ca = { x: (c.x + a.x) / 2, y: (c.y + a.y) / 2 };
+    emitCapUniform(builder, a, ab, ca, topY, colTop, depth - 1, topN);
+    emitCapUniform(builder, ab, b, bc, topY, colTop, depth - 1, topN);
+    emitCapUniform(builder, ca, bc, c, topY, colTop, depth - 1, topN);
+    emitCapUniform(builder, ab, bc, ca, topY, colTop, depth - 1, topN);
+    return;
+  }
+  const at = [a.x * M, topY(a), a.y * M];
+  const bt = [b.x * M, topY(b), b.y * M];
+  const ct = [c.x * M, topY(c), c.y * M];
+  if (topN) {
+    builder.triN(at, bt, ct, topN(a), topN(b), topN(c), colTop);
+    return;
+  }
+  let n = faceNormal(at, bt, ct);
+  if (n[1] < 0) n = [-n[0], -n[1], -n[2]];
+  builder.tri(at, bt, ct, n, colTop);
+}
+var MAX_RING_SPLIT_DEPTH = 8;
+function densifyRing(ring, topY, maxError) {
+  if (!Number.isFinite(maxError)) return ring;
+  const out = [];
+  const emit = (p, q, yp, yq, depth) => {
+    if (depth > 0) {
+      const mid = { x: (p.x + q.x) / 2, y: (p.y + q.y) / 2 };
+      const ym = topY(mid);
+      if (Math.abs(ym - (yp + yq) / 2) > maxError) {
+        emit(p, mid, yp, ym, depth - 1);
+        emit(mid, q, ym, yq, depth - 1);
+        return;
+      }
+    }
+    out.push(p);
+  };
+  for (let i = 0; i < ring.length; i++) {
+    const p = ring[i], q = ring[(i + 1) % ring.length];
+    emit(p, q, topY(p), topY(q), MAX_RING_SPLIT_DEPTH);
+  }
+  return out;
+}
+function dedupeRing(ring, eps) {
+  if (ring.length < 3) return ring;
+  const out = [];
+  for (const p of ring) {
+    const last = out[out.length - 1];
+    if (last && Math.hypot(p.x - last.x, p.y - last.y) < eps) continue;
+    out.push(p);
+  }
+  while (out.length > 2 && Math.hypot(out[0].x - out[out.length - 1].x, out[0].y - out[out.length - 1].y) < eps) {
+    out.pop();
+  }
+  if (out.length < 3) return ring;
+  const keep = [];
+  for (let i = 0; i < out.length; i++) {
+    const prev = keep.length ? keep[keep.length - 1] : out[(i - 1 + out.length) % out.length];
+    const p = out[i];
+    const next = out[(i + 1) % out.length];
+    const ax = next.x - prev.x, ay = next.y - prev.y;
+    const len = Math.hypot(ax, ay);
+    if (len > eps) {
+      const cross = Math.abs((p.x - prev.x) * ay - (p.y - prev.y) * ax) / len;
+      if (cross < eps) continue;
+    }
+    keep.push(p);
+  }
+  return keep.length >= 3 ? keep : out;
+}
+var RING_EPS_U = 1e-3 * CHART_UNITS_PER_METRE * 0.1;
+function extrudePrism(builder, outlineIn, holesIn, topY, bottomY, colTop, colWall, ao, maxCapError = Infinity, topNormal) {
+  if (!outlineIn || outlineIn.length < 3) return;
+  if (maxCapError === void 0) maxCapError = Infinity;
+  if (Math.abs(signedArea(outlineIn)) < 1e-4) return;
+  const outline = dedupeRing(densifyRing(dedupeRing(toCCW(outlineIn), RING_EPS_U), topY, maxCapError), RING_EPS_U);
+  const holes = holesIn?.map((h) => dedupeRing(densifyRing(dedupeRing(toCCW(h), RING_EPS_U), topY, maxCapError), RING_EPS_U)).filter((h) => h.length >= 3 && Math.abs(signedArea(h)) >= 1e-4);
+  const { pts, tris } = triangulate(outline, holes);
+  const cTop = [colTop[0] * ao.top, colTop[1] * ao.top, colTop[2] * ao.top];
+  const cBot = [colTop[0] * ao.bottomCap, colTop[1] * ao.bottomCap, colTop[2] * ao.bottomCap];
+  const cWallTop = [colWall[0] * ao.top, colWall[1] * ao.top, colWall[2] * ao.top];
+  const cWallBot = [colWall[0] * ao.wallBottom, colWall[1] * ao.wallBottom, colWall[2] * ao.wallBottom];
+  let capDepth = 0;
+  if (Number.isFinite(maxCapError)) {
+    for (; capDepth < MAX_CAP_SPLIT_DEPTH; capDepth++) {
+      let worst = 0;
+      for (let i = 0; i < tris.length; i += 3) {
+        const d = maxDevAtDepth(pts[tris[i]], pts[tris[i + 1]], pts[tris[i + 2]], topY, capDepth);
+        if (d > worst) worst = d;
+      }
+      if (worst <= maxCapError) break;
+    }
+  }
+  for (let i = 0; i < tris.length; i += 3) {
+    const a = pts[tris[i]], b = pts[tris[i + 1]], c = pts[tris[i + 2]];
+    emitCapUniform(builder, a, b, c, topY, cTop, capDepth, topNormal);
+    const ab = [a.x * M, bottomY, a.y * M];
+    const bb = [b.x * M, bottomY, b.y * M];
+    const cb = [c.x * M, bottomY, c.y * M];
+    builder.tri(ab, cb, bb, [0, -1, 0], cBot);
+  }
+  const splitRing = (ring) => {
+    if (capDepth <= 0) return ring;
+    const n = 1 << capDepth;
+    const out = [];
+    for (let i = 0; i < ring.length; i++) {
+      const a = ring[i], b = ring[(i + 1) % ring.length];
+      for (let k = 0; k < n; k++) {
+        const t = k / n;
+        out.push({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
+      }
+    }
+    return out;
+  };
+  const oc = centroid(outline);
+  const rings = [{ ring: splitRing(outline), flip: false }];
+  if (holes) {
+    for (const h of holes) if (h.length >= 3) rings.push({ ring: splitRing(h), flip: true });
+  }
+  for (const { ring, flip } of rings) {
+    for (let i = 0; i < ring.length; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % ring.length];
+      const dx = (b.x - a.x) * M;
+      const dz = (b.y - a.y) * M;
+      let nx = dz, nz = -dx;
+      const nl = Math.hypot(nx, nz) || 1;
+      nx /= nl;
+      nz /= nl;
+      const mx = (a.x + b.x) / 2 - oc.x;
+      const mz = (a.y + b.y) / 2 - oc.y;
+      let dot = nx * mx + nz * mz;
+      if (flip) dot = -dot;
+      if (dot < 0) {
+        nx = -nx;
+        nz = -nz;
+      }
+      const n = [nx, 0, nz];
+      const aTop = [a.x * M, topY(a), a.y * M];
+      const bTop = [b.x * M, topY(b), b.y * M];
+      const aBot = [a.x * M, bottomY, a.y * M];
+      const bBot = [b.x * M, bottomY, b.y * M];
+      builder.tri(aTop, bTop, bBot, n, cWallTop, cWallTop, cWallBot);
+      builder.tri(aTop, bBot, aBot, n, cWallTop, cWallBot, cWallBot);
+    }
+  }
+}
+function mergeMeshData(parts) {
+  let total = 0;
+  for (const p of parts) total += p.count;
+  const position = new Float32Array(total * 3);
+  const normal = new Float32Array(total * 3);
+  const color = new Float32Array(total * 3);
+  const floor = new Float32Array(total);
+  let off = 0;
+  for (const p of parts) {
+    position.set(p.position, off * 3);
+    normal.set(p.normal, off * 3);
+    color.set(p.color, off * 3);
+    floor.set(p.floor, off);
+    off += p.count;
+  }
+  return { position, normal, color, floor, count: total };
+}
+function outsetRing(ring, d, miterLimit = 2.5) {
+  if (d <= 0 || ring.length < 3) return ring;
+  const r = toCCW(ring);
+  const n = r.length;
+  const nrm = [];
+  for (let i = 0; i < n; i++) {
+    const a = r[i], b = r[(i + 1) % n];
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const len = Math.hypot(dx, dy) || 1;
+    nrm.push({ x: dy / len, y: -dx / len });
+  }
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const p = r[i];
+    const nPrev = nrm[(i - 1 + n) % n];
+    const nCur = nrm[i];
+    let mx = nPrev.x + nCur.x, my = nPrev.y + nCur.y;
+    const ml = Math.hypot(mx, my);
+    const bevel = () => {
+      out.push([p.x + nPrev.x * d, p.y + nPrev.y * d]);
+      out.push([p.x + nCur.x * d, p.y + nCur.y * d]);
+    };
+    if (ml < 1e-9) {
+      bevel();
+      continue;
+    }
+    mx /= ml;
+    my /= ml;
+    const cosHalf = mx * nPrev.x + my * nPrev.y;
+    const scale2 = 1 / Math.max(cosHalf, 1e-6);
+    if (!Number.isFinite(scale2) || scale2 > miterLimit) {
+      bevel();
+      continue;
+    }
+    out.push([p.x + mx * d * scale2, p.y + my * d * scale2]);
+  }
+  if (out.length < 3) return ring;
+  try {
+    const merged = import_polygon_clipping.default.union([[...out, out[0]]]);
+    let best = null, bestArea = -Infinity;
+    for (const poly of merged) {
+      const area = Math.abs(signedArea(poly[0].map(([x, y]) => ({ x, y }))));
+      if (area > bestArea) {
+        bestArea = area;
+        best = poly[0];
+      }
+    }
+    if (!best) return ring;
+    const pts = best.map(([x, y]) => ({ x, y }));
+    if (pts.length > 1) {
+      const f = pts[0], l = pts[pts.length - 1];
+      if (Math.abs(f.x - l.x) < 1e-9 && Math.abs(f.y - l.y) < 1e-9) pts.pop();
+    }
+    return pts.length >= 3 ? pts : ring;
+  } catch {
+    return ring;
+  }
+}
+function ellipsePolygon(cx, cy, rx, ry, seg = 28) {
+  const out = [];
+  for (let i = 0; i < seg; i++) {
+    const a = i / seg * Math.PI * 2;
+    out.push({ x: cx + rx * Math.cos(a), y: cy + ry * Math.sin(a) });
+  }
+  return out;
+}
+function rectPolygon(x, y, w, h) {
+  return [
+    { x, y },
+    { x: x + w, y },
+    { x: x + w, y: y + h },
+    { x, y: y + h }
+  ];
+}
+
+// src/view3d/scene/seatInstances.ts
+var SEAT_DOT_RADIUS_M = 0.22;
+var SEAT_PITCH_FRACTION = 0.42;
+function nearestNeighbourSpacing(seats) {
+  const n = seats.length;
+  const out = new Float64Array(n);
+  if (n < 2) {
+    out.fill(Infinity);
+    return out;
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const s of seats) {
+    if (s.x < minX) minX = s.x;
+    if (s.y < minY) minY = s.y;
+    if (s.x > maxX) maxX = s.x;
+    if (s.y > maxY) maxY = s.y;
+  }
+  const w = Math.max(maxX - minX, 1e-6), h = Math.max(maxY - minY, 1e-6);
+  const cell = Math.max(Math.sqrt(w * h / n), 1e-6);
+  const cols = Math.max(1, Math.ceil(w / cell) + 1);
+  const rows = Math.max(1, Math.ceil(h / cell) + 1);
+  const buckets = /* @__PURE__ */ new Map();
+  const cellOf = (x, y) => {
+    const cx = Math.min(cols - 1, Math.max(0, Math.floor((x - minX) / cell)));
+    const cy = Math.min(rows - 1, Math.max(0, Math.floor((y - minY) / cell)));
+    return cy * cols + cx;
+  };
+  for (let i = 0; i < n; i++) {
+    const k = cellOf(seats[i].x, seats[i].y);
+    const b = buckets.get(k);
+    if (b) b.push(i);
+    else buckets.set(k, [i]);
+  }
+  for (let i = 0; i < n; i++) {
+    const s = seats[i];
+    const cx = Math.min(cols - 1, Math.max(0, Math.floor((s.x - minX) / cell)));
+    const cy = Math.min(rows - 1, Math.max(0, Math.floor((s.y - minY) / cell)));
+    let best = Infinity;
+    for (let r = 1; r <= 4; r++) {
+      for (let gy = cy - r; gy <= cy + r; gy++) {
+        if (gy < 0 || gy >= rows) continue;
+        for (let gx = cx - r; gx <= cx + r; gx++) {
+          if (gx < 0 || gx >= cols) continue;
+          if (r > 1 && Math.abs(gy - cy) < r && Math.abs(gx - cx) < r) continue;
+          const b = buckets.get(gy * cols + gx);
+          if (!b) continue;
+          for (const j of b) {
+            if (j === i) continue;
+            const d = Math.hypot(seats[j].x - s.x, seats[j].y - s.y);
+            if (d < best) best = d;
+          }
+        }
+      }
+      if (Number.isFinite(best) && best <= r * cell) break;
+    }
+    out[i] = best;
+  }
+  return out;
+}
+function seatSurfaceY(seat) {
+  const eye = seat.eyeHeightM;
+  if (Number.isFinite(eye)) return Math.max(0, eye - SEATED_EYE_HEIGHT_M);
+  return 0;
+}
+function buildSeatInstances(seats, initial, surfaces, seatFloor) {
+  const count = seats.length;
+  const iPosition = new Float32Array(count * 3);
+  const iState = new Float32Array(count);
+  const iMaxRadius = new Float32Array(count);
+  const iRing = new Float32Array(count * 3);
+  const idToIndex = /* @__PURE__ */ new Map();
+  const spacing = nearestNeighbourSpacing(seats);
+  for (let i = 0; i < count; i++) {
+    const seat = seats[i];
+    const resolved = surfaces?.seatPitchU(i);
+    const pitchM = (resolved ?? spacing[i]) * M;
+    iMaxRadius[i] = Number.isFinite(pitchM) ? Math.max(0.06, Math.min(SEAT_DOT_RADIUS_M, pitchM * SEAT_PITCH_FRACTION)) : SEAT_DOT_RADIUS_M;
+    iPosition[i * 3] = seat.x * M;
+    iPosition[i * 3 + 1] = surfaces ? surfaces.seatDeckY(i) : seatSurfaceY(seat);
+    iPosition[i * 3 + 2] = seat.y * M;
+    iState[i] = seatStateIndex(initial ? initial(seat) : "available");
+    if (seat.accessibility?.length) {
+      const rgb = hexToRgb(accessibilityRingColor(seat.accessibility));
+      if (rgb) {
+        iRing[i * 3] = rgb[0];
+        iRing[i * 3 + 1] = rgb[1];
+        iRing[i * 3 + 2] = rgb[2];
+      }
+    }
+    idToIndex.set(seat.id, i);
+  }
+  return {
+    count,
+    iPosition,
+    iState,
+    iMaxRadius,
+    iRing,
+    idToIndex,
+    iFloor: seatFloor ?? new Float32Array(count)
+  };
+}
+var RUN_MERGE_GAP = 64;
+function applySeatStates(data, updates) {
+  const changed = [];
+  for (const u of updates) {
+    const idx = data.idToIndex.get(u.seatId);
+    if (idx === void 0) continue;
+    const v = seatStateIndex(u.state);
+    if (data.iState[idx] !== v) {
+      data.iState[idx] = v;
+      changed.push(idx);
+    }
+  }
+  if (!changed.length) return [];
+  changed.sort((a, b) => a - b);
+  const runs = [];
+  let start = changed[0];
+  let prev = changed[0];
+  for (let i = 1; i < changed.length; i++) {
+    const idx = changed[i];
+    if (idx === prev) continue;
+    if (idx <= prev + RUN_MERGE_GAP) {
+      prev = idx;
+      continue;
+    }
+    runs.push({ start, length: prev - start + 1 });
+    start = idx;
+    prev = idx;
+  }
+  runs.push({ start, length: prev - start + 1 });
+  return runs;
+}
+
+// src/view3d/theme.ts
+var BACKGROUND_INFLUENCE = 0.15;
+var BG_TOP_SCALE = 0.9;
+var BG_BOTTOM_SCALE = 1.76;
+var SEAT_SCALE_MIN = 0.7;
+var SEAT_SCALE_MAX = 1.6;
+function defaultTheme3D() {
+  return {
+    background: { top: [...BACKGROUND.top], bottom: [...BACKGROUND.bottom] },
+    structure: STRUCTURE,
+    seatStates: { ...SEAT_STATE_COLORS },
+    seatScale: 1
+  };
+}
+function resolveTheme3D(theme) {
+  const base = defaultTheme3D();
+  if (!theme) return base;
+  const bg = hexToRgb(theme.background);
+  if (bg) {
+    base.background = {
+      top: scaleRgb(bg, BG_TOP_SCALE),
+      bottom: scaleRgb(bg, BG_BOTTOM_SCALE)
+    };
+    const rebased = {};
+    for (const [key, value] of Object.entries(STRUCTURE)) {
+      rebased[key] = mix(value, bg, BACKGROUND_INFLUENCE);
+    }
+    base.structure = rebased;
+  }
+  const selection = hexToRgb(theme.selectionColor) ?? hexToRgb(theme.accent);
+  if (selection) base.seatStates = { ...base.seatStates, selected: selection };
+  const scale2 = theme.seatScale;
+  if (typeof scale2 === "number" && Number.isFinite(scale2)) {
+    base.seatScale = Math.min(SEAT_SCALE_MAX, Math.max(SEAT_SCALE_MIN, scale2));
+  }
+  return base;
+}
+function themeSeatColorLUT(theme, order) {
+  const out = [];
+  for (const s of order) out.push(...theme.seatStates[s]);
+  return out;
+}
+
+// src/view3d/labels.ts
+var ZONE_MIN_DISTANCE = 1.15;
+var SECTION_MAX_DISTANCE = 2.2;
+var NEAR_MAX_DISTANCE = 0.85;
+function visibleLabelKinds(distance, venueRadius) {
+  const r = Math.max(1e-6, venueRadius);
+  const d = distance / r;
+  const out = /* @__PURE__ */ new Set();
+  if (d >= ZONE_MIN_DISTANCE) out.add("zone");
+  if (d <= SECTION_MAX_DISTANCE) out.add("section");
+  if (d <= NEAR_MAX_DISTANCE) {
+    out.add("annotation");
+    out.add("booth");
+  }
+  return out;
+}
+function projectToScreen(viewProjection, p, width, height) {
+  const m = viewProjection;
+  const x = p[0], y = p[1], z = p[2];
+  const cx = m[0] * x + m[4] * y + m[8] * z + m[12];
+  const cy = m[1] * x + m[5] * y + m[9] * z + m[13];
+  const cz = m[2] * x + m[6] * y + m[10] * z + m[14];
+  const cw = m[3] * x + m[7] * y + m[11] * z + m[15];
+  if (!(cw > 1e-6)) return { x: 0, y: 0, depth: Infinity, visible: false };
+  const ndcX = cx / cw, ndcY = cy / cw, ndcZ = cz / cw;
+  const inside = ndcX >= -1.05 && ndcX <= 1.05 && ndcY >= -1.05 && ndcY <= 1.05 && ndcZ <= 1;
+  return {
+    x: (ndcX * 0.5 + 0.5) * width,
+    y: (1 - (ndcY * 0.5 + 0.5)) * height,
+    depth: ndcZ,
+    visible: inside
+  };
+}
+function cullOverlapping(items, separationX, separationY = separationX) {
+  const kept = [];
+  const ordered = [...items].sort((a, b) => a.screen.depth - b.screen.depth);
+  for (const item of ordered) {
+    let clash = false;
+    for (const k of kept) {
+      const dx = Math.abs(item.screen.x - k.screen.x);
+      const dy = Math.abs(item.screen.y - k.screen.y);
+      if (dx < separationX && dy < separationY) {
+        clash = true;
+        break;
+      }
+    }
+    if (!clash) kept.push(item);
+  }
+  return kept;
+}
+function centroidOf(points) {
+  if (!points.length) return null;
+  let x = 0, y = 0;
+  for (const p of points) {
+    x += p.x;
+    y += p.y;
+  }
+  return { x: x / points.length, y: y / points.length };
+}
+
+// src/view3d/scene/sceneModel.ts
+var import_polygon_clipping3 = __toESM(require("polygon-clipping"), 1);
+
+// src/core/venueStructure.ts
+var BLOCK_LINK_RATIO = 1.8;
+function probesOf(pts) {
+  const n = pts.length;
+  if (n <= 3) return [...pts];
+  return [pts[Math.floor(n * 0.25)], pts[Math.floor(n * 0.5)], pts[Math.floor(n * 0.75)]];
+}
+function distanceToPolyline(pts, x, y) {
+  if (!pts.length) return Infinity;
+  if (pts.length === 1) return Math.hypot(x - pts[0].x, y - pts[0].y);
+  let best = Infinity;
+  for (let i = 0; i + 1 < pts.length; i++) {
+    const a = pts[i], b = pts[i + 1];
+    const vx = b.x - a.x, vy = b.y - a.y;
+    const len2 = vx * vx + vy * vy;
+    let t = len2 > 1e-12 ? ((x - a.x) * vx + (y - a.y) * vy) / len2 : 0;
+    if (t < 0) t = 0;
+    else if (t > 1) t = 1;
+    const d = Math.hypot(x - (a.x + t * vx), y - (a.y + t * vy));
+    if (d < best) best = d;
+  }
+  return best;
+}
+function boundOf(pts) {
+  let cx = 0, cy = 0;
+  for (const p of pts) {
+    cx += p.x;
+    cy += p.y;
+  }
+  const n = pts.length || 1;
+  cx /= n;
+  cy /= n;
+  let r = 0;
+  for (const p of pts) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > r) r = d;
+  }
+  return { cx, cy, r };
+}
+function boundGap(a, b) {
+  return Math.hypot(a.cx - b.cx, a.cy - b.cy) - a.r - b.r;
+}
+function rowGap(a, b) {
+  let best = Infinity;
+  for (const p of probesOf(a)) {
+    const d = distanceToPolyline(b, p.x, p.y);
+    if (d < best) best = d;
+  }
+  for (const p of probesOf(b)) {
+    const d = distanceToPolyline(a, p.x, p.y);
+    if (d < best) best = d;
+  }
+  return best;
+}
+function orderAlongRow(pts, indices) {
+  if (pts.length < 3) return { pts, seatIndices: indices };
+  let cx = 0, cy = 0;
+  for (const p of pts) {
+    cx += p.x;
+    cy += p.y;
+  }
+  cx /= pts.length;
+  cy /= pts.length;
+  let far = -1, ax = pts[0];
+  for (const p of pts) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > far) {
+      far = d;
+      ax = p;
+    }
+  }
+  let dx = ax.x - cx, dy = ax.y - cy;
+  const len = Math.hypot(dx, dy);
+  if (len > 1e-9) {
+    dx /= len;
+    dy /= len;
+  } else {
+    dx = 1;
+    dy = 0;
+  }
+  const order = pts.map((p, i) => ({ p, i, t: (p.x - cx) * dx + (p.y - cy) * dy })).sort((u, v) => u.t - v.t);
+  return { pts: order.map((o) => o.p), seatIndices: order.map((o) => indices[o.i]) };
+}
+function fitCircle(pts) {
+  const n = pts.length;
+  if (n < 3) return null;
+  let mx = 0, my = 0;
+  for (const p of pts) {
+    mx += p.x;
+    my += p.y;
+  }
+  mx /= n;
+  my /= n;
+  let suu = 0, suv = 0, svv = 0, suuu = 0, svvv = 0, suvv = 0, svuu = 0;
+  for (const p of pts) {
+    const u = p.x - mx, v = p.y - my;
+    suu += u * u;
+    svv += v * v;
+    suv += u * v;
+    suuu += u * u * u;
+    svvv += v * v * v;
+    suvv += u * v * v;
+    svuu += v * u * u;
+  }
+  const det = suu * svv - suv * suv;
+  if (Math.abs(det) < 1e-9) return null;
+  const b1 = (suuu + suvv) / 2;
+  const b2 = (svvv + svuu) / 2;
+  const uc = (b1 * svv - b2 * suv) / det;
+  const vc = (b2 * suu - b1 * suv) / det;
+  const cx = uc + mx, cy = vc + my;
+  if (!Number.isFinite(cx) || !Number.isFinite(cy)) return null;
+  return { cx, cy };
+}
+var CIRCLE_ROW_SPREAD_LIMIT = 0.15;
+function fitBlockAxis(group) {
+  if (group.length < 2) return null;
+  const cents = group.map((r) => {
+    let x = 0, y = 0;
+    for (const p of r.pts) {
+      x += p.x;
+      y += p.y;
+    }
+    return { x: x / r.pts.length, y: y / r.pts.length };
+  });
+  let ox = 0, oy = 0;
+  for (const c of cents) {
+    ox += c.x;
+    oy += c.y;
+  }
+  ox /= cents.length;
+  oy /= cents.length;
+  let sxx = 0, sxy = 0, syy = 0;
+  for (const c of cents) {
+    const dx = c.x - ox, dy = c.y - oy;
+    sxx += dx * dx;
+    sxy += dx * dy;
+    syy += dy * dy;
+  }
+  const tr = sxx + syy;
+  const det = sxx * syy - sxy * sxy;
+  const lambda = tr / 2 + Math.sqrt(Math.max(0, tr * tr / 4 - det));
+  let ax, ay;
+  if (Math.abs(sxy) > 1e-12) {
+    ax = lambda - syy;
+    ay = sxy;
+  } else if (sxx >= syy) {
+    ax = 1;
+    ay = 0;
+  } else {
+    ax = 0;
+    ay = 1;
+  }
+  const len = Math.hypot(ax, ay);
+  if (!(len > 1e-12)) return null;
+  ax /= len;
+  ay /= len;
+  let lo = Infinity, hi = -Infinity;
+  const widths = [];
+  for (const r of group) {
+    let rlo = Infinity, rhi = -Infinity;
+    for (const p of r.pts) {
+      const t = p.x * ax + p.y * ay;
+      if (t < rlo) rlo = t;
+      if (t > rhi) rhi = t;
+      if (t < lo) lo = t;
+      if (t > hi) hi = t;
+    }
+    widths.push(rhi - rlo);
+  }
+  const range = hi - lo;
+  if (!(range > 1e-9)) return null;
+  widths.sort((a, b) => a - b);
+  const p90 = widths[Math.min(widths.length - 1, Math.floor(widths.length * 0.9))];
+  return p90 / range <= AXIS_ROW_WIDTH_LIMIT ? { x: ax, y: ay } : null;
+}
+var AXIS_ROW_WIDTH_LIMIT = 0.35;
+function resolveSection(sectionId, seats, seatIndices, focal) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const i of seatIndices) {
+    const s = seats[i];
+    const key = s.rowId || `__seat-${i}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { pts: [], idx: [] };
+      groups.set(key, g);
+    }
+    g.pts.push({ x: s.x, y: s.y });
+    g.idx.push(i);
+  }
+  if (!groups.size) return { sectionId, rows: [], blockCount: 0 };
+  const rows = [];
+  for (const [id, g] of groups) {
+    const ordered = orderAlongRow(g.pts, g.idx);
+    let sum = 0;
+    for (const p of ordered.pts) sum += Math.hypot(p.x - focal.x, p.y - focal.y);
+    rows.push({
+      id,
+      pts: ordered.pts,
+      seatIndices: ordered.seatIndices,
+      blockId: -1,
+      ordinal: 0,
+      blockDepth: 0,
+      focalDistance: sum / ordered.pts.length
+    });
+  }
+  const bounds = rows.map((r) => boundOf(r.pts));
+  const nearest = [];
+  for (let i = 0; i < rows.length; i++) {
+    let best = Infinity;
+    for (let j = 0; j < rows.length; j++) {
+      if (i === j) continue;
+      if (boundGap(bounds[i], bounds[j]) >= best) continue;
+      const d = rowGap(rows[i].pts, rows[j].pts);
+      if (d < best) best = d;
+    }
+    if (Number.isFinite(best)) nearest.push(best);
+  }
+  nearest.sort((a, b) => a - b);
+  const typicalGap = nearest.length ? nearest[Math.floor(nearest.length / 2)] : 1;
+  const linkDistance = Math.max(typicalGap * BLOCK_LINK_RATIO, 1e-6);
+  const adjacency = rows.map(() => []);
+  for (let i = 0; i < rows.length; i++) {
+    for (let j = i + 1; j < rows.length; j++) {
+      if (boundGap(bounds[i], bounds[j]) > linkDistance) continue;
+      if (rowGap(rows[i].pts, rows[j].pts) <= linkDistance) {
+        adjacency[i].push(j);
+        adjacency[j].push(i);
+      }
+    }
+  }
+  let blockCount = 0;
+  for (let i = 0; i < rows.length; i++) {
+    if (rows[i].blockId !== -1) continue;
+    const id = blockCount++;
+    const stack = [i];
+    rows[i].blockId = id;
+    while (stack.length) {
+      const k = stack.pop();
+      for (const n of adjacency[k]) {
+        if (rows[n].blockId !== -1) continue;
+        rows[n].blockId = id;
+        stack.push(n);
+      }
+    }
+  }
+  const byBlock = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const a = byBlock.get(r.blockId) ?? [];
+    a.push(r);
+    byBlock.set(r.blockId, a);
+  }
+  const centres = [];
+  for (const r of rows) {
+    if (r.pts.length < 4) continue;
+    const c = fitCircle(r.pts);
+    if (!c) continue;
+    if (!Number.isFinite(c.cx) || !Number.isFinite(c.cy)) continue;
+    centres.push({ x: c.cx, y: c.cy });
+  }
+  const centre = centres.length >= 2 ? (() => {
+    const xs = centres.map((c) => c.x).sort((a, b) => a - b);
+    const ys = centres.map((c) => c.y).sort((a, b) => a - b);
+    const mid = Math.floor(centres.length / 2);
+    return { cx: xs[mid], cy: ys[mid] };
+  })() : null;
+  if (centre) {
+    const radiusOf = (p) => Math.hypot(p.x - centre.cx, p.y - centre.cy);
+    let lo = Infinity, hi = -Infinity;
+    const spreads = [];
+    for (const r of rows) {
+      let rlo = Infinity, rhi = -Infinity;
+      for (const p of r.pts) {
+        const d = radiusOf(p);
+        if (d < rlo) rlo = d;
+        if (d > rhi) rhi = d;
+      }
+      spreads.push(rhi - rlo);
+      if (rlo < lo) lo = rlo;
+      if (rhi > hi) hi = rhi;
+    }
+    const range = hi - lo;
+    spreads.sort((a, b) => a - b);
+    const p90 = spreads[Math.min(spreads.length - 1, Math.floor(spreads.length * 0.9))];
+    if (range > 1e-9 && p90 / range <= CIRCLE_ROW_SPREAD_LIMIT) {
+      const withRadius = rows.map((r) => {
+        let sum = 0;
+        for (const p of r.pts) sum += radiusOf(p);
+        return { row: r, radius: sum / r.pts.length };
+      });
+      let minR = Infinity;
+      for (const w of withRadius) if (w.radius < minR) minR = w.radius;
+      withRadius.sort((a, b) => a.radius - b.radius);
+      let ordinal = -1, lastRadius = -Infinity;
+      const tolerance = range / Math.max(1, withRadius.length) * 0.5;
+      const ordered = [];
+      for (const w of withRadius) {
+        if (w.radius - lastRadius > tolerance) {
+          ordinal++;
+          lastRadius = w.radius;
+        }
+        w.row.ordinal = ordinal;
+        w.row.blockDepth = w.radius - minR;
+        ordered.push(w.row);
+      }
+      return { sectionId, rows: ordered, blockCount };
+    }
+  }
+  const out = [];
+  for (const [, group] of byBlock) {
+    const axis = fitBlockAxis(group);
+    if (axis) {
+      const key = (r) => {
+        let sum = 0;
+        for (const p of r.pts) sum += p.x * axis.x + p.y * axis.y;
+        return sum / r.pts.length;
+      };
+      group.sort((a, b) => key(a) - key(b));
+      let depth = 0;
+      for (let i = 0; i < group.length; i++) {
+        if (i > 0) depth += rowGap(group[i - 1].pts, group[i].pts);
+        group[i].ordinal = i;
+        group[i].blockDepth = depth;
+        out.push(group[i]);
+      }
+    } else {
+      let front = Infinity;
+      for (const r of group) if (r.focalDistance < front) front = r.focalDistance;
+      group.sort((a, b) => a.focalDistance - b.focalDistance);
+      for (let i = 0; i < group.length; i++) {
+        group[i].ordinal = i;
+        group[i].blockDepth = Math.max(0, group[i].focalDistance - front);
+        out.push(group[i]);
+      }
+    }
+  }
+  return { sectionId, rows: out, blockCount };
+}
+
+// src/core/layout.ts
+var DEG2 = Math.PI / 180;
+function pointInPolygon(p, poly) {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const xi = poly[i].x;
+    const yi = poly[i].y;
+    const xj = poly[j].x;
+    const yj = poly[j].y;
+    const hit = yi > p.y !== yj > p.y && p.x < (xj - xi) * (p.y - yi) / (yj - yi) + xi;
+    if (hit) inside = !inside;
+  }
+  return inside;
+}
+function pointOnPolygonBoundary(p, poly) {
+  return poly.some((start, index) => {
+    const end = poly[(index + 1) % poly.length];
+    const cross = (p.y - start.y) * (end.x - start.x) - (p.x - start.x) * (end.y - start.y);
+    if (Math.abs(cross) > 1e-7) return false;
+    const dot = (p.x - start.x) * (end.x - start.x) + (p.y - start.y) * (end.y - start.y);
+    const lengthSquared = (end.x - start.x) ** 2 + (end.y - start.y) ** 2;
+    return dot >= -1e-7 && dot <= lengthSquared + 1e-7;
+  });
+}
+function pointInPolygonWithHoles(p, outer, holes) {
+  return pointInPolygon(p, outer) && !(holes ?? []).some((hole) => pointInPolygon(p, hole) || pointOnPolygonBoundary(p, hole));
+}
+
+// src/core/rake.ts
+var BLEND_ROWS = 3;
+var BLEND_DISTANCE_RATIO = 2.2;
+var GRAD_STEP = 0.5;
+function radialRake(focal) {
+  return {
+    kind: "radial",
+    rowCount: 0,
+    rows: [],
+    nearestRow: () => -1,
+    depthAt: (x, y) => Math.hypot(x - focal.x, y - focal.y),
+    gradientAt: (x, y) => {
+      const dx = x - focal.x, dy = y - focal.y;
+      const d = Math.hypot(dx, dy);
+      return d < 1e-9 ? [0, 0] : [dx / d, dy / d];
+    }
+  };
+}
+function fitRow(points, focal) {
+  if (!points.length) return null;
+  let cx = 0, cy = 0, depth = 0;
+  for (const p of points) {
+    cx += p.x;
+    cy += p.y;
+    depth += Math.hypot(p.x - focal.x, p.y - focal.y);
+  }
+  const n = points.length;
+  cx /= n;
+  cy /= n;
+  depth /= n;
+  let ax = points[0], far = -1;
+  for (const p of points) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > far) {
+      far = d;
+      ax = p;
+    }
+  }
+  let dx = ax.x - cx, dy = ax.y - cy;
+  const len = Math.hypot(dx, dy);
+  if (len > 1e-9) {
+    dx /= len;
+    dy /= len;
+  } else {
+    dx = 1;
+    dy = 0;
+  }
+  const pts = [...points].sort((p, q) => (p.x - cx) * dx + (p.y - cy) * dy - ((q.x - cx) * dx + (q.y - cy) * dy));
+  let radius = 0;
+  for (const p of pts) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > radius) radius = d;
+  }
+  return { pts, cx, cy, radius, depth };
+}
+function distToRow(r, x, y) {
+  const pts = r.pts;
+  if (pts.length === 1) return Math.hypot(x - pts[0].x, y - pts[0].y);
+  let best = Infinity;
+  for (let i = 0; i + 1 < pts.length; i++) {
+    const a = pts[i], b = pts[i + 1];
+    const vx = b.x - a.x, vy = b.y - a.y;
+    const len2 = vx * vx + vy * vy;
+    let t = len2 > 1e-12 ? ((x - a.x) * vx + (y - a.y) * vy) / len2 : 0;
+    if (t < 0) t = 0;
+    else if (t > 1) t = 1;
+    const d = Math.hypot(x - (a.x + t * vx), y - (a.y + t * vy));
+    if (d < best) best = d;
+  }
+  return best;
+}
+var CANDIDATE_ROWS = 8;
+function sampleRows(rows, x, y) {
+  const candD = new Array(CANDIDATE_ROWS).fill(Infinity);
+  const candI = new Array(CANDIDATE_ROWS).fill(-1);
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    const lower = Math.hypot(x - r.cx, y - r.cy) - r.radius;
+    for (let k = 0; k < CANDIDATE_ROWS; k++) {
+      if (lower < candD[k]) {
+        for (let j = CANDIDATE_ROWS - 1; j > k; j--) {
+          candD[j] = candD[j - 1];
+          candI[j] = candI[j - 1];
+        }
+        candD[k] = lower;
+        candI[k] = i;
+        break;
+      }
+    }
+  }
+  const bestD = new Array(BLEND_ROWS).fill(Infinity);
+  const bestI = new Array(BLEND_ROWS).fill(-1);
+  for (const i of candI) {
+    if (i < 0) continue;
+    const d = distToRow(rows[i], x, y);
+    for (let k = 0; k < BLEND_ROWS; k++) {
+      if (d < bestD[k]) {
+        for (let j = BLEND_ROWS - 1; j > k; j--) {
+          bestD[j] = bestD[j - 1];
+          bestI[j] = bestI[j - 1];
+        }
+        bestD[k] = d;
+        bestI[k] = i;
+        break;
+      }
+    }
+  }
+  if (bestI[0] < 0) return 0;
+  if (bestD[0] < 1e-6) return rows[bestI[0]].depth;
+  const cutoff = bestD[0] * BLEND_DISTANCE_RATIO;
+  let num = 0, den = 0;
+  for (let k = 0; k < BLEND_ROWS; k++) {
+    const i = bestI[k];
+    if (i < 0 || bestD[k] > cutoff) continue;
+    const w = 1 / (bestD[k] * bestD[k]);
+    num += w * rows[i].depth;
+    den += w;
+  }
+  return den > 0 ? num / den : rows[bestI[0]].depth;
+}
+function rowsRake(rows) {
+  const depthAt = (x, y) => sampleRows(rows, x, y);
+  const nearestRow = (x, y) => {
+    let best = Infinity, bestI = -1;
+    for (let i = 0; i < rows.length; i++) {
+      const r = rows[i];
+      if (Math.hypot(x - r.cx, y - r.cy) - r.radius >= best) continue;
+      const d = distToRow(r, x, y);
+      if (d < best) {
+        best = d;
+        bestI = i;
+      }
+    }
+    return bestI;
+  };
+  return {
+    kind: "rows",
+    rowCount: rows.length,
+    rows,
+    nearestRow,
+    depthAt,
+    gradientAt: (x, y) => {
+      const gx = (depthAt(x + GRAD_STEP, y) - depthAt(x - GRAD_STEP, y)) / (2 * GRAD_STEP);
+      const gy = (depthAt(x, y + GRAD_STEP) - depthAt(x, y - GRAD_STEP)) / (2 * GRAD_STEP);
+      const len = Math.hypot(gx, gy);
+      return len < 1e-9 ? [0, 0] : [gx / len, gy / len];
+    }
+  };
+}
+function buildSectionRake(rows, focal) {
+  const fits = [];
+  for (const r of rows) {
+    const f = fitRow(r.points, focal);
+    if (f) fits.push(f);
+  }
+  if (fits.length < 2) return radialRake(focal);
+  fits.sort((a, b) => a.depth - b.depth);
+  return rowsRake(fits);
+}
+
+// src/view3d/scene/surface.ts
+var FLAT_SLAB_TOP_M = 0.05;
+var CAP_MAX_ERROR_M = 0.05;
+var SEAT_CLEARANCE_M = 0.15;
+var SEAT_OWNERSHIP_PAD_U = SEAT_DOT_RADIUS_M * 1.5 * CHART_UNITS_PER_METRE;
+function bboxOf(pts) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of pts) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+var MAX_TIER_RISE_M = 25;
+function buildVenueSurfaces(units, seats) {
+  const bySection = /* @__PURE__ */ new Map();
+  const seatOwner = new Array(seats.length).fill(null);
+  const seatDeck = new Float64Array(seats.length);
+  const seatRowLevel = new Array(seats.length).fill(void 0);
+  const seatPitch = new Array(seats.length).fill(void 0);
+  const acc = /* @__PURE__ */ new Map();
+  const boxes = [];
+  for (const unit of units) {
+    for (const o of unit.objects) {
+      if (o.type !== "section" || !o.outline || o.outline.length < 3) continue;
+      const owned = outsetRing(o.outline, SEAT_OWNERSHIP_PAD_U);
+      acc.set(o.id, { section: o, unit, frontU: Infinity, hasSeats: false, rows: /* @__PURE__ */ new Map(), seatIndices: [] });
+      boxes.push({ id: o.id, box: bboxOf(owned), section: o, unit, outline: owned });
+    }
+  }
+  for (let i = 0; i < seats.length; i++) {
+    const s = seats[i];
+    for (const b of boxes) {
+      if (s.x < b.box.minX || s.x > b.box.maxX || s.y < b.box.minY || s.y > b.box.maxY) continue;
+      if (!pointInPolygonWithHoles({ x: s.x, y: s.y }, b.outline, b.section.holes)) continue;
+      seatOwner[i] = b.id;
+      const a = acc.get(b.id);
+      a.hasSeats = true;
+      const f = s.focalPoint ?? b.unit.focal;
+      const d = Math.hypot(s.x - f.x, s.y - f.y);
+      if (d < a.frontU) a.frontU = d;
+      a.seatIndices.push(i);
+      const rowKey = s.rowId || `__seat-${i}`;
+      const arr = a.rows.get(rowKey);
+      if (arr) arr.push({ x: s.x, y: s.y });
+      else a.rows.set(rowKey, [{ x: s.x, y: s.y }]);
+      break;
+    }
+  }
+  for (const [id, a] of acc) {
+    const geo = sectionGeometry(a.section, { floorBaseHeightM: a.unit.baseHeightM });
+    const bottomY = a.unit.baseHeightM;
+    const rakeTan = geo.rake > 0 ? Math.tan(geo.rake * Math.PI / 180) : 0;
+    const inferredFlat = geo.rake <= 0.01 && geo.height <= bottomY + 1e-3;
+    const kind = a.section.surfaceKind;
+    const flat = kind === "flat" ? true : kind === "rakedRows" ? geo.rake > 0.01 ? false : inferredFlat : inferredFlat;
+    const rake = buildSectionRake([...a.rows.values()].map((points) => ({ points })), a.unit.focal);
+    let frontU = Infinity;
+    if (a.hasSeats) {
+      for (const pts of a.rows.values()) {
+        for (const p of pts) {
+          const d = rake.depthAt(p.x, p.y);
+          if (d < frontU) frontU = d;
+        }
+      }
+    }
+    if (!a.hasSeats || !Number.isFinite(frontU)) {
+      frontU = Infinity;
+      for (const p of a.section.outline) {
+        const d = rake.depthAt(p.x, p.y);
+        if (d < frontU) frontU = d;
+      }
+    }
+    const flatTop = bottomY + FLAT_SLAB_TOP_M;
+    const baseFloor = bottomY + FLAT_SLAB_TOP_M;
+    const levelFor = (depthU) => {
+      const depthM = Math.max(0, depthU - frontU) * METRES_PER_CHART_UNIT;
+      const rise = Math.min(depthM * rakeTan, MAX_TIER_RISE_M);
+      return Math.max(baseFloor, geo.height + rise);
+    };
+    const levelForBlockDepth = (blockDepthU) => {
+      const depthM = Math.max(0, blockDepthU) * METRES_PER_CHART_UNIT;
+      const rise = Math.min(depthM * rakeTan, MAX_TIER_RISE_M);
+      return Math.max(baseFloor, geo.height + rise);
+    };
+    const structure = a.hasSeats ? resolveSection(id, seats, a.seatIndices, a.unit.focal) : { sectionId: id, rows: [], blockCount: 0 };
+    const rowLevels = flat ? [] : structure.rows.map((r) => ({
+      pts: r.pts,
+      y: levelForBlockDepth(r.blockDepth),
+      depth: r.blockDepth,
+      blockId: r.blockId
+    }));
+    const landingY = rowLevels.length ? rowLevels[0].y : flatTop;
+    const rowBounds = rowLevels.map((r) => {
+      let cx = 0, cy = 0;
+      for (const p of r.pts) {
+        cx += p.x;
+        cy += p.y;
+      }
+      const n = r.pts.length || 1;
+      cx /= n;
+      cy /= n;
+      let rad = 0;
+      for (const p of r.pts) {
+        const d = Math.hypot(p.x - cx, p.y - cy);
+        if (d > rad) rad = d;
+      }
+      return { cx, cy, rad };
+    });
+    const deckAt = flat ? () => flatTop : rowLevels.length >= 2 ? (x, y) => {
+      let best = Infinity, bestY = landingY;
+      for (let i = 0; i < rowLevels.length; i++) {
+        const b = rowBounds[i];
+        if (Math.hypot(x - b.cx, y - b.cy) - b.rad >= best) continue;
+        const d = distanceToPolyline(rowLevels[i].pts, x, y);
+        if (d < best) {
+          best = d;
+          bestY = rowLevels[i].y;
+        }
+      }
+      return bestY;
+    } : (x, y) => levelFor(rake.depthAt(x, y));
+    const UP = [0, 1, 0];
+    const normalAt = rowLevels.length >= 2 || flat ? () => UP : (x, y) => {
+      const d = rake.depthAt(x, y);
+      if (d <= frontU) return UP;
+      const depthM = (d - frontU) * METRES_PER_CHART_UNIT;
+      if (depthM * rakeTan >= MAX_TIER_RISE_M) return UP;
+      if (geo.height + depthM * rakeTan <= baseFloor) return UP;
+      const [gx, gy] = rake.gradientAt(x, y);
+      if (gx === 0 && gy === 0) return UP;
+      const inv = 1 / Math.hypot(rakeTan, 1);
+      return [-gx * rakeTan * inv, inv, -gy * rakeTan * inv];
+    };
+    if (!flat) {
+      for (const r of structure.rows) {
+        const y = levelForBlockDepth(r.blockDepth);
+        for (const si of r.seatIndices) seatRowLevel[si] = y;
+      }
+    }
+    for (const r of structure.rows) {
+      const gaps = [];
+      for (let k = 1; k < r.pts.length; k++) {
+        const d = Math.hypot(r.pts[k].x - r.pts[k - 1].x, r.pts[k].y - r.pts[k - 1].y);
+        if (d > 1e-6) gaps.push(d);
+      }
+      gaps.sort((x, y) => x - y);
+      const along = gaps.length ? gaps[Math.floor(gaps.length / 2)] : Infinity;
+      let across = Infinity;
+      const probe = r.pts[Math.floor(r.pts.length / 2)];
+      if (probe) {
+        for (const other of structure.rows) {
+          if (other === r || other.blockId !== r.blockId) continue;
+          const d = distanceToPolyline(other.pts, probe.x, probe.y);
+          if (d > 1e-6 && d < across) across = d;
+        }
+      }
+      const pitch = Math.min(along, Math.max(across, along * 0.5));
+      if (Number.isFinite(pitch) && pitch > 0) {
+        for (const si of r.seatIndices) seatPitch[si] = pitch;
+      }
+    }
+    bySection.set(id, { sectionId: id, deckAt, normalAt, flat, bottomY, rowLevels, landingY });
+  }
+  for (let i = 0; i < seats.length; i++) {
+    const ownerId = seatOwner[i];
+    const s = seats[i];
+    if (ownerId) {
+      const own = seatRowLevel[i];
+      seatDeck[i] = (own ?? bySection.get(ownerId).deckAt(s.x, s.y)) + SEAT_CLEARANCE_M;
+      continue;
+    }
+    const eye = s.eyeHeightM;
+    seatDeck[i] = Number.isFinite(eye) ? Math.max(0, eye - SEATED_EYE_HEIGHT_M) : 0;
+  }
+  return {
+    bySection,
+    seatOwner,
+    seatDeckY: (i) => seatDeck[i],
+    seatPitchU: (i) => seatPitch[i]
+  };
+}
+
+// src/view3d/scene/deckBands.ts
+var import_polygon_clipping2 = __toESM(require("polygon-clipping"), 1);
+var import_earcut2 = __toESM(require("earcut"), 1);
+var FRONT_REACH = 0.58;
+var MIN_RISER_M = 0.01;
+var MIN_REACH_U = SEAT_DOT_RADIUS_M * 1.5 * CHART_UNITS_PER_METRE;
+var BACK_REACH = 0.5;
+var END_REACH = 0.6;
+function rowNormals(pts, focal) {
+  const n = pts.length;
+  const raw = [];
+  for (let i = 0; i < n; i++) {
+    const a = pts[Math.max(0, i - 1)];
+    const b = pts[Math.min(n - 1, i + 1)];
+    let dx = b.x - a.x, dy = b.y - a.y;
+    const len = Math.hypot(dx, dy);
+    if (len < 1e-9) {
+      raw.push([0, 0]);
+      continue;
+    }
+    dx /= len;
+    dy /= len;
+    raw.push([-dy, dx]);
+  }
+  let vote = 0;
+  for (let i = 0; i < n; i++) {
+    vote += (pts[i].x - focal.x) * raw[i][0] + (pts[i].y - focal.y) * raw[i][1];
+  }
+  const flip = vote < 0;
+  return flip ? raw.map(([x, y]) => [-x, -y]) : raw;
+}
+function extendEnds(pts, by) {
+  if (pts.length < 2 || by <= 0) return [...pts];
+  const out = [...pts];
+  const dir = (p, q) => {
+    const dx = q.x - p.x, dy = q.y - p.y;
+    const len = Math.hypot(dx, dy) || 1;
+    return { x: dx / len, y: dy / len };
+  };
+  const head = dir(out[1], out[0]);
+  const tail = dir(out[out.length - 2], out[out.length - 1]);
+  out.unshift({ x: out[0].x + head.x * by, y: out[0].y + head.y * by });
+  out.push({
+    x: out[out.length - 1].x + tail.x * by,
+    y: out[out.length - 1].y + tail.y * by
+  });
+  return out;
+}
+function distToPolyline(pts, x, y) {
+  if (pts.length === 1) return Math.hypot(x - pts[0].x, y - pts[0].y);
+  let best = Infinity;
+  for (let i = 0; i + 1 < pts.length; i++) {
+    const a = pts[i], b = pts[i + 1];
+    const vx = b.x - a.x, vy = b.y - a.y;
+    const len2 = vx * vx + vy * vy;
+    let t = len2 > 1e-12 ? ((x - a.x) * vx + (y - a.y) * vy) / len2 : 0;
+    if (t < 0) t = 0;
+    else if (t > 1) t = 1;
+    const d = Math.hypot(x - (a.x + t * vx), y - (a.y + t * vy));
+    if (d < best) best = d;
+  }
+  return best;
+}
+function neighbourhoods(rows) {
+  const probesOf2 = (pts) => {
+    const n = pts.length;
+    if (n <= 2) return [...pts];
+    return [pts[Math.floor(n * 0.25)], pts[Math.floor(n * 0.5)], pts[Math.floor(n * 0.75)]];
+  };
+  const out = [];
+  for (let i = 0; i < rows.length; i++) {
+    const probes = probesOf2(rows[i].pts);
+    const pitches = [];
+    let bestFrontD = Infinity, belowY = null;
+    for (const c of probes) {
+      let nearest = Infinity;
+      for (let j = 0; j < rows.length; j++) {
+        if (j === i || Math.abs(rows[j].y - rows[i].y) < 1e-3) continue;
+        const d = distToPolyline(rows[j].pts, c.x, c.y);
+        if (d < nearest) nearest = d;
+        if (rows[j].depth < rows[i].depth && d < bestFrontD) {
+          bestFrontD = d;
+          belowY = rows[j].y;
+        }
+      }
+      if (Number.isFinite(nearest) && nearest > 0) pitches.push(nearest);
+    }
+    pitches.sort((a, b) => a - b);
+    const pitch = pitches.length ? pitches[Math.floor(pitches.length / 2)] : 1;
+    out.push({ pitch, belowY });
+  }
+  return out;
+}
+function ribbonOf(rows, i, nbrs, focal) {
+  const row = rows[i];
+  const rowPts = row.pts.length >= 2 ? [...row.pts] : row.pts.length === 1 ? (() => {
+    const p = row.pts[0];
+    let dx = p.x - focal.x, dy = p.y - focal.y;
+    const len = Math.hypot(dx, dy) || 1;
+    dx /= len;
+    dy /= len;
+    const h = Math.max(nbrs[i].pitch, 1e-3) * 0.5;
+    return [{ x: p.x + dy * h, y: p.y - dx * h }, { x: p.x - dy * h, y: p.y + dx * h }];
+  })() : [];
+  if (rowPts.length < 2) return null;
+  let seatSpan = 0, spanN = 0;
+  for (let k = 1; k < rowPts.length; k++) {
+    const d = Math.hypot(rowPts[k].x - rowPts[k - 1].x, rowPts[k].y - rowPts[k - 1].y);
+    if (d > 1e-6) {
+      seatSpan += d;
+      spanN++;
+    }
+  }
+  const spacing = spanN > 0 ? seatSpan / spanN : 0;
+  const pts = extendEnds(rowPts, Math.max(spacing * END_REACH, MIN_REACH_U));
+  return {
+    pts,
+    nrm: rowNormals(pts, focal),
+    front: Math.max(nbrs[i].pitch * FRONT_REACH, MIN_REACH_U),
+    back: Math.max(nbrs[i].pitch * BACK_REACH, MIN_REACH_U)
+  };
+}
+function deckFootprints(rows, focal) {
+  if (rows.length < 2) return [];
+  const nbrs = neighbourhoods(rows);
+  const rings = [];
+  const ribbons = [];
+  for (let i = 0; i < rows.length; i++) {
+    const r = ribbonOf(rows, i, nbrs, focal);
+    ribbons.push(r);
+    if (!r) continue;
+    const f = [];
+    const b = [];
+    const rf = r.front + FOOTPRINT_MARGIN_U;
+    const rb = r.back + FOOTPRINT_MARGIN_U;
+    for (let k = 0; k < r.pts.length; k++) {
+      const p = r.pts[k], n = r.nrm[k];
+      f.push([p.x - n[0] * rf, p.y - n[1] * rf]);
+      b.push([p.x + n[0] * rb, p.y + n[1] * rb]);
+    }
+    const ring = [...f, ...b.reverse()];
+    if (ring.length < 3) continue;
+    ring.push(ring[0]);
+    rings.push([ring]);
+  }
+  if (!rings.length) return [];
+  let merged;
+  try {
+    merged = import_polygon_clipping2.default.union(rings[0], ...rings.slice(1));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const poly of merged) {
+    if (!poly.length || poly[0].length < 4) continue;
+    const toPts = (ring) => {
+      const pts = ring.map(([x, y]) => ({ x, y }));
+      const first = pts[0], last = pts[pts.length - 1];
+      if (pts.length > 1 && Math.abs(first.x - last.x) < 1e-9 && Math.abs(first.y - last.y) < 1e-9) pts.pop();
+      return pts;
+    };
+    const outline = toPts(poly[0]);
+    if (outline.length < 3) continue;
+    let topY = Infinity;
+    for (let i = 0; i < rows.length; i++) {
+      const r = ribbons[i];
+      if (!r) continue;
+      const mid = r.pts[Math.floor(r.pts.length / 2)];
+      if (pointInRing(outline, mid.x, mid.y) && rows[i].y < topY) topY = rows[i].y;
+    }
+    if (!Number.isFinite(topY)) continue;
+    out.push({
+      outline: simplifyRing(outline, FOOTPRINT_TOLERANCE_U),
+      holes: poly.slice(1).map(toPts).map((h) => simplifyRing(h, FOOTPRINT_TOLERANCE_U)).filter((h) => h.length >= 3),
+      topY
+    });
+  }
+  return out;
+}
+var FOOTPRINT_TOLERANCE_U = 0.3;
+var FOOTPRINT_MARGIN_U = 1.5;
+function simplifyRun(pts, tol) {
+  if (pts.length < 3) return pts;
+  const a = pts[0], b = pts[pts.length - 1];
+  const dx = b.x - a.x, dy = b.y - a.y;
+  const len = Math.hypot(dx, dy);
+  let worst = -1, worstI = -1;
+  for (let i = 1; i < pts.length - 1; i++) {
+    const p = pts[i];
+    const d = len > 1e-12 ? Math.abs((p.x - a.x) * dy - (p.y - a.y) * dx) / len : Math.hypot(p.x - a.x, p.y - a.y);
+    if (d > worst) {
+      worst = d;
+      worstI = i;
+    }
+  }
+  if (worst <= tol || worstI < 0) return [a, b];
+  const left = simplifyRun(pts.slice(0, worstI + 1), tol);
+  const right = simplifyRun(pts.slice(worstI), tol);
+  return [...left.slice(0, -1), ...right];
+}
+function simplifyRing(ring, tol) {
+  if (ring.length < 4) return ring;
+  const out = simplifyRun([...ring, ring[0]], tol);
+  out.pop();
+  return out.length >= 3 ? out : ring;
+}
+function pointInRing(ring, x, y) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const a = ring[i], b = ring[j];
+    if (a.y > y !== b.y > y && x < (b.x - a.x) * (y - a.y) / (b.y - a.y) + a.x) inside = !inside;
+  }
+  return inside;
+}
+var ClipTest = class {
+  constructor(rings) {
+    this.minX = Infinity;
+    this.minY = Infinity;
+    this.maxX = -Infinity;
+    this.maxY = -Infinity;
+    this.rings = rings;
+    for (const r of rings) {
+      for (const p of r) {
+        if (p.x < this.minX) this.minX = p.x;
+        if (p.y < this.minY) this.minY = p.y;
+        if (p.x > this.maxX) this.maxX = p.x;
+        if (p.y > this.maxY) this.maxY = p.y;
+      }
+    }
+  }
+  /** True when every point lies strictly inside ONE ring of the clip region. */
+  containsAll(pts) {
+    for (const p of pts) {
+      if (p.x < this.minX || p.x > this.maxX || p.y < this.minY || p.y > this.maxY) return false;
+    }
+    for (const ring of this.rings) {
+      let all = true;
+      for (const p of pts) {
+        if (!pointInRing(ring, p.x, p.y)) {
+          all = false;
+          break;
+        }
+      }
+      if (all) return true;
+    }
+    return false;
+  }
+};
+function emitClippedQuad(builder, clipRing, clipTest, quad, y, color) {
+  if (clipTest.containsAll(quad)) {
+    const UPF = [0, 1, 0];
+    const a = quad[0], b = quad[1], c = quad[2], d = quad[3];
+    builder.tri([a.x * M, y, a.y * M], [b.x * M, y, b.y * M], [c.x * M, y, c.y * M], UPF, color);
+    builder.tri([a.x * M, y, a.y * M], [c.x * M, y, c.y * M], [d.x * M, y, d.y * M], UPF, color);
+    return;
+  }
+  const ring = quad.map((p) => [p.x, p.y]);
+  ring.push(ring[0]);
+  let pieces;
+  try {
+    pieces = import_polygon_clipping2.default.intersection([ring], clipRing);
+  } catch {
+    return;
+  }
+  const UP = [0, 1, 0];
+  for (const poly of pieces) {
+    if (!poly.length || poly[0].length < 4) continue;
+    const outer = poly[0];
+    const flat = [];
+    const pts = [];
+    for (let i = 0; i < outer.length - 1; i++) {
+      flat.push(outer[i][0], outer[i][1]);
+      pts.push([outer[i][0], outer[i][1]]);
+    }
+    if (pts.length < 3) continue;
+    const tris = (0, import_earcut2.default)(flat, void 0, 2);
+    for (let i = 0; i < tris.length; i += 3) {
+      const a = pts[tris[i]], b = pts[tris[i + 1]], c = pts[tris[i + 2]];
+      builder.tri(
+        [a[0] * M, y, a[1] * M],
+        [b[0] * M, y, b[1] * M],
+        [c[0] * M, y, c[1] * M],
+        UP,
+        color
+      );
+    }
+  }
+}
+function emitDeckBands(builder, rows, focal, landingY, colors, clip) {
+  if (rows.length < 2) return;
+  const nbrs = neighbourhoods(rows);
+  const UP = [0, 1, 0];
+  const clipRing = clip && clip.length >= 3 ? [[...clip.map((p) => [p.x, p.y]), [clip[0].x, clip[0].y]]] : null;
+  const clipTest = clip && clip.length >= 3 ? new ClipTest([[...clip]]) : null;
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    const rib = ribbonOf(rows, i, nbrs, focal);
+    if (!rib) continue;
+    const { pts, nrm, front, back } = rib;
+    const belowY = nbrs[i].belowY ?? landingY;
+    for (let k = 0; k + 1 < pts.length; k++) {
+      const p = pts[k], q = pts[k + 1];
+      const np = nrm[k], nq = nrm[k + 1];
+      if (Math.hypot(q.x - p.x, q.y - p.y) < 1e-6) continue;
+      if (np[0] === 0 && np[1] === 0 || nq[0] === 0 && nq[1] === 0) continue;
+      const pF = [(p.x - np[0] * front) * M, row.y, (p.y - np[1] * front) * M];
+      const qF = [(q.x - nq[0] * front) * M, row.y, (q.y - nq[1] * front) * M];
+      const pB = [(p.x + np[0] * back) * M, row.y, (p.y + np[1] * back) * M];
+      const qB = [(q.x + nq[0] * back) * M, row.y, (q.y + nq[1] * back) * M];
+      if (clipRing && clipTest) {
+        emitClippedQuad(builder, clipRing, clipTest, [
+          { x: p.x - np[0] * front, y: p.y - np[1] * front },
+          { x: q.x - nq[0] * front, y: q.y - nq[1] * front },
+          { x: q.x + nq[0] * back, y: q.y + nq[1] * back },
+          { x: p.x + np[0] * back, y: p.y + np[1] * back }
+        ], row.y, colors.tread);
+      } else {
+        builder.tri(pF, qF, qB, UP, colors.tread);
+        builder.tri(pF, qB, pB, UP, colors.tread);
+      }
+      if (row.y > belowY + MIN_RISER_M) {
+        const pFd = [pF[0], belowY, pF[2]];
+        const qFd = [qF[0], belowY, qF[2]];
+        const rn = [-np[0], 0, -np[1]];
+        builder.tri(pF, qF, qFd, rn, colors.riser);
+        builder.tri(pF, qFd, pFd, rn, colors.riser);
+      }
+    }
+  }
+}
+
+// src/view3d/scene/sceneModel.ts
+function floorUnits(doc) {
+  if (doc.floors?.length) {
+    return doc.floors.map((f) => ({
+      objects: f.objects,
+      focal: f.focalPoint ?? doc.focalPoint,
+      baseHeightM: f.baseHeightM ?? 0
+    }));
+  }
+  return [{ objects: doc.objects, focal: doc.focalPoint, baseHeightM: 0 }];
+}
+var AO = { top: 1, wallBottom: 0.5, bottomCap: 0.4 };
+function tintTop(fill, neutral) {
+  if (!fill) return neutral;
+  const muted = scaleRgb(desaturate(fill, 0.4), 0.62);
+  return mix(neutral, muted, 0.72);
+}
+function resolveSectionFills(doc, seats) {
+  const catColor = /* @__PURE__ */ new Map();
+  for (const c of doc.categories ?? []) catColor.set(c.key, c.color);
+  const counts = /* @__PURE__ */ new Map();
+  for (const s of seats) {
+    if (!s.sectionId) continue;
+    let m = counts.get(s.sectionId);
+    if (!m) {
+      m = /* @__PURE__ */ new Map();
+      counts.set(s.sectionId, m);
+    }
+    m.set(s.categoryKey, (m.get(s.categoryKey) ?? 0) + 1);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [sid, byCat] of counts) {
+    let r = 0, g = 0, b = 0, w = 0;
+    for (const [key, n] of byCat) {
+      const rgb = hexToRgb(catColor.get(key));
+      if (!rgb) continue;
+      r += rgb[0] * n;
+      g += rgb[1] * n;
+      b += rgb[2] * n;
+      w += n;
+    }
+    if (w > 0) out.set(sid, [r / w, g / w, b / w]);
+  }
+  return out;
+}
+function sectionFill(section, byLogical) {
+  return hexToRgb(section.color) ?? byLogical.get(section.logicalSectionId ?? section.id) ?? null;
+}
+function bboxOfRing(ring) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of ring) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+function boxesOverlap(a, b) {
+  return a.minX <= b.maxX && b.minX <= a.maxX && a.minY <= b.maxY && b.minY <= a.maxY;
+}
+function paddedFootprint(section, siblings) {
+  const __tp = performance.now();
+  const padded = outsetRing(section.outline, SEAT_DOT_RADIUS_M * 1.5 * CHART_UNITS_PER_METRE);
+  __t("outsetRing", __tp);
+  const box = bboxOfRing(padded);
+  const others = siblings.filter((o) => o !== section && o.outline && o.outline.length >= 3 && boxesOverlap(box, bboxOfRing(o.outline)));
+  if (!others.length) return [padded];
+  const toRing = (pts) => {
+    const r = pts.map((p) => [p.x, p.y]);
+    r.push(r[0]);
+    return r;
+  };
+  try {
+    const diff = import_polygon_clipping3.default.difference([toRing(padded)], ...others.map((o) => [toRing(o.outline)]));
+    const out = [];
+    for (const poly of diff) {
+      if (!poly.length) continue;
+      const pts = poly[0].map(([x, y]) => ({ x, y }));
+      if (pts.length > 1) {
+        const f = pts[0], l = pts[pts.length - 1];
+        if (Math.abs(f.x - l.x) < 1e-9 && Math.abs(f.y - l.y) < 1e-9) pts.pop();
+      }
+      if (pts.length >= 3) out.push(pts);
+    }
+    return out.length ? out : [padded];
+  } catch {
+    return [padded];
+  }
+}
+function clipFootprints(blocks, allowed) {
+  if (!allowed.length) return blocks;
+  const toRing = (pts) => {
+    const r = pts.map((p) => [p.x, p.y]);
+    r.push(r[0]);
+    return r;
+  };
+  const allowedPolys = allowed.map((a) => [toRing(a)]);
+  const out = [];
+  for (const b of blocks) {
+    let pieces;
+    try {
+      pieces = import_polygon_clipping3.default.intersection([toRing(b.outline)], ...[allowedPolys.flat()]);
+    } catch {
+      out.push(b);
+      continue;
+    }
+    for (const poly of pieces) {
+      if (!poly.length) continue;
+      const pts = poly[0].map(([x, y]) => ({ x, y }));
+      if (pts.length > 1) {
+        const f = pts[0], l = pts[pts.length - 1];
+        if (Math.abs(f.x - l.x) < 1e-9 && Math.abs(f.y - l.y) < 1e-9) pts.pop();
+      }
+      if (pts.length >= 3) out.push({ outline: pts, holes: [], topY: b.topY });
+    }
+  }
+  return out.length ? out : blocks;
+}
+function buildTier(builder, section, unit, fill, surface, claimed, siblings, S) {
+  if (!section.outline || section.outline.length < 3) return;
+  const bottomY = unit.baseHeightM;
+  const colTop = tintTop(fill, S.tierTop);
+  if (!surface) return;
+  const topY = (p) => surface.deckAt(p.x, p.y);
+  const footprint = paddedFootprint(section, siblings);
+  const outline = footprint[0] ?? section.outline;
+  if (surface.rowLevels.length >= 2) {
+    const __tf = performance.now();
+    const blocks = clipFootprints(deckFootprints(surface.rowLevels, unit.focal), footprint);
+    __t("deckFootprints", __tf);
+    const capUp = () => [0, 1, 0];
+    for (const b of blocks) {
+      extrudePrism(
+        builder,
+        b.outline,
+        b.holes,
+        () => b.topY,
+        bottomY,
+        colTop,
+        S.tierWall,
+        AO,
+        void 0,
+        capUp
+      );
+    }
+    if (!blocks.length) {
+      extrudePrism(
+        builder,
+        outline,
+        section.holes,
+        () => surface.landingY,
+        bottomY,
+        colTop,
+        S.tierWall,
+        AO
+      );
+    }
+    const __tb = performance.now();
+    emitDeckBands(builder, surface.rowLevels, unit.focal, surface.landingY, {
+      tread: [colTop[0] * AO.top, colTop[1] * AO.top, colTop[2] * AO.top],
+      // Risers read as the structure they are, a shade below their tread, which
+      // is what makes the stepping legible from a low angle.
+      riser: [colTop[0] * 0.72, colTop[1] * 0.72, colTop[2] * 0.72]
+    }, footprint.length === 1 ? outline : footprint.flat());
+    __t("emitDeckBands", __tb);
+    return;
+  }
+  const maxErr = surface.flat ? Infinity : CAP_MAX_ERROR_M;
+  const topN = (p) => surface.normalAt(p.x, p.y);
+  for (const ring of claimed.subtract(outline)) {
+    extrudePrism(builder, ring, section.holes, topY, bottomY, colTop, S.tierWall, AO, maxErr, topN);
+  }
+}
+var ClaimedArea = class {
+  constructor() {
+    this.rings = [];
+    this.boxes = [];
+  }
+  /** `ring` minus everything claimed so far; then claim what is returned. */
+  subtract(ring) {
+    const closed = ring.map((p) => [p.x, p.y]);
+    if (closed.length < 3) return [];
+    closed.push(closed[0]);
+    const box = bboxOfRing(ring);
+    const overlapping = this.rings.filter((_, i) => boxesOverlap(box, this.boxes[i]));
+    let pieces = [[closed]];
+    if (overlapping.length) {
+      try {
+        const diff = import_polygon_clipping3.default.difference([closed], ...overlapping);
+        pieces = diff.map((poly) => poly.map((r) => r.map(([x, y]) => [x, y])));
+      } catch {
+        pieces = [[closed]];
+      }
+    }
+    this.rings.push([closed]);
+    this.boxes.push(box);
+    const out = [];
+    for (const poly of pieces) {
+      if (!poly.length) continue;
+      const pts = poly[0].map(([x, y]) => ({ x, y }));
+      if (pts.length > 1) {
+        const f = pts[0], l = pts[pts.length - 1];
+        if (Math.abs(f.x - l.x) < 1e-9 && Math.abs(f.y - l.y) < 1e-9) pts.pop();
+      }
+      if (pts.length >= 3) out.push(pts);
+    }
+    return out;
+  }
+};
+var BOOTH_HEIGHT_M = 2.4;
+var ZONE_LABEL_LIFT_M = 6;
+var SECTION_LABEL_LIFT_M = 2.2;
+var ANNOTATION_LIFT_M = 0.1;
+var BOOTH_LABEL_LIFT_M = 0.3;
+var TABLE_HEIGHT_M = 0.75;
+function boothPolygon(booth) {
+  if (booth.points && booth.points.length >= 3) return booth.points;
+  const { center, width, height, rotation } = booth;
+  if (!width || !height) return null;
+  const a = (rotation ?? 0) * Math.PI / 180;
+  const cos = Math.cos(a), sin = Math.sin(a);
+  const hw = width / 2, hh = height / 2;
+  return [[-hw, -hh], [hw, -hh], [hw, hh], [-hw, hh]].map(([lx, ly]) => ({
+    x: center.x + lx * cos - ly * sin,
+    y: center.y + lx * sin + ly * cos
+  }));
+}
+function buildBooth(builder, booth, base, fill, S) {
+  const poly = boothPolygon(booth);
+  if (!poly) return;
+  extrudePrism(
+    builder,
+    poly,
+    void 0,
+    () => base + BOOTH_HEIGHT_M,
+    base,
+    tintTop(fill, S.boothTop),
+    S.boothWall,
+    AO
+  );
+}
+function tablePolygon(table) {
+  if (table.shape === "round") {
+    const r = table.radius;
+    if (!r) return null;
+    return ellipsePolygon(table.center.x, table.center.y, r, r, 24);
+  }
+  const { width, height, rotation, center } = table;
+  if (!width || !height) return null;
+  const a = (rotation ?? 0) * Math.PI / 180;
+  const cos = Math.cos(a), sin = Math.sin(a);
+  const hw = width / 2, hh = height / 2;
+  return [[-hw, -hh], [hw, -hh], [hw, hh], [-hw, hh]].map(([lx, ly]) => ({
+    x: center.x + lx * cos - ly * sin,
+    y: center.y + lx * sin + ly * cos
+  }));
+}
+function buildTable(builder, table, base, fill, S) {
+  const poly = tablePolygon(table);
+  if (!poly) return;
+  extrudePrism(
+    builder,
+    poly,
+    void 0,
+    () => base + TABLE_HEIGHT_M,
+    base,
+    tintTop(fill, S.tableTop),
+    S.tableWall,
+    AO
+  );
+}
+function shapePolygon(shape) {
+  if (shape.kind === "polygon" && shape.points && shape.points.length >= 3) return shape.points;
+  if (shape.kind === "rect" && shape.width && shape.height) {
+    return rectPolygon(shape.x ?? 0, shape.y ?? 0, shape.width, shape.height);
+  }
+  if (shape.kind === "ellipse" && shape.width && shape.height) {
+    const cx = (shape.x ?? 0) + shape.width / 2;
+    const cy = (shape.y ?? 0) + shape.height / 2;
+    return ellipsePolygon(cx, cy, shape.width / 2, shape.height / 2);
+  }
+  return null;
+}
+function buildShape(builder, shape, base, S) {
+  const poly = shapePolygon(shape);
+  if (!poly) return;
+  const isStage = shape.role === "stage";
+  const height = isStage ? base + 1 : base + 0.25;
+  const colTop = isStage ? S.stageTop : S.decorTop;
+  const colWall = isStage ? S.stageWall : S.decorWall;
+  extrudePrism(builder, poly, void 0, () => height, base, colTop, colWall, AO);
+}
+function buildGa(builder, ga, base, fill, S) {
+  if (!ga.points || ga.points.length < 3) return;
+  const colTop = tintTop(fill, S.gaTop);
+  extrudePrism(builder, ga.points, ga.holes, () => base + 0.15, base, colTop, S.gaWall, AO);
+}
+function chartFootprint(units, seats) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  const acc = (x, y) => {
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+  };
+  for (const s of seats) acc(s.x, s.y);
+  for (const u of units) {
+    for (const o of u.objects) {
+      if (o.type === "section") for (const p of o.outline) acc(p.x, p.y);
+      else if (o.type === "shape" && o.points) for (const p of o.points) acc(p.x, p.y);
+      else if (o.type === "gaArea") for (const p of o.points) acc(p.x, p.y);
+      else if (o.type === "booth") {
+        const b = boothPolygon(o);
+        if (b) for (const p of b) acc(p.x, p.y);
+      } else if (o.type === "table") {
+        const t = tablePolygon(o);
+        if (t) for (const p of t) acc(p.x, p.y);
+      }
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    minX = -100;
+    minY = -100;
+    maxX = 100;
+    maxY = 100;
+  }
+  return { minX, minY, maxX, maxY };
+}
+var __PROF = {};
+var __t = (k, t0) => {
+  __PROF[k] = (__PROF[k] ?? 0) + (performance.now() - t0);
+};
+function buildSceneModel(input) {
+  for (const k of Object.keys(__PROF)) delete __PROF[k];
+  const { doc, seats } = input;
+  const theme = resolveTheme3D(doc.theme);
+  const S = theme.structure;
+  const units = floorUnits(doc);
+  const builder = new MeshBuilder();
+  const fp = chartFootprint(units, seats);
+  const padU = Math.max(60, (fp.maxX - fp.minX + fp.maxY - fp.minY) * 0.06);
+  const groundPoly = rectPolygon(fp.minX - padU, fp.minY - padU, fp.maxX - fp.minX + padU * 2, fp.maxY - fp.minY + padU * 2);
+  extrudePrism(builder, groundPoly, void 0, () => 0, -0.4, 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 __t0 = performance.now();
+  const surfaces = buildVenueSurfaces(units, seats);
+  __t("surfaces", __t0);
+  const seatFloor = new Float32Array(seats.length);
+  for (let unitIndex = 0; unitIndex < units.length; unitIndex++) {
+    const unit = units[unitIndex];
+    builder.setFloor(unitIndex);
+    const claimed = new ClaimedArea();
+    const siblings = unit.objects.filter((o) => o.type === "section" && !!o.outline && o.outline.length >= 3);
+    for (const o of unit.objects) {
+      if (o.type === "section") {
+        const t = performance.now();
+        buildTier(builder, o, unit, sectionFill(o, sectionFills), surfaces.bySection.get(o.id), claimed, siblings, S);
+        __t("buildTier", t);
+      } else if (o.type === "shape") buildShape(builder, o, unit.baseHeightM, S);
+      else if (o.type === "gaArea") buildGa(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)), S);
+      else if (o.type === "booth") buildBooth(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)), S);
+      else if (o.type === "table") buildTable(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)), S);
+    }
+  }
+  const focal = doc.focalPoint ?? { x: (fp.minX + fp.maxX) / 2, y: (fp.minY + fp.maxY) / 2 };
+  const __tm = performance.now();
+  const solids = mergeMeshData([builder.build()]);
+  __t("meshBuild+merge", __tm);
+  const __ts = performance.now();
+  const seatData = buildSeatInstances(seats, input.initialState, surfaces, seatFloor);
+  __t("seatInstances", __ts);
+  const zoneDefs = doc.zones ?? [];
+  const zones = [];
+  if (zoneDefs.length) {
+    const sectionZone = /* @__PURE__ */ new Map();
+    for (const unit of units) {
+      for (const o of unit.objects) {
+        if (o.type === "section" && o.zone) sectionZone.set(o.id, o.zone);
+      }
+    }
+    const acc = /* @__PURE__ */ new Map();
+    for (let i = 0; i < seats.length; i++) {
+      const s = seats[i];
+      const owner = surfaces.seatOwner[i];
+      const zid = s.zoneId ?? (owner ? sectionZone.get(owner) : void 0);
+      if (!zid) continue;
+      let a = acc.get(zid);
+      if (!a) {
+        a = { n: 0, minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity, sumY: 0 };
+        acc.set(zid, a);
+      }
+      a.n++;
+      if (s.x < a.minX) a.minX = s.x;
+      if (s.y < a.minY) a.minY = s.y;
+      if (s.x > a.maxX) a.maxX = s.x;
+      if (s.y > a.maxY) a.maxY = s.y;
+      a.sumY += surfaces.seatDeckY(i);
+    }
+    for (const z of zoneDefs) {
+      const a = acc.get(z.id);
+      const sectionIds = [];
+      for (const [secId, zid] of sectionZone) if (zid === z.id) sectionIds.push(secId);
+      if (!a || a.n === 0) {
+        zones.push({
+          id: z.id,
+          label: z.label,
+          color: hexToRgb(z.color),
+          sectionIds,
+          seatCount: 0,
+          center: [0, 0, 0],
+          radius: 0,
+          focalWorld: [(z.focalPoint ?? focal).x * M, 1.5, (z.focalPoint ?? focal).y * M]
+        });
+        continue;
+      }
+      zones.push({
+        id: z.id,
+        label: z.label,
+        color: hexToRgb(z.color),
+        sectionIds,
+        seatCount: a.n,
+        center: [(a.minX + a.maxX) / 2 * M, a.sumY / a.n, (a.minY + a.maxY) / 2 * M],
+        radius: 0.5 * Math.hypot((a.maxX - a.minX) * M, (a.maxY - a.minY) * M) || 1,
+        // A zone may face its own point (`ZoneDef.focalPoint`); the documented
+        // fallback is the floor/chart focal.
+        focalWorld: [(z.focalPoint ?? focal).x * M, 1.5, (z.focalPoint ?? focal).y * M]
+      });
+    }
+  }
+  const labels = [];
+  for (const z of zones) {
+    if (z.seatCount === 0) continue;
+    labels.push({
+      id: `zone:${z.id}`,
+      kind: "zone",
+      text: z.label,
+      anchor: [z.center[0], z.center[1] + ZONE_LABEL_LIFT_M, z.center[2]],
+      color: doc.zones?.find((d) => d.id === z.id)?.color
+    });
+  }
+  {
+    const acc = /* @__PURE__ */ new Map();
+    for (let i = 0; i < seats.length; i++) {
+      const owner = surfaces.seatOwner[i];
+      if (!owner) continue;
+      let a = acc.get(owner);
+      if (!a) {
+        a = { n: 0, x: 0, y: 0, deck: 0 };
+        acc.set(owner, a);
+      }
+      a.n++;
+      a.x += seats[i].x;
+      a.y += seats[i].y;
+      a.deck += surfaces.seatDeckY(i);
+    }
+    for (const unit of units) {
+      for (const o of unit.objects) {
+        if (o.type !== "section") continue;
+        const a = acc.get(o.id);
+        if (!a || a.n === 0) continue;
+        labels.push({
+          id: `section:${o.id}`,
+          kind: "section",
+          // The buyer-facing name wins over the technical one, as it does in 2D.
+          text: o.displayLabel || o.label || o.id,
+          anchor: [a.x / a.n * M, a.deck / a.n + SECTION_LABEL_LIFT_M, a.y / a.n * M]
+        });
+      }
+    }
+  }
+  for (const unit of units) {
+    for (const o of unit.objects) {
+      if (o.type === "text") {
+        if (!o.text) continue;
+        labels.push({
+          id: `text:${o.id}`,
+          kind: "annotation",
+          text: o.text,
+          anchor: [o.position.x * M, unit.baseHeightM + ANNOTATION_LIFT_M, o.position.y * M],
+          color: o.color,
+          rotation: o.rotation
+        });
+      } else if (o.type === "booth") {
+        const poly = boothPolygon(o);
+        if (!poly) continue;
+        const c = centroidOf(poly);
+        if (!c) continue;
+        labels.push({
+          id: `booth:${o.id}`,
+          kind: "booth",
+          text: o.displayLabel || o.label || o.id,
+          anchor: [c.x * M, unit.baseHeightM + BOOTH_HEIGHT_M + BOOTH_LABEL_LIFT_M, c.y * M]
+        });
+      }
+    }
+  }
+  const floors = [];
+  {
+    const sectionFloor = /* @__PURE__ */ new Map();
+    for (let ui = 0; ui < units.length; ui++) {
+      for (const o of units[ui].objects) if (o.type === "section") sectionFloor.set(o.id, ui);
+    }
+    const acc = units.map(() => ({ n: 0, minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity, sumY: 0 }));
+    for (let i = 0; i < seats.length; i++) {
+      const owner = surfaces.seatOwner[i];
+      const ui = owner !== null ? sectionFloor.get(owner) : void 0;
+      if (ui === void 0) continue;
+      const a = acc[ui];
+      const s = seats[i];
+      a.n++;
+      if (s.x < a.minX) a.minX = s.x;
+      if (s.y < a.minY) a.minY = s.y;
+      if (s.x > a.maxX) a.maxX = s.x;
+      if (s.y > a.maxY) a.maxY = s.y;
+      a.sumY += surfaces.seatDeckY(i);
+      seatFloor[i] = ui;
+    }
+    for (let ui = 0; ui < units.length; ui++) {
+      const a = acc[ui];
+      const f = doc.floors?.[ui];
+      floors.push({
+        index: ui,
+        id: f?.id ?? `floor-${ui}`,
+        label: f?.name ?? (units.length > 1 ? `Floor ${ui + 1}` : "Venue"),
+        seatCount: a.n,
+        center: a.n ? [(a.minX + a.maxX) / 2 * M, a.sumY / a.n, (a.minY + a.maxY) / 2 * M] : [0, 0, 0],
+        radius: a.n ? 0.5 * Math.hypot((a.maxX - a.minX) * M, (a.maxY - a.minY) * M) || 1 : 0
+      });
+    }
+  }
+  const cx = (fp.minX + fp.maxX) / 2 * M;
+  const cz = (fp.minY + fp.maxY) / 2 * M;
+  const radius = 0.5 * Math.hypot((fp.maxX - fp.minX) * M, (fp.maxY - fp.minY) * M) || 10;
+  return {
+    solids,
+    seats: seatData,
+    bounds: { center: [cx, radius * 0.08, cz], radius, groundY: 0 },
+    stateColorLUT: themeSeatColorLUT(theme, SEAT_STATES),
+    theme,
+    seatCount: seats.length,
+    // Look-at target ~1.5 m up so a seated camera aims slightly down at the stage.
+    focalWorld: [focal.x * M, 1.5, focal.y * M],
+    zones,
+    labels,
+    floors
+  };
+}
+
+// src/view3d/labelOverlay.ts
+var SEPARATION_X_PX = 88;
+var SEPARATION_Y_PX = 20;
+var KIND_STYLE = {
+  zone: { size: 15, weight: "600", opacity: 0.95 },
+  section: { size: 12, weight: "500", opacity: 0.88 },
+  booth: { size: 11, weight: "500", opacity: 0.85 },
+  annotation: { size: 11, weight: "400", opacity: 0.75 }
+};
+var LabelOverlay = class {
+  constructor(container, opts = {}) {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.labels = [];
+    this.opts = opts;
+    this.root = document.createElement("div");
+    this.root.setAttribute("data-view3d-labels", "");
+    const s = this.root.style;
+    s.position = "absolute";
+    s.inset = "0";
+    s.pointerEvents = "none";
+    s.overflow = "hidden";
+    if (opts.fontFamily) s.fontFamily = opts.fontFamily;
+    container.appendChild(this.root);
+  }
+  setLabels(labels) {
+    this.labels = labels;
+    for (const [id, node] of this.nodes) {
+      if (!labels.some((l) => l.id === id)) {
+        node.remove();
+        this.nodes.delete(id);
+      }
+    }
+  }
+  /**
+   * Reposition every label for the current camera.
+   *
+   * `viewProjection` is column-major, as OGL supplies it.
+   */
+  update(viewProjection, width, height, cameraDistance, venueRadius) {
+    if (!this.labels.length) return;
+    const kinds = visibleLabelKinds(cameraDistance, venueRadius);
+    const candidates = [];
+    for (const label of this.labels) {
+      if (!kinds.has(label.kind)) continue;
+      const screen = projectToScreen(viewProjection, label.anchor, width, height);
+      if (!screen.visible) continue;
+      candidates.push({ label, screen });
+    }
+    const kept = cullOverlapping(candidates, SEPARATION_X_PX, SEPARATION_Y_PX);
+    const keptIds = new Set(kept.map((k) => k.label.id));
+    for (const { label, screen } of kept) {
+      const node = this.nodeFor(label);
+      const st = node.style;
+      st.display = "";
+      st.transform = `translate(-50%, -50%) translate(${screen.x.toFixed(1)}px, ${screen.y.toFixed(1)}px)`;
+    }
+    for (const [id, node] of this.nodes) {
+      if (!keptIds.has(id)) node.style.display = "none";
+    }
+  }
+  nodeFor(label) {
+    let node = this.nodes.get(label.id);
+    if (node) return node;
+    node = document.createElement("div");
+    node.textContent = label.text;
+    node.setAttribute("data-label-kind", label.kind);
+    const style = KIND_STYLE[label.kind];
+    const s = node.style;
+    s.position = "absolute";
+    s.left = "0";
+    s.top = "0";
+    s.whiteSpace = "nowrap";
+    s.fontSize = `${style.size}px`;
+    s.fontWeight = style.weight;
+    s.opacity = String(style.opacity);
+    s.color = label.color ?? this.opts.ink ?? "#e8edf5";
+    s.textShadow = "0 1px 3px rgba(0,0,0,0.85), 0 0 8px rgba(0,0,0,0.55)";
+    s.letterSpacing = label.kind === "zone" ? "0.08em" : "0.02em";
+    if (label.kind === "zone") s.textTransform = "uppercase";
+    s.display = "none";
+    this.root.appendChild(node);
+    this.nodes.set(label.id, node);
+    return node;
+  }
+  dispose() {
+    this.root.remove();
+    this.nodes.clear();
+  }
+};
+
+// src/view3d/scene/build.ts
+var import_ogl4 = require("ogl");
+
+// src/view3d/scene/materials.ts
+var import_ogl3 = require("ogl");
+var SOLID_VERT = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec3 position;
+in vec3 normal;
+in vec3 color;
+in float floorIndex;
+uniform mat4 modelMatrix;
+uniform float uFocusFloor;   // -1 = show every floor
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform mat3 normalMatrix;
+out vec3 vColor;
+out vec3 vNormalWorld;
+out vec3 vNormalView;
+out vec3 vPosView;
+out float vDim;
+void main() {
+  // Per-floor isolation without splitting the merged mesh into a draw call per
+  // floor: a floor that is not the focused one is dimmed, not hidden, so the
+  // buyer keeps the whole venue as context while looking at one level.
+  vDim = (uFocusFloor < -0.5 || abs(floorIndex - uFocusFloor) < 0.5) ? 0.0 : 1.0;
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  vPosView = mv.xyz;
+  vNormalView = normalize(normalMatrix * normal);
+  // World normal drives the key + hemisphere so the lighting stays welded to the
+  // venue as the camera orbits (the scene has no non-uniform scale, so mat3 of
+  // the model matrix is the correct normal transform).
+  vNormalWorld = normalize(mat3(modelMatrix) * normal);
+  vColor = color;
+  gl_Position = projectionMatrix * mv;
+}`
+);
+var SOLID_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec3 vColor;
+in vec3 vNormalWorld;
+in vec3 vNormalView;
+in vec3 vPosView;
+in float vDim;
+uniform vec3 uKeyDir;                           // WORLD space, unit, points at the light
+out vec4 fragColor;
+void main() {
+  vec3 N = normalize(vNormalWorld);
+  vec3 V = normalize(-vPosView);
+  float hemi = 0.5 + 0.5 * N.y;                 // sky/ground gradient about WORLD up
+  float key = max(dot(N, uKeyDir), 0.0);        // fixed key \u2014 does not orbit with you
+  // Low opposite fill so faces turned away from the key keep their form instead
+  // of crushing to a single flat value.
+  vec3 fillDir = normalize(vec3(-uKeyDir.x, 0.25, -uKeyDir.z));
+  float fill = max(dot(N, fillDir), 0.0);
+  vec3 base = vColor * (0.52 + 0.34 * hemi) + vColor * key * 0.34 + vColor * fill * 0.10;
+  float fres = pow(1.0 - max(dot(normalize(vNormalView), V), 0.0), 3.0);
+  base += vec3(0.26, 0.31, 0.38) * fres * 0.35; // cool rim, restrained (view-dependent by design)
+  // Unfocused floors fall back toward the background rather than vanishing.
+  base = mix(base, base * 0.45, vDim);
+  fragColor = vec4(base, 1.0);
+}`
+);
+var SEAT_VERT = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 position;      // quad corner in [-1,1]
+in vec3 iOffset;       // per-instance world position
+in vec3 iColor;        // per-instance state colour (resolved CPU-side)
+in float iMaxRadius;   // per-instance world-radius ceiling (seat pitch derived)
+in vec3 iRing;         // accommodation ring colour; (0,0,0) = not accessible
+in float iFloor;       // owning floor index
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform float uSeatRadius;
+uniform float uSeatScale;
+uniform float uMinPixels;
+uniform float uPixelToWorld;   // (2*tan(fovY/2)) / viewportHeightPx
+uniform float uFocusFloor;     // -1 = show every floor
+out vec2 vUv;
+out vec3 vColor;
+out float vBudget;     // 1 = dot holds its minimum pixel size, <1 = it cannot
+out vec3 vRing;
+out float vDim;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(iOffset, 1.0);
+  float depth = max(-mv.z, 0.001);
+  float minR = uMinPixels * depth * uPixelToWorld;      // screen-space floor
+  // Grow to hold the pixel floor, but never past this seat's own pitch ceiling:
+  // unbounded growth is what merges neighbouring rows into one mass at range.
+  float r = min(max(uSeatRadius * uSeatScale, minR), iMaxRadius);
+  // How much of the requested pixel floor the dot could actually afford. Below 1
+  // it is losing legibility to distance, and the fragment stage dissolves it
+  // toward the tier top rather than letting a sub-pixel dot alias and shimmer.
+  vBudget = minR > 0.0 ? clamp(r / minR, 0.0, 1.0) : 1.0;
+  mv.xy += position * r;                                 // camera-facing billboard
+  // Seat the dot ON the deck instead of centring it in the deck. iOffset is the
+  // exact surface point, so half the billboard would otherwise sit below the cap
+  // and be clipped by it \u2014 and because uMinPixels grows r with distance, no
+  // constant world-space lift can prevent that at every range. Offsetting by r
+  // along the screen projection of WORLD up is self-correcting: it is full at a
+  // grazing view (where slicing happens) and vanishes looking straight down
+  // (where the dot must stay centred on its seat).
+  mv.xy += normalize(vec3(modelViewMatrix * vec4(0.0, 1.0, 0.0, 0.0))).xy * r;
+  vUv = position;
+  vColor = iColor;
+  vRing = iRing;
+  vDim = (uFocusFloor < -0.5 || abs(iFloor - uFocusFloor) < 0.5) ? 0.0 : 1.0;
+  gl_Position = projectionMatrix * mv;
+}`
+);
+var SEAT_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 vUv;
+in vec3 vColor;
+in float vBudget;
+in vec3 vRing;
+in float vDim;
+uniform float uSeatFade;      // fade toward tier colour with distance (LOD)
+uniform vec3 uFadeColor;
+out vec4 fragColor;
+void main() {
+  float d = length(vUv);
+  if (d > 1.0) discard;
+  float alpha = smoothstep(1.0, 0.72, d);
+  float shade = 0.80 + 0.28 * (0.5 - vUv.y * 0.5);       // subtle top-lit
+  vec3 c = vColor * shade;
+  c = mix(c, uFadeColor, uSeatFade);
+  // Accommodation ring \u2014 the 3D echo of the coloured ring 2D draws around every
+  // accessible seat. Painted INSIDE the dot's own radius rather than outside it,
+  // so an accessible seat still respects the row-pitch ceiling and cannot grow
+  // into its neighbour just for carrying a ring.
+  float ringMask = step(0.001, dot(vRing, vRing));
+  float ring = smoothstep(0.58, 0.70, d) * (1.0 - smoothstep(0.90, 1.0, d));
+  c = mix(c, vRing, ring * ringMask * 0.95);
+  // A dot that can no longer afford its pixel floor dissolves instead of
+  // aliasing; the tier cap underneath already carries the section's category
+  // tint, so the block reads as coloured seating rather than empty concrete.
+  alpha *= smoothstep(0.35, 1.0, vBudget);
+  // Seats on an unfocused floor recede with their structure.
+  c = mix(c, uFadeColor, vDim * 0.75);
+  alpha *= mix(1.0, 0.30, vDim);
+  fragColor = vec4(c, alpha);
+}`
+);
+var BG_VERT = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 position;
+out vec2 vUv;
+void main() {
+  vUv = position * 0.5 + 0.5;
+  gl_Position = vec4(position, 0.999, 1.0);
+}`
+);
+var BG_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 vUv;
+uniform vec3 uTop;
+uniform vec3 uBottom;
+out vec4 fragColor;
+void main() {
+  vec3 col = mix(uBottom, uTop, vUv.y);
+  vec2 c = vUv - 0.5;
+  float vig = 1.0 - dot(c, c) * 0.85;                    // soft vignette
+  fragColor = vec4(col * vig, 1.0);
+}`
+);
+var SEAT_PICK_VERT = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 position;
+in vec3 iOffset;
+in float iMaxRadius;
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform float uSeatRadius;
+uniform float uSeatScale;
+uniform float uMinPixels;
+uniform float uPixelToWorld;
+out vec2 vUv;
+flat out vec3 vPick;
+void main() {
+  int id = gl_InstanceID + 1;                 // 0 reserved for no-hit
+  vPick = vec3(float(id & 255), float((id >> 8) & 255), float((id >> 16) & 255)) / 255.0;
+  vec4 mv = modelViewMatrix * vec4(iOffset, 1.0);
+  float depth = max(-mv.z, 0.001);
+  float minR = uMinPixels * depth * uPixelToWorld;
+  float r = min(max(uSeatRadius * uSeatScale, minR), iMaxRadius);
+  mv.xy += position * r;
+  // Must match SEAT_VERT exactly, or the hit mask drifts off the drawn dot.
+  mv.xy += normalize(vec3(modelViewMatrix * vec4(0.0, 1.0, 0.0, 0.0))).xy * r;
+  vUv = position;
+  gl_Position = projectionMatrix * mv;
+}`
+);
+var SEAT_PICK_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 vUv;
+flat in vec3 vPick;
+out vec4 fragColor;
+void main() {
+  if (length(vUv) > 1.0) discard;             // round hit-mask matches the dot
+  fragColor = vec4(vPick, 1.0);
+}`
+);
+var PICK_DEPTH_VERT = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec3 position;
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+void main() {
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}`
+);
+var PICK_DEPTH_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+out vec4 fragColor;
+void main() { fragColor = vec4(0.0, 0.0, 0.0, 1.0); }`
+);
+function createSeatPickProgram(gl) {
+  return new import_ogl3.Program(gl, {
+    vertex: SEAT_PICK_VERT,
+    fragment: SEAT_PICK_FRAG,
+    transparent: false,
+    depthTest: true,
+    depthWrite: true,
+    cullFace: false,
+    uniforms: {
+      uSeatRadius: { value: SEAT_DOT_RADIUS_M },
+      uSeatScale: { value: 1 },
+      uMinPixels: { value: 2.5 },
+      uPixelToWorld: { value: 2e-3 }
+    }
+  });
+}
+function createPickDepthProgram(gl) {
+  return new import_ogl3.Program(gl, {
+    vertex: PICK_DEPTH_VERT,
+    fragment: PICK_DEPTH_FRAG,
+    transparent: false,
+    depthTest: true,
+    depthWrite: true,
+    cullFace: false
+  });
+}
+function createSolidProgram(gl) {
+  return new import_ogl3.Program(gl, {
+    // No backface culling: free-hand section polygons are stored in raw click
+    // order (either winding), so a culled solid would render see-through. The
+    // shader lights both faces and closed opaque prisms + depth test keep
+    // overdraw negligible; extrudePrism also normalises winding as a belt.
+    vertex: SOLID_VERT,
+    fragment: SOLID_FRAG,
+    cullFace: false,
+    depthTest: true,
+    depthWrite: true,
+    uniforms: {
+      // High and off-axis, in world space: reads as a house rig rather than a
+      // headlamp welded to the camera.
+      uKeyDir: { value: new Float32Array([0.38, 0.86, 0.34]) },
+      uFocusFloor: { value: -1 }
+    }
+  });
+}
+function createSeatProgram(gl) {
+  return new import_ogl3.Program(gl, {
+    vertex: SEAT_VERT,
+    fragment: SEAT_FRAG,
+    transparent: true,
+    depthTest: true,
+    depthWrite: false,
+    cullFace: false,
+    uniforms: {
+      uSeatRadius: { value: SEAT_DOT_RADIUS_M },
+      uSeatScale: { value: 1 },
+      uMinPixels: { value: 2.5 },
+      uPixelToWorld: { value: 2e-3 },
+      uSeatFade: { value: 0 },
+      uFocusFloor: { value: -1 },
+      uFadeColor: { value: new Float32Array([0.32, 0.37, 0.43]) }
+    }
+  });
+}
+function createBackgroundProgram(gl, top, bottom) {
+  return new import_ogl3.Program(gl, {
+    vertex: BG_VERT,
+    fragment: BG_FRAG,
+    depthTest: false,
+    depthWrite: false,
+    cullFace: false,
+    uniforms: {
+      uTop: { value: new Float32Array(top) },
+      uBottom: { value: new Float32Array(bottom) }
+    }
+  });
+}
+
+// src/view3d/scene/build.ts
+function writeSeatColors(iColor, iState, start, count, states) {
+  for (let i = start; i < start + count; i++) {
+    const c = states[iState[i]] ?? states[0];
+    iColor[i * 3] = c[0];
+    iColor[i * 3 + 1] = c[1];
+    iColor[i * 3 + 2] = c[2];
+  }
+}
+var SEAT_QUAD = new Float32Array([-1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1]);
+var BG_TRI = new Float32Array([-1, -1, 3, -1, -1, 3]);
+function buildGpuScene(gl, model) {
+  const main = new import_ogl4.Transform();
+  const background = new import_ogl4.Transform();
+  const bgGeo = new import_ogl4.Geometry(gl, { position: { size: 2, data: BG_TRI } });
+  const bgProg = createBackgroundProgram(gl, model.theme.background.top, model.theme.background.bottom);
+  const bgMesh = new import_ogl4.Mesh(gl, { geometry: bgGeo, program: bgProg });
+  bgMesh.frustumCulled = false;
+  bgMesh.setParent(background);
+  const solidGeo = new import_ogl4.Geometry(gl, {
+    position: { size: 3, data: model.solids.position },
+    normal: { size: 3, data: model.solids.normal },
+    color: { size: 3, data: model.solids.color },
+    floorIndex: { size: 1, data: model.solids.floor }
+  });
+  const solidProg = createSolidProgram(gl);
+  const solidMesh = new import_ogl4.Mesh(gl, { geometry: solidGeo, program: solidProg });
+  solidMesh.frustumCulled = false;
+  solidMesh.setParent(main);
+  const seatProg = createSeatProgram(gl);
+  const iColor = new Float32Array(model.seats.count * 3);
+  const stateColors = SEAT_STATES.map((st) => model.theme.seatStates[st]);
+  writeSeatColors(iColor, model.seats.iState, 0, model.seats.count, stateColors);
+  const seatGeo = new import_ogl4.Geometry(gl, {
+    position: { size: 2, data: SEAT_QUAD },
+    iOffset: { size: 3, data: model.seats.iPosition, instanced: 1 },
+    iColor: { size: 3, data: iColor, instanced: 1 },
+    // Per-seat world-radius ceiling: what stops distant rows merging into one
+    // mass when the shader grows a dot to hold its minimum pixel size.
+    iMaxRadius: { size: 1, data: model.seats.iMaxRadius, instanced: 1 },
+    // Accommodation ring colour; (0,0,0) means the seat carries no access type.
+    iRing: { size: 3, data: model.seats.iRing, instanced: 1 },
+    iFloor: { size: 1, data: model.seats.iFloor, instanced: 1 }
+  });
+  const seatMesh = new import_ogl4.Mesh(gl, { geometry: seatGeo, program: seatProg });
+  seatMesh.frustumCulled = false;
+  if (model.seats.count > 0) seatMesh.setParent(main);
+  const colorAttr = seatGeo.attributes.iColor;
+  return {
+    main,
+    background,
+    seatProgram: seatProg,
+    solidProgram: solidProg,
+    seatGeometry: seatGeo,
+    solidGeometry: solidGeo,
+    drawCalls: 3,
+    uploadSeatStateRuns(runs) {
+      if (!runs.length) return;
+      for (const run of runs) writeSeatColors(iColor, model.seats.iState, run.start, run.length, stateColors);
+      const buffer = colorAttr.buffer;
+      if (!buffer) {
+        colorAttr.needsUpdate = true;
+        return;
+      }
+      gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+      for (const run of runs) {
+        const sub2 = iColor.subarray(run.start * 3, (run.start + run.length) * 3);
+        gl.bufferSubData(gl.ARRAY_BUFFER, run.start * 3 * Float32Array.BYTES_PER_ELEMENT, sub2);
+      }
+    },
+    dispose() {
+      bgGeo.remove();
+      bgProg.remove();
+      solidGeo.remove();
+      solidProg.remove();
+      seatGeo.remove();
+      seatProg.remove();
+    }
+  };
+}
+
+// src/view3d/pick/pickPipeline.ts
+var import_ogl5 = require("ogl");
+
+// src/view3d/pick/encode.ts
+function decodePickRGB(r, g, b) {
+  const id = r + (g << 8) + (b << 16);
+  return id === 0 ? -1 : id - 1;
+}
+function pickNearestFromBuffer(pixels, boxW, boxH, centerI, centerJ, maxIndex) {
+  let best = -1;
+  let bestDist = Infinity;
+  for (let j = 0; j < boxH; j++) {
+    for (let i = 0; i < boxW; i++) {
+      const o = (j * boxW + i) * 4;
+      const idx = decodePickRGB(pixels[o], pixels[o + 1], pixels[o + 2]);
+      if (idx < 0 || idx >= maxIndex) continue;
+      const di = i - centerI;
+      const dj = j - centerJ;
+      const d = di * di + dj * dj;
+      if (d < bestDist) {
+        bestDist = d;
+        best = idx;
+      }
+    }
+  }
+  return best;
+}
+function pickPixelCoords(clientX, clientY, rect, dpr, bufferWidth, bufferHeight) {
+  const cssX = clientX - rect.left;
+  const cssY = clientY - rect.top;
+  const x = Math.round(cssX * dpr);
+  const y = Math.round((rect.height - cssY) * dpr);
+  return {
+    x: Math.max(0, Math.min(bufferWidth - 1, x)),
+    y: Math.max(0, Math.min(bufferHeight - 1, y))
+  };
+}
+
+// src/view3d/pick/pickPipeline.ts
+var SYNC_KEYS = ["uSeatRadius", "uSeatScale", "uMinPixels", "uPixelToWorld"];
+var PickPipeline = class {
+  constructor(renderer, seatGeo, solidGeo, seatCount) {
+    this.seatScene = new import_ogl5.Transform();
+    this.solidScene = new import_ogl5.Transform();
+    this.target = null;
+    /** Display clear colour to restore after the pick pass (theme-dependent). */
+    this.restoreClear = [0, 0, 0];
+    this.renderer = renderer;
+    this.gl = renderer.gl;
+    this.maxIndex = seatCount;
+    this.seatProg = createSeatPickProgram(this.gl);
+    this.depthProg = createPickDepthProgram(this.gl);
+    const seatMesh = new import_ogl5.Mesh(this.gl, { geometry: seatGeo, program: this.seatProg });
+    seatMesh.frustumCulled = false;
+    seatMesh.setParent(this.seatScene);
+    const solidMesh = new import_ogl5.Mesh(this.gl, { geometry: solidGeo, program: this.depthProg });
+    solidMesh.frustumCulled = false;
+    solidMesh.setParent(this.solidScene);
+  }
+  /** Follow the theme's background when the scene is (re)built. */
+  setRestoreClear(rgb) {
+    this.restoreClear = [rgb[0], rgb[1], rgb[2]];
+  }
+  /** Match the display seat sizing so the pick mask lines up with the dots. */
+  syncFromSeatProgram(seatProgram) {
+    for (const k of SYNC_KEYS) this.seatProg.uniforms[k].value = seatProgram.uniforms[k].value;
+  }
+  ensureTarget() {
+    const w = this.gl.drawingBufferWidth;
+    const h = this.gl.drawingBufferHeight;
+    if (this.target && (this.target.width !== w || this.target.height !== h)) {
+      this.destroyTarget();
+    }
+    if (!this.target) {
+      this.target = new import_ogl5.RenderTarget(this.gl, { width: w, height: h, depth: true });
+    }
+    return this.target;
+  }
+  destroyTarget() {
+    if (!this.target) return;
+    const gl = this.gl;
+    if (this.target.buffer) gl.deleteFramebuffer(this.target.buffer);
+    for (const t of this.target.textures ?? []) if (t.texture) gl.deleteTexture(t.texture);
+    if (this.target.depthBuffer) gl.deleteRenderbuffer(this.target.depthBuffer);
+    this.target = null;
+  }
+  /**
+   * Read back the seat instance index NEAREST framebuffer pixel (px, py), or -1.
+   * `radius` is the tap tolerance in buffer px: a box of side (2·radius+1) is
+   * rendered + read so a tap that lands between the ~2px overview dots still
+   * finds the closest seat. px/py/radius are bottom-left-origin buffer pixels.
+   */
+  pick(camera, px, py, radius) {
+    const gl = this.gl;
+    const target = this.ensureTarget();
+    const bw = gl.drawingBufferWidth;
+    const bh = gl.drawingBufferHeight;
+    const x0 = Math.max(0, px - radius);
+    const y0 = Math.max(0, py - radius);
+    const boxW = Math.max(1, Math.min(bw, px + radius + 1) - x0);
+    const boxH = Math.max(1, Math.min(bh, py + radius + 1) - y0);
+    gl.enable(gl.SCISSOR_TEST);
+    gl.scissor(x0, y0, boxW, boxH);
+    const [br, bg, bb] = this.restoreClear;
+    gl.clearColor(0, 0, 0, 1);
+    this.renderer.render({ scene: this.solidScene, camera, target, clear: true });
+    this.renderer.render({ scene: this.seatScene, camera, target, clear: false });
+    gl.clearColor(br, bg, bb, 1);
+    gl.disable(gl.SCISSOR_TEST);
+    const buf = new Uint8Array(boxW * boxH * 4);
+    this.renderer.bindFramebuffer(target);
+    gl.readPixels(x0, y0, boxW, boxH, gl.RGBA, gl.UNSIGNED_BYTE, buf);
+    this.renderer.bindFramebuffer();
+    return pickNearestFromBuffer(buf, boxW, boxH, px - x0, py - y0, this.maxIndex);
+  }
+  dispose() {
+    this.destroyTarget();
+    this.seatProg.remove();
+    this.depthProg.remove();
+  }
+};
+
+// src/view3d/pick/selection.ts
+function mergeAvailabilityIntoSelection(selection, updates) {
+  const passthrough = [];
+  for (const u of updates) {
+    if (selection.has(u.seatId)) selection.set(u.seatId, seatStateIndex(u.state));
+    else passthrough.push(u);
+  }
+  return passthrough;
+}
+function diffSelection(prev, desiredIds, baseStateIndex) {
+  const desired = /* @__PURE__ */ new Set();
+  for (const id of desiredIds) {
+    if (prev.has(id) || baseStateIndex(id) !== void 0) desired.add(id);
+  }
+  const next = new Map(prev);
+  const updates = [];
+  for (const [id, base] of prev) {
+    if (!desired.has(id)) {
+      updates.push({ seatId: id, state: SEAT_STATES[base] ?? "available" });
+      next.delete(id);
+    }
+  }
+  for (const id of desired) {
+    if (next.has(id)) continue;
+    const base = baseStateIndex(id);
+    if (base === void 0) continue;
+    next.set(id, base);
+    updates.push({ seatId: id, state: "selected" });
+  }
+  return { updates, next };
+}
+
+// src/view3d/camera/cinematic.ts
+var import_ogl6 = require("ogl");
+
+// src/view3d/camera/cinematicMath.ts
+var FLIGHT_DURATION_MS = 2500;
+var FOV_START = 35;
+var FOV_END = 28;
+var ORIENTATION_LEAD = 0.15;
+var BACK_M = 2.5;
+var ABOVE_EYE_M = 1.5;
+function sub(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function add(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function scale(a, k) {
+  return [a[0] * k, a[1] * k, a[2] * k];
+}
+function norm(a) {
+  const l = Math.hypot(a[0], a[1], a[2]);
+  return l > 1e-6 ? [a[0] / l, a[1] / l, a[2] / l] : [0, 0, 0];
+}
+function smootherstep(t) {
+  const x = Math.max(0, Math.min(1, t));
+  return x * x * x * (x * (x * 6 - 15) + 10);
+}
+function orientationLeadT(posT, lead) {
+  return Math.max(0, Math.min(1, posT + lead));
+}
+function catmullRom(points, u) {
+  const n = points.length;
+  if (n === 0) return [0, 0, 0];
+  if (n === 1) return [...points[0]];
+  const cu = Math.max(0, Math.min(1, u));
+  const segCount = n - 1;
+  let seg = Math.floor(cu * segCount);
+  if (seg >= segCount) seg = segCount - 1;
+  const t = cu * segCount - seg;
+  const p0 = points[Math.max(0, seg - 1)];
+  const p1 = points[seg];
+  const p2 = points[seg + 1];
+  const p3 = points[Math.min(n - 1, seg + 2)];
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const out = [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    out[i] = 0.5 * (2 * p1[i] + (-p0[i] + p2[i]) * t + (2 * p0[i] - 5 * p1[i] + 4 * p2[i] - p3[i]) * t2 + (-p0[i] + 3 * p1[i] - 3 * p2[i] + p3[i]) * t3);
+  }
+  return out;
+}
+function buildWaypoints(start, seatEye, focal, center, radius) {
+  let away = norm(sub(seatEye, focal));
+  if (away[0] === 0 && away[1] === 0 && away[2] === 0) away = [0, 0, 1];
+  const finalPos = add(add(seatEye, scale(away, BACK_M)), [0, ABOVE_EYE_M, 0]);
+  const horiz = [seatEye[0] - center[0], 0, seatEye[2] - center[2]];
+  let hn = norm(horiz);
+  if (hn[0] === 0 && hn[2] === 0) hn = [away[0], 0, away[2]];
+  const r = Math.max(1, radius);
+  const arc = [
+    center[0] + hn[0] * r * 1.3,
+    center[1] + r * 0.75,
+    center[2] + hn[2] * r * 1.3
+  ];
+  return { waypoints: [start, arc, finalPos], finalPos };
+}
+function sampleFlight(waypoints, u, fovStart = FOV_START, fovEnd = FOV_END) {
+  const eased = smootherstep(u);
+  const pos = catmullRom(waypoints, eased);
+  const fovT = smootherstep(Math.max(0, Math.min(1, (u - 0.66) / 0.34)));
+  return { pos, fov: fovStart + (fovEnd - fovStart) * fovT, eased };
+}
+
+// src/view3d/camera/cinematic.ts
+function lookAtQuat(camera, from, to) {
+  const savedPos = camera.position.clone();
+  const savedQuat = new import_ogl6.Quat().copy(camera.quaternion);
+  camera.position.set(from[0], from[1], from[2]);
+  camera.lookAt(new import_ogl6.Vec3(to[0], to[1], to[2]));
+  const q = new import_ogl6.Quat().copy(camera.quaternion);
+  camera.position.copy(savedPos);
+  camera.quaternion.copy(savedQuat);
+  return q;
+}
+var Cinematic = class {
+  constructor(camera) {
+    this.active = false;
+    this.waypoints = [];
+    this.startQuat = new import_ogl6.Quat();
+    this.endQuat = new import_ogl6.Quat();
+    this.outQuat = new import_ogl6.Quat();
+    this.startTime = 0;
+    this.duration = FLIGHT_DURATION_MS;
+    this.resolveFn = null;
+    this.camera = camera;
+  }
+  /** Begin (or retarget) a flight. Resolves when it lands or is cancelled. */
+  start(waypoints, startQuat, endQuat, duration = FLIGHT_DURATION_MS) {
+    this.settle();
+    this.waypoints = waypoints;
+    this.startQuat.copy(startQuat);
+    this.endQuat.copy(endQuat);
+    this.duration = duration;
+    this.startTime = performance.now();
+    this.active = true;
+    return new Promise((res) => {
+      this.resolveFn = res;
+    });
+  }
+  /** Advance the flight, mutating the camera. Returns true while still flying. */
+  update(now2) {
+    if (!this.active) return false;
+    const u = Math.min(1, (now2 - this.startTime) / this.duration);
+    const { pos, fov, eased } = sampleFlight(this.waypoints, u);
+    this.camera.position.set(pos[0], pos[1], pos[2]);
+    this.outQuat.copy(this.startQuat).slerp(this.endQuat, orientationLeadT(eased, ORIENTATION_LEAD));
+    this.camera.quaternion.copy(this.outQuat);
+    this.camera.fov = fov;
+    this.camera.updateProjectionMatrix();
+    if (u >= 1) {
+      this.settle();
+      return false;
+    }
+    return true;
+  }
+  /** Stop where we are (no snap) — the camera keeps its current pose. */
+  cancel() {
+    this.settle();
+  }
+  settle() {
+    this.active = false;
+    const r = this.resolveFn;
+    this.resolveFn = null;
+    if (r) r();
+  }
+};
+
+// src/view3d/crossfade/panorama.ts
+var VFOV_DEG = 70;
+var MAX_PITCH_DEG = 35;
+function bearingToOffsetPx(bearingDeg, viewportW, bgW) {
+  const col = (0.5 + bearingDeg / 360) * bgW;
+  return viewportW / 2 - col;
+}
+function windowedBgHeight(viewportH, vfovDeg = VFOV_DEG) {
+  return viewportH * (180 / vfovDeg);
+}
+function horizonOffsetPy(viewportH, bgH, pitchPx) {
+  return (viewportH - bgH) / 2 + clampPitchPx(pitchPx, bgH);
+}
+function clampPitchPx(pitchPx, bgH) {
+  const limit = MAX_PITCH_DEG / 180 * bgH;
+  return Math.max(-limit, Math.min(limit, pitchPx));
+}
+function mountPanorama(container, view, opts = {}) {
+  const fadeMs = opts.fadeMs ?? 400;
+  const bearing = view.initialBearingDeg ?? 0;
+  const root = document.createElement("div");
+  root.setAttribute("role", "dialog");
+  root.setAttribute("aria-label", opts.seatLabel ? `View from ${opts.seatLabel}` : "View from seat");
+  Object.assign(root.style, {
+    position: "absolute",
+    inset: "0",
+    zIndex: "10",
+    opacity: "0",
+    transition: `opacity ${fadeMs}ms ease`,
+    background: "#05070c",
+    overflow: "hidden",
+    touchAction: "none"
+  });
+  const pano = document.createElement("div");
+  Object.assign(pano.style, {
+    position: "absolute",
+    inset: "0",
+    backgroundImage: `url("${view.url}")`,
+    backgroundRepeat: "repeat-x",
+    cursor: "grab"
+  });
+  root.appendChild(pano);
+  const closeBtn = document.createElement("button");
+  closeBtn.type = "button";
+  closeBtn.setAttribute("aria-label", "Close");
+  closeBtn.textContent = "\u2715";
+  Object.assign(closeBtn.style, {
+    position: "absolute",
+    top: "12px",
+    right: "12px",
+    zIndex: "2",
+    width: "34px",
+    height: "34px",
+    borderRadius: "999px",
+    cursor: "pointer",
+    border: "1px solid rgba(255,255,255,0.25)",
+    background: "rgba(8,12,18,0.6)",
+    color: "#e6edf3",
+    fontSize: "15px",
+    lineHeight: "1"
+  });
+  root.appendChild(closeBtn);
+  const hint = document.createElement("div");
+  hint.textContent = "Drag to look around \xB7 Esc to close";
+  Object.assign(hint.style, {
+    position: "absolute",
+    bottom: "12px",
+    left: "0",
+    right: "0",
+    textAlign: "center",
+    color: "rgba(230,237,243,0.7)",
+    font: "12px ui-sans-serif, system-ui, sans-serif",
+    pointerEvents: "none"
+  });
+  root.appendChild(hint);
+  container.appendChild(root);
+  let bgW = 0;
+  let bgH = 0;
+  let posX = 0;
+  let pitchPx = 0;
+  const layout = () => {
+    const vh = root.clientHeight || 1;
+    const vw = root.clientWidth || 1;
+    const natW = img.naturalWidth || vw * 2;
+    const natH = img.naturalHeight || vh;
+    bgH = windowedBgHeight(vh);
+    bgW = bgH * (natW / natH);
+    pano.style.backgroundSize = `${bgW}px ${bgH}px`;
+    if (!posInitialised) {
+      posX = bearingToOffsetPx(bearing, vw, bgW);
+      posInitialised = true;
+    }
+    pitchPx = clampPitchPx(pitchPx, bgH);
+    pano.style.backgroundPosition = `${posX}px ${horizonOffsetPy(vh, bgH, pitchPx)}px`;
+  };
+  let posInitialised = false;
+  const applyPos = () => {
+    const vh = root.clientHeight || 1;
+    pitchPx = clampPitchPx(pitchPx, bgH);
+    pano.style.backgroundPosition = `${posX}px ${horizonOffsetPy(vh, bgH, pitchPx)}px`;
+  };
+  const img = new Image();
+  img.onload = layout;
+  img.src = view.url;
+  requestAnimationFrame(layout);
+  let dragging = false;
+  let lastX = 0;
+  let lastY = 0;
+  const onDown = (e) => {
+    dragging = true;
+    lastX = e.clientX;
+    lastY = e.clientY;
+    pano.style.cursor = "grabbing";
+    try {
+      pano.setPointerCapture?.(e.pointerId);
+    } catch {
+    }
+  };
+  const onMove = (e) => {
+    if (!dragging) return;
+    posX += e.clientX - lastX;
+    pitchPx += e.clientY - lastY;
+    lastX = e.clientX;
+    lastY = e.clientY;
+    applyPos();
+  };
+  const onUp = (e) => {
+    dragging = false;
+    pano.style.cursor = "grab";
+    try {
+      pano.releasePointerCapture?.(e.pointerId);
+    } catch {
+    }
+  };
+  pano.addEventListener("pointerdown", onDown);
+  pano.addEventListener("pointermove", onMove);
+  pano.addEventListener("pointerup", onUp);
+  pano.addEventListener("pointercancel", onUp);
+  let closed = false;
+  let disposed = false;
+  let fadeTimer = 0;
+  const removeListeners = () => {
+    pano.removeEventListener("pointerdown", onDown);
+    pano.removeEventListener("pointermove", onMove);
+    pano.removeEventListener("pointerup", onUp);
+    pano.removeEventListener("pointercancel", onUp);
+    window.removeEventListener("keydown", onKey);
+  };
+  const teardown = () => {
+    if (fadeTimer) {
+      window.clearTimeout(fadeTimer);
+      fadeTimer = 0;
+    }
+    removeListeners();
+    if (root.parentNode) root.parentNode.removeChild(root);
+  };
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    root.style.opacity = "0";
+    const done = () => {
+      fadeTimer = 0;
+      if (disposed) return;
+      teardown();
+      opts.onClose?.();
+    };
+    fadeTimer = window.setTimeout(done, fadeMs);
+  };
+  const onKey = (e) => {
+    if (e.key === "Escape") {
+      e.stopPropagation();
+      close();
+    }
+  };
+  window.addEventListener("keydown", onKey);
+  closeBtn.addEventListener("click", close);
+  requestAnimationFrame(() => {
+    root.style.opacity = "1";
+  });
+  return {
+    close,
+    dispose() {
+      closed = true;
+      disposed = true;
+      teardown();
+    }
+  };
+}
+
+// src/view3d/analytics.ts
+var now = () => typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+var Analytics3D = class {
+  constructor(cb) {
+    this.orbitLatched = false;
+    this.panoramaOpenedAt = 0;
+    this.cb = cb;
+  }
+  /** The single guarded emit point — analytics must never throw into the loop. */
+  emit(event, props) {
+    if (!this.cb) return;
+    try {
+      this.cb(event, props);
+    } catch {
+    }
+  }
+  opened(seats, hasHeights) {
+    this.emit("3d_opened", { seats, hasHeights });
+  }
+  /** First user-driven orbit/dolly per mount only (the intro ease is not user
+   * input, so callers must gate this on real pointer/wheel gestures). */
+  orbitEngaged() {
+    if (this.orbitLatched) return;
+    this.orbitLatched = true;
+    this.emit("3d_orbit_engaged");
+  }
+  seatPicked(seatId, sectionId) {
+    this.emit("3d_seat_picked", { seatId, sectionId });
+  }
+  cinematicPlayed(durationMs) {
+    this.emit("3d_cinematic_played", { durationMs, reducedMotion: false });
+  }
+  cinematicSkipped() {
+    this.emit("3d_cinematic_skipped", { reducedMotion: true });
+  }
+  cinematicCancelled() {
+    this.emit("3d_cinematic_cancelled");
+  }
+  panoramaOpened() {
+    this.panoramaOpenedAt = now();
+    this.emit("3d_panorama_opened");
+  }
+  panoramaClosed() {
+    const viewMs = this.panoramaOpenedAt ? Math.round(now() - this.panoramaOpenedAt) : 0;
+    this.panoramaOpenedAt = 0;
+    this.emit("3d_panorama_closed", { viewMs });
+  }
+};
+
+// src/view3d/index.ts
+var SEAT_EYE_ABOVE_DECK = 1.02;
+var DEG3 = Math.PI / 180;
+var TAP_SLOP = 6;
+var TAP_MS = 500;
+function mountVenue3D(container, input, opts = {}) {
+  const model = buildSceneModel(input);
+  const analytics = new Analytics3D(opts.onAnalytics);
+  const seatIdByIndex = new Array(model.seats.count);
+  for (const [id, idx] of model.seats.idToIndex) seatIdByIndex[idx] = id;
+  const sectionIdBySeatId = /* @__PURE__ */ new Map();
+  for (const s of input.seats) sectionIdBySeatId.set(s.id, s.sectionId);
+  const hasHeights = (() => {
+    if (input.doc.floors?.some((f) => (f.baseHeightM ?? 0) > 0)) return true;
+    const objs = input.doc.floors?.flatMap((f) => f.objects) ?? input.doc.objects;
+    return objs.some((o) => o.type === "section" && ((o.height ?? 0) > 0 || (o.rake ?? 0) > 0));
+  })();
+  let gpu = null;
+  let pick = null;
+  let contextLost = false;
+  let frozen = false;
+  let disposed = false;
+  let selection = /* @__PURE__ */ new Map();
+  let panorama = null;
+  const prefetch = /* @__PURE__ */ new Map();
+  let flightGen = 0;
+  let reducedForced = null;
+  let focusedFloor = -1;
+  const rebuildGpu = () => {
+    gpu = buildGpuScene(glctx.gl, model);
+    pick = new PickPipeline(glctx.renderer, gpu.seatGeometry, gpu.solidGeometry, model.seats.count);
+    glctx.setClearColor(model.theme.background.top);
+    pick.setRestoreClear(model.theme.background.top);
+    gpu.seatProgram.uniforms.uSeatRadius.value = SEAT_DOT_RADIUS_M * model.theme.seatScale;
+    gpu.seatProgram.uniforms.uFocusFloor.value = focusedFloor;
+    gpu.solidProgram.uniforms.uFocusFloor.value = focusedFloor;
+  };
+  const glctx = new GLContext(container, {
+    onContextLost: () => {
+      contextLost = true;
+      loop.stop();
+      gpu = null;
+      pick = null;
+    },
+    onContextRestored: () => {
+      rebuildGpu();
+      contextLost = false;
+      loop.requestRender();
+    }
+  });
+  const orbit = new OrbitCamera(
+    glctx.gl,
+    glctx.canvas,
+    () => loop.requestRender(),
+    () => analytics.orbitEngaged()
+    // first real drag/wheel/pinch (not the intro ease)
+  );
+  orbit.setAspect(glctx.aspect);
+  const stageAzimuth = (() => {
+    const dx = model.focalWorld[0] - model.bounds.center[0];
+    const dz = model.focalWorld[2] - model.bounds.center[2];
+    return Math.hypot(dx, dz) > model.bounds.radius * 0.12 ? Math.atan2(dx, dz) : void 0;
+  })();
+  orbit.frame(model.bounds, true, stageAzimuth);
+  const cinematic = new Cinematic(orbit.camera);
+  if (!container.style.position || container.style.position === "static") {
+    container.style.position = "relative";
+  }
+  const labelOverlay = new LabelOverlay(container, {
+    fontFamily: input.doc.theme?.fontFamily,
+    ink: input.doc.theme?.textColor
+  });
+  labelOverlay.setLabels(model.labels);
+  rebuildGpu();
+  const loop = new RenderLoop(() => {
+    if (contextLost || !gpu || frozen) return false;
+    const flying = cinematic.active;
+    const moving = flying ? cinematic.update(performance.now()) : orbit.update();
+    const lod = computeSeatLod(orbit.currentDistance, model.bounds.radius);
+    const u = gpu.seatProgram.uniforms;
+    u.uSeatScale.value = lod.scale;
+    u.uSeatFade.value = lod.fade;
+    u.uPixelToWorld.value = 2 * Math.tan(orbit.camera.fov * DEG3 / 2) / Math.max(1, glctx.pixelHeight);
+    glctx.renderer.render({ scene: gpu.background, clear: true });
+    glctx.renderer.render({ scene: gpu.main, camera: orbit.camera, clear: false });
+    labelOverlay.update(
+      orbit.camera.projectionViewMatrix,
+      glctx.canvas.clientWidth || 1,
+      glctx.canvas.clientHeight || 1,
+      orbit.currentDistance,
+      model.bounds.radius
+    );
+    return moving;
+  });
+  const ro = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => handle.resize()) : null;
+  ro?.observe(container);
+  const setSelection = (ids) => {
+    const baseStateIndex = (id) => {
+      const idx = model.seats.idToIndex.get(id);
+      return idx === void 0 ? void 0 : model.seats.iState[idx];
+    };
+    const { updates, next } = diffSelection(selection, ids, baseStateIndex);
+    selection = next;
+    if (updates.length) {
+      const runs = applySeatStates(model.seats, updates);
+      if (gpu) gpu.uploadSeatStateRuns(runs);
+      loop.requestRender();
+    }
+  };
+  const reducedMotion = () => {
+    if (reducedForced !== null) return reducedForced;
+    return typeof window !== "undefined" && !!window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  };
+  const PREFETCH_CAP = 8;
+  const ensureSeatView = (seatId) => {
+    if (!opts.getSeatView) return null;
+    let p = prefetch.get(seatId);
+    if (!p) {
+      p = Promise.resolve(opts.getSeatView(seatId));
+      prefetch.set(seatId, p);
+      while (prefetch.size > PREFETCH_CAP) {
+        const oldest = prefetch.keys().next().value;
+        if (oldest === void 0) break;
+        prefetch.delete(oldest);
+      }
+    }
+    return p;
+  };
+  const seatEyeWorld = (idx) => [
+    model.seats.iPosition[idx * 3],
+    model.seats.iPosition[idx * 3 + 1] + SEAT_EYE_ABOVE_DECK,
+    model.seats.iPosition[idx * 3 + 2]
+  ];
+  const placeCameraFinal = (finalPos, focal) => {
+    orbit.camera.position.set(finalPos[0], finalPos[1], finalPos[2]);
+    orbit.camera.lookAt(new import_ogl7.Vec3(focal[0], focal[1], focal[2]));
+    orbit.camera.fov = FOV_END;
+    orbit.camera.updateProjectionMatrix();
+  };
+  let arriveChip = null;
+  const removeArriveChip = () => {
+    arriveChip?.remove();
+    arriveChip = null;
+  };
+  const showArriveChip = (seatId, gen) => {
+    removeArriveChip();
+    if (disposed || !opts.getSeatView) return;
+    const chip = document.createElement("button");
+    chip.type = "button";
+    chip.textContent = "\u25C9 View in 360\xB0";
+    chip.setAttribute("aria-label", `Open the 360\xB0 view from seat ${seatId}`);
+    Object.assign(chip.style, {
+      position: "absolute",
+      left: "50%",
+      bottom: "18px",
+      transform: "translateX(-50%)",
+      minHeight: "44px",
+      padding: "10px 18px",
+      borderRadius: "999px",
+      background: "rgba(12,18,32,0.78)",
+      color: "#eef1f8",
+      border: "1px solid rgba(150,165,205,0.4)",
+      backdropFilter: "blur(6px)",
+      font: "600 13px/1 inherit",
+      cursor: "pointer",
+      zIndex: "4"
+    });
+    chip.addEventListener("click", () => {
+      if (disposed || gen !== flightGen) {
+        removeArriveChip();
+        return;
+      }
+      removeArriveChip();
+      void openPanorama(seatId, 400, gen);
+    });
+    container.appendChild(chip);
+    arriveChip = chip;
+  };
+  const overviewChip = document.createElement("button");
+  overviewChip.type = "button";
+  overviewChip.textContent = "\u2302 Overview";
+  overviewChip.setAttribute("aria-label", "Return to the venue overview");
+  Object.assign(overviewChip.style, {
+    position: "absolute",
+    right: "14px",
+    bottom: "18px",
+    minHeight: "40px",
+    padding: "8px 14px",
+    borderRadius: "999px",
+    background: "rgba(12,18,32,0.72)",
+    color: "#c9d4ea",
+    border: "1px solid rgba(150,165,205,0.35)",
+    backdropFilter: "blur(6px)",
+    font: "600 12.5px/1 inherit",
+    cursor: "pointer",
+    zIndex: "4"
+  });
+  overviewChip.addEventListener("click", () => {
+    if (disposed || frozen) return;
+    cancelFlight();
+    removeArriveChip();
+    orbit.frameSoft(model.bounds, stageAzimuth);
+    loop.requestRender();
+  });
+  container.appendChild(overviewChip);
+  const openPanorama = async (seatId, fadeMs, gen) => {
+    const viewPromise = ensureSeatView(seatId);
+    if (!viewPromise) {
+      orbit.syncFromCamera();
+      return;
+    }
+    frozen = true;
+    loop.stop();
+    let view;
+    try {
+      view = await viewPromise;
+    } catch {
+      if (!disposed && gen === flightGen) {
+        frozen = false;
+        orbit.resumeAfterFlight(model.focalWorld);
+        loop.requestRender();
+      }
+      return;
+    }
+    if (disposed || gen !== flightGen) return;
+    removeArriveChip();
+    panorama = mountPanorama(container, view, {
+      fadeMs,
+      seatLabel: seatId,
+      onClose: () => {
+        panorama = null;
+        frozen = false;
+        analytics.panoramaClosed();
+        orbit.resumeAfterFlight(model.focalWorld);
+        loop.requestRender();
+        showArriveChip(seatId, flightGen);
+      }
+    });
+    analytics.panoramaOpened();
+  };
+  const cancelFlight = () => {
+    flightGen++;
+    if (cinematic.active) {
+      cinematic.cancel();
+      orbit.resumeAfterFlight(model.focalWorld);
+    }
+  };
+  const flyToSeat = (seatId) => {
+    if (disposed || !gpu) return Promise.resolve();
+    const idx = model.seats.idToIndex.get(seatId);
+    if (idx === void 0) return Promise.resolve();
+    if (panorama) {
+      panorama.dispose();
+      panorama = null;
+    }
+    frozen = false;
+    const gen = ++flightGen;
+    removeArriveChip();
+    const seatEye = seatEyeWorld(idx);
+    const focal = model.focalWorld;
+    const start = [orbit.camera.position.x, orbit.camera.position.y, orbit.camera.position.z];
+    const { waypoints, finalPos } = buildWaypoints(start, seatEye, focal, model.bounds.center, model.bounds.radius);
+    if (reducedMotion()) {
+      placeCameraFinal(finalPos, focal);
+      loop.requestRender();
+      analytics.cinematicSkipped();
+      if (!disposed) orbit.syncFromCamera();
+      showArriveChip(seatId, gen);
+      return Promise.resolve();
+    }
+    const startQuat = new import_ogl7.Quat().copy(orbit.camera.quaternion);
+    const endQuat = lookAtQuat(orbit.camera, finalPos, focal);
+    loop.requestRender();
+    return cinematic.start(waypoints, startQuat, endQuat).then(() => {
+      if (disposed || gen !== flightGen) return;
+      analytics.cinematicPlayed(FLIGHT_DURATION_MS);
+      orbit.resumeAfterFlight(model.focalWorld);
+      loop.requestRender();
+      showArriveChip(seatId, gen);
+    });
+  };
+  let downX = 0, downY = 0, downT = 0, downId = -1, moved = false, suppressTap = false;
+  const onDown = (e) => {
+    if (downId !== -1) return;
+    downId = e.pointerId;
+    downX = e.clientX;
+    downY = e.clientY;
+    downT = performance.now();
+    moved = false;
+    suppressTap = cinematic.active;
+    if (cinematic.active) {
+      analytics.cinematicCancelled();
+      cancelFlight();
+    }
+  };
+  const onMove = (e) => {
+    if (e.pointerId !== downId) return;
+    if (Math.hypot(e.clientX - downX, e.clientY - downY) > TAP_SLOP) moved = true;
+  };
+  const onUp = (e) => {
+    if (e.pointerId !== downId) return;
+    const isTap = !moved && performance.now() - downT < TAP_MS;
+    downId = -1;
+    if (suppressTap) {
+      suppressTap = false;
+      return;
+    }
+    if (!isTap || !gpu || !pick) return;
+    pick.syncFromSeatProgram(gpu.seatProgram);
+    const rect = glctx.canvas.getBoundingClientRect();
+    const dpr = glctx.renderer.dpr;
+    const { x, y } = pickPixelCoords(e.clientX, e.clientY, rect, dpr, glctx.gl.drawingBufferWidth, glctx.gl.drawingBufferHeight);
+    const radius = Math.max(2, Math.round(8 * dpr));
+    const idx = pick.pick(orbit.camera, x, y, radius);
+    if (idx < 0 || idx >= seatIdByIndex.length) {
+      if (selection.size) setSelection([]);
+      return;
+    }
+    const seatId = seatIdByIndex[idx];
+    if (selection.has(seatId) && selection.size === 1) setSelection([]);
+    else setSelection([seatId]);
+    ensureSeatView(seatId);
+    analytics.seatPicked(seatId, sectionIdBySeatId.get(seatId));
+    opts.onSeatPick?.(seatId);
+  };
+  glctx.canvas.addEventListener("pointerdown", onDown);
+  glctx.canvas.addEventListener("pointermove", onMove);
+  glctx.canvas.addEventListener("pointerup", onUp);
+  glctx.canvas.addEventListener("pointercancel", onUp);
+  loop.requestRender();
+  const handle = {
+    setAvailability(updates) {
+      const passthrough = mergeAvailabilityIntoSelection(selection, updates);
+      const runs = applySeatStates(model.seats, passthrough);
+      if (runs.length && gpu) gpu.uploadSeatStateRuns(runs);
+      loop.requestRender();
+    },
+    setSelection,
+    flyToSeat,
+    resize() {
+      const { width, height } = glctx.resize();
+      orbit.setAspect(width / Math.max(1, height));
+      loop.requestRender();
+    },
+    stats() {
+      return {
+        ...loop.stats(),
+        drawCalls: gpu ? gpu.drawCalls : 0,
+        seatCount: model.seatCount
+      };
+    },
+    loseContextForTest() {
+      glctx.simulateContextLossCycle();
+    },
+    floors() {
+      return model.floors;
+    },
+    focusFloor(index) {
+      if (index !== null && !model.floors.some((f) => f.index === index)) return false;
+      const value = index ?? -1;
+      if (gpu) {
+        gpu.seatProgram.uniforms.uFocusFloor.value = value;
+        gpu.solidProgram.uniforms.uFocusFloor.value = value;
+      }
+      focusedFloor = value;
+      if (index !== null) {
+        const f = model.floors[index];
+        if (f.seatCount > 0) {
+          cinematic.cancel();
+          orbit.frame({ center: f.center, radius: f.radius * 1.25 });
+        }
+      }
+      loop.requestRender();
+      return true;
+    },
+    zones() {
+      return model.zones;
+    },
+    focusZone(zoneId) {
+      const zone = model.zones.find((z) => z.id === zoneId);
+      if (!zone || zone.seatCount === 0) return false;
+      cinematic.cancel();
+      const dx = zone.focalWorld[0] - zone.center[0];
+      const dz = zone.focalWorld[2] - zone.center[2];
+      const azimuth = Math.hypot(dx, dz) > zone.radius * 0.12 ? Math.atan2(dx, dz) : void 0;
+      orbit.frame({ center: zone.center, radius: zone.radius * 1.25 }, false, azimuth);
+      loop.requestRender();
+      return true;
+    },
+    setReducedMotionForTest(value) {
+      reducedForced = value;
+    },
+    dispose() {
+      disposed = true;
+      removeArriveChip();
+      overviewChip.remove();
+      cancelFlight();
+      loop.stop();
+      labelOverlay.dispose();
+      ro?.disconnect();
+      if (panorama) {
+        panorama.dispose();
+        panorama = null;
+      }
+      glctx.canvas.removeEventListener("pointerdown", onDown);
+      glctx.canvas.removeEventListener("pointermove", onMove);
+      glctx.canvas.removeEventListener("pointerup", onUp);
+      glctx.canvas.removeEventListener("pointercancel", onUp);
+      orbit.dispose();
+      if (pick) pick.dispose();
+      if (gpu) gpu.dispose();
+      gpu = null;
+      pick = null;
+      glctx.dispose();
+    }
+  };
+  analytics.opened(model.seatCount, hasHeights);
+  return handle;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildSceneModel,
+  mountVenue3D
+});
+//# sourceMappingURL=index.cjs.map