@seatlayer/core 0.28.4 → 0.29.0

package/dist/view3d/index.cjs

@@ -0,0 +1,1972 @@
+"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]
+};
+function seatStateColorLUT() {
+  const out = [];
+  for (const s of SEAT_STATES) out.push(...SEAT_STATE_COLORS[s]);
+  return out;
+}
+function seatStateColorByIndex(index) {
+  const state = SEAT_STATES[index] ?? "available";
+  return SEAT_STATE_COLORS[state];
+}
+var STRUCTURE = {
+  ground: [0.07, 0.085, 0.11],
+  tierTop: [0.24, 0.28, 0.34],
+  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]
+};
+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) {
+    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.gl.clearColor(BACKGROUND.top[0], BACKGROUND.top[1], BACKGROUND.top[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();
+  }
+  /** 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) {
+    this.target.set(bounds.center[0], bounds.center[1], bounds.center[2]);
+    const r = Math.max(1, bounds.radius);
+    const halfV = this.fovY * DEG / 2;
+    const aspect = this.camera.aspect || 1;
+    const halfH = Math.atan(Math.tan(halfV) * aspect);
+    const fit = Math.max(r / Math.tan(halfV), r / Math.tan(halfH));
+    this.azT = -30 * DEG;
+    this.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 });
+  }
+  /** 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/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 M = METRES_PER_CHART_UNIT;
+var MeshBuilder = class {
+  constructor() {
+    this.pos = [];
+    this.nor = [];
+    this.col = [];
+  }
+  /** One triangle with a shared (flat) normal and per-vertex colours. */
+  tri(p0, p1, p2, n, c0, c1 = c0, c2 = c0) {
+    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]);
+  }
+  get vertexCount() {
+    return this.pos.length / 3;
+  }
+  build() {
+    return {
+      position: new Float32Array(this.pos),
+      normal: new Float32Array(this.nor),
+      color: new Float32Array(this.col),
+      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;
+}
+function extrudePrism(builder, outlineIn, holesIn, topY, bottomY, colTop, colWall, ao) {
+  if (!outlineIn || outlineIn.length < 3) return;
+  if (Math.abs(signedArea(outlineIn)) < 1e-4) return;
+  const outline = toCCW(outlineIn);
+  const holes = holesIn?.map((h) => toCCW(h)).filter((h) => h.length >= 3 && Math.abs(signedArea(h)) >= 1e-4);
+  const { 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];
+  for (let i = 0; i < tris.length; i += 3) {
+    const a = pts[tris[i]], b = pts[tris[i + 1]], c = pts[tris[i + 2]];
+    const at = [a.x * M, topY(a), a.y * M];
+    const bt = [b.x * M, topY(b), b.y * M];
+    const ct = [c.x * M, topY(c), c.y * M];
+    let n = faceNormal(at, bt, ct);
+    if (n[1] < 0) n = [-n[0], -n[1], -n[2]];
+    builder.tri(at, bt, ct, n, cTop);
+    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 oc = centroid(outline);
+  const rings = [{ ring: outline, flip: false }];
+  if (holes) {
+    for (const h of holes) if (h.length >= 3) rings.push({ ring: 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);
+  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);
+    off += p.count;
+  }
+  return { position, normal, color, count: total };
+}
+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_SURFACE_LIFT_M = 0.18;
+function seatSurfaceY(seat) {
+  const eye = seat.eyeHeightM;
+  if (Number.isFinite(eye)) {
+    return Math.max(0, eye - SEATED_EYE_HEIGHT_M) + SEAT_SURFACE_LIFT_M;
+  }
+  return SEAT_SURFACE_LIFT_M;
+}
+function buildSeatInstances(seats, initial) {
+  const count = seats.length;
+  const iPosition = new Float32Array(count * 3);
+  const iState = new Float32Array(count);
+  const idToIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < count; i++) {
+    const seat = seats[i];
+    iPosition[i * 3] = seat.x * M;
+    iPosition[i * 3 + 1] = seatSurfaceY(seat);
+    iPosition[i * 3 + 2] = seat.y * M;
+    iState[i] = seatStateIndex(initial ? initial(seat) : "available");
+    idToIndex.set(seat.id, i);
+  }
+  return { count, iPosition, iState, idToIndex };
+}
+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 + 1) {
+      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/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 };
+var DECK_DROP_M = 0.28;
+var MAX_TIER_RISE_M = 25;
+function tintTop(fill, neutral) {
+  if (!fill) return neutral;
+  const muted = scaleRgb(desaturate(fill, 0.4), 0.62);
+  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 buildTier(builder, section, unit, fill) {
+  if (!section.outline || section.outline.length < 3) return;
+  const geo = sectionGeometry(section, { floorBaseHeightM: unit.baseHeightM });
+  const bottomY = unit.baseHeightM;
+  const rakeRad = geo.rake * Math.PI / 180;
+  const flat = geo.rake <= 0.01 && geo.height <= bottomY + 1e-3;
+  const colTop = tintTop(fill, STRUCTURE.tierTop);
+  if (flat) {
+    const topY2 = bottomY + 0.05;
+    extrudePrism(builder, section.outline, section.holes, () => topY2, bottomY, colTop, STRUCTURE.tierWall, AO);
+    return;
+  }
+  let frontDist = Infinity;
+  for (const p of section.outline) {
+    const d = Math.hypot(p.x - unit.focal.x, p.y - unit.focal.y);
+    if (d < frontDist) frontDist = d;
+  }
+  const tan = Math.tan(rakeRad);
+  const topY = (p) => {
+    const d = Math.hypot(p.x - unit.focal.x, p.y - unit.focal.y);
+    const depthM = Math.max(0, d - frontDist) * M;
+    const rise = Math.min(depthM * tan, MAX_TIER_RISE_M);
+    return Math.max(bottomY + 0.05, geo.height + rise - DECK_DROP_M);
+  };
+  extrudePrism(builder, section.outline, section.holes, topY, bottomY, colTop, STRUCTURE.tierWall, AO);
+}
+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) {
+  const poly = shapePolygon(shape);
+  if (!poly) return;
+  const isStage = shape.role === "stage";
+  const height = isStage ? base + 1 : base + 0.25;
+  const colTop = isStage ? STRUCTURE.stageTop : STRUCTURE.decorTop;
+  const colWall = isStage ? STRUCTURE.stageWall : STRUCTURE.decorWall;
+  extrudePrism(builder, poly, void 0, () => height, base, colTop, colWall, AO);
+}
+function buildGa(builder, ga, base, fill) {
+  if (!ga.points || ga.points.length < 3) return;
+  const colTop = tintTop(fill, STRUCTURE.gaTop);
+  extrudePrism(builder, ga.points, ga.holes, () => base + 0.15, base, colTop, STRUCTURE.gaWall, AO);
+}
+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);
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    minX = -100;
+    minY = -100;
+    maxX = 100;
+    maxY = 100;
+  }
+  return { minX, minY, maxX, maxY };
+}
+function buildSceneModel(input) {
+  const { doc, seats } = input;
+  const units = floorUnits(doc);
+  const builder = new MeshBuilder();
+  const fp = chartFootprint(units, seats);
+  const padU = Math.max(60, (fp.maxX - fp.minX + fp.maxY - fp.minY) * 0.06);
+  const groundPoly = rectPolygon(fp.minX - padU, fp.minY - padU, fp.maxX - fp.minX + padU * 2, fp.maxY - fp.minY + padU * 2);
+  extrudePrism(builder, groundPoly, void 0, () => 0, -0.4, STRUCTURE.ground, STRUCTURE.ground, AO);
+  const sectionFills = resolveSectionFills(doc, seats);
+  const catColor = /* @__PURE__ */ new Map();
+  for (const c of doc.categories ?? []) catColor.set(c.key, c.color);
+  for (const unit of units) {
+    for (const o of unit.objects) {
+      if (o.type === "section") buildTier(builder, o, unit, sectionFill(o, sectionFills));
+      else if (o.type === "shape") buildShape(builder, o, unit.baseHeightM);
+      else if (o.type === "gaArea") buildGa(builder, o, unit.baseHeightM, hexToRgb(catColor.get(o.categoryKey)));
+    }
+  }
+  const solids = mergeMeshData([builder.build()]);
+  const seatData = buildSeatInstances(seats, input.initialState);
+  const cx = (fp.minX + fp.maxX) / 2 * M;
+  const cz = (fp.minY + fp.maxY) / 2 * M;
+  const radius = 0.5 * Math.hypot((fp.maxX - fp.minX) * M, (fp.maxY - fp.minY) * M) || 10;
+  const focal = doc.focalPoint ?? { x: (fp.minX + fp.maxX) / 2, y: (fp.minY + fp.maxY) / 2 };
+  return {
+    solids,
+    seats: seatData,
+    bounds: { center: [cx, radius * 0.08, cz], radius, groundY: 0 },
+    stateColorLUT: seatStateColorLUT(),
+    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]
+  };
+}
+
+// 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;
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform mat3 normalMatrix;
+out vec3 vColor;
+out vec3 vNormalView;
+out vec3 vPosView;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  vPosView = mv.xyz;
+  vNormalView = normalize(normalMatrix * normal);
+  vColor = color;
+  gl_Position = projectionMatrix * mv;
+}`
+);
+var SOLID_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec3 vColor;
+in vec3 vNormalView;
+in vec3 vPosView;
+out vec4 fragColor;
+void main() {
+  vec3 N = normalize(vNormalView);
+  vec3 V = normalize(-vPosView);
+  float hemi = 0.5 + 0.5 * N.y;                 // sky/ground gradient
+  vec3 L = normalize(vec3(0.4, 0.85, 0.55));    // warm key, view space
+  float key = max(dot(N, L), 0.0);
+  vec3 base = vColor * (0.60 + 0.32 * hemi) + vColor * key * 0.32;
+  float fres = pow(1.0 - max(dot(N, V), 0.0), 3.0);
+  base += vec3(0.26, 0.31, 0.38) * fres * 0.35; // cool rim, restrained
+  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)
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform float uSeatRadius;
+uniform float uSeatScale;
+uniform float uMinPixels;
+uniform float uPixelToWorld;   // (2*tan(fovY/2)) / viewportHeightPx
+out vec2 vUv;
+out vec3 vColor;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(iOffset, 1.0);
+  float depth = max(-mv.z, 0.001);
+  float minR = uMinPixels * depth * uPixelToWorld;      // screen-space floor
+  float r = max(uSeatRadius * uSeatScale, minR);
+  mv.xy += position * r;                                 // camera-facing billboard
+  vUv = position;
+  vColor = iColor;
+  gl_Position = projectionMatrix * mv;
+}`
+);
+var SEAT_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 vUv;
+in vec3 vColor;
+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);
+  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;
+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 = max(uSeatRadius * uSeatScale, minR);
+  mv.xy += position * 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: 0.22 },
+      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
+  });
+}
+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: 0.22 },
+      uSeatScale: { value: 1 },
+      uMinPixels: { value: 2.5 },
+      uPixelToWorld: { value: 2e-3 },
+      uSeatFade: { value: 0 },
+      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) {
+  for (let i = start; i < start + count; i++) {
+    const c = seatStateColorByIndex(iState[i]);
+    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, BACKGROUND.top, 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 }
+  });
+  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);
+  writeSeatColors(iColor, model.seats.iState, 0, model.seats.count);
+  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 }
+  });
+  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,
+    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);
+      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;
+    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);
+  }
+  /** 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] = BACKGROUND.top;
+    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 DEG2 = 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;
+  const rebuildGpu = () => {
+    gpu = buildGpuScene(glctx.gl, model);
+    pick = new PickPipeline(glctx.renderer, gpu.seatGeometry, gpu.solidGeometry, model.seats.count);
+  };
+  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);
+  orbit.frame(model.bounds, true);
+  const cinematic = new Cinematic(orbit.camera);
+  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 * DEG2 / 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 });
+    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();
+  };
+  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;
+    panorama = mountPanorama(container, view, {
+      fadeMs,
+      seatLabel: seatId,
+      onClose: () => {
+        panorama = null;
+        frozen = false;
+        analytics.panoramaClosed();
+        orbit.resumeAfterFlight(model.focalWorld);
+        loop.requestRender();
+      }
+    });
+    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;
+    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();
+      return openPanorama(seatId, 300, gen).then(() => {
+        if (!disposed) orbit.syncFromCamera();
+      });
+    }
+    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);
+      return openPanorama(seatId, 400, 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();
+    },
+    setReducedMotionForTest(value) {
+      reducedForced = value;
+    },
+    dispose() {
+      disposed = true;
+      cancelFlight();
+      loop.stop();
+      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