@seatlayer/core 0.51.0 → 0.52.0

package/dist/index.js

@@ -22,8 +22,10 @@ import {
   expandTable,
   expandTableSlots,
   floorObjects,
+  floorOverviewTranslations,
   floorsOf,
   layerOf,
+  layoutFloorOverview,
   objectCenter,
   owningSectionForObject,
   pointInPolygon,
@@ -37,8 +39,9 @@ import {
   sectionGeometry,
   stackFloors,
   tableInventoryCount,
-  tableSeatCountsBySide
-} from "./chunk-GD267BFB.js";
+  tableSeatCountsBySide,
+  translateObject
+} from "./chunk-UID7KN44.js";
 
 // src/core/ga.ts
 var PREFIX = "__sl_ga__";
@@ -1286,6 +1289,8 @@ var en = {
   "picker.poweredBy": "Powered by SeatLayer",
   "picker.testMode": "TEST MODE",
   "picker.orphanHint": "This leaves a single seat stranded \u2014 consider shifting one seat over.",
+  "picker.companionRequiresWheelchair": "Requires the adjacent wheelchair place",
+  "picker.companionPairRequired": "Select the adjacent wheelchair place with each companion ticket.",
   // renderer (drawn on the Konva map — shared by the embed SDK)
   "map.aria": "Seating map. Use arrow keys to move between seats, Enter to select.",
   "map.seatsLeft": "{count} LEFT",
@@ -1397,8 +1402,6 @@ var en = {
   "picker.fewerGuests": "Fewer guests",
   "picker.fewerSeats": "Fewer seats",
   "picker.filterAndFocusByPrice": "Filter and focus seats by price",
-  "picker.filteredSeat": "Unavailable with current filters",
-  "picker.filteredSeatExplanation": "Change the active price or view filters to make this seat selectable.",
   "picker.filters": "Filters",
   "picker.findBestSeatsCount.one": "Find {count} best seat",
   "picker.findBestSeatsCount.other": "Find {count} best seats",
@@ -1634,10 +1637,11 @@ var WHEELCHAIR_GLYPH_MIN_PX = 10;
 var FILTERED_WHEELCHAIR_GLYPH_MIN_PX = 14;
 var SECTION_PROMINENT_SCALE = 0.45 * SEAT_LEGIBLE_SCALE;
 var BLOCK_MELT_TOP = 0.9 * SEAT_LEGIBLE_SCALE;
-var SEAT_FOCUS_SCALE = Math.max(SEAT_LEGIBLE_SCALE * 1.1, BLOCK_MELT_TOP);
+var SEAT_DETAIL_SCALE = Math.max(SEAT_LEGIBLE_SCALE * 1.1, BLOCK_MELT_TOP);
 var PAN_START_SLOP_PX = 8;
 var GHOST_CLICK_MS = 700;
 var ROW_LABEL_CLEARANCE = 2;
+var FOCUSED_ROW_LABEL_MIN_PX = MIN_VISIBLE_BOOKABLE_LABEL_PX;
 var ROW_LABEL_COLLISION_CELL = 64;
 var ZONE_PROMINENT_SCALE = 0.55 * SECTION_PROMINENT_SCALE;
 var MAX_LABELS = 700;
@@ -2033,6 +2037,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     this.activeFloorId = "";
     /** When true on a multi-floor chart, render ALL floors stacked (3D overview). */
     this.stacked = false;
+    /** Buyer-facing 2D overview: floors are rigidly arranged without altering topology. */
+    this.floorOverview = false;
     /** Interactive node per seat/booth — a Circle for seats, a Rect for booths. */
     this.circleById = /* @__PURE__ */ new Map();
     /** Booth block geometry, keyed by booth id (= the unit's rowId). */
@@ -2288,6 +2294,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         return;
       }
       if (this.pinch && this.pointers.size >= 2) {
+        this.releaseSectionFocusDim();
         const [a, b] = [...this.pointers.values()];
         const dist = Math.hypot(b.x - a.x, b.y - a.y);
         if (this.pinch.startDist < 1) return;
@@ -2306,6 +2313,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         if (!this.panStarted) {
           if (this.moved <= PAN_START_SLOP_PX) return;
           this.panStarted = true;
+          this.releaseSectionFocusDim();
         }
         this.stage.position({
           x: this.stage.x() + (p.x - this.panLast.x),
@@ -2426,13 +2434,23 @@ var _SeatmapRenderer = class _SeatmapRenderer {
   }
   // ---- ISeatmapRenderer -----------------------------------------------------
   setChart(doc, opts) {
-    if (doc !== this.chartDoc) this.stacked = false;
+    if (doc !== this.chartDoc) {
+      this.stacked = false;
+      this.floorOverview = false;
+    }
     this.cancelAssetLoads();
     this.chartDoc = doc;
     this.activeFloorId = opts?.floorId ?? floorsOf(doc)[0].id;
     this.objectFloor.clear();
     if (doc.floors && doc.floors.length > 1) {
-      for (const f of doc.floors) for (const o of f.objects) this.objectFloor.set(o.id, f.id);
+      for (const f of doc.floors) {
+        for (const o of f.objects) {
+          this.objectFloor.set(o.id, f.id);
+          if (o.type === "section" && o.logicalSectionId) {
+            this.objectFloor.set(o.logicalSectionId, f.id);
+          }
+        }
+      }
     }
     const view = this.floorView(doc);
     this.focusedId = null;
@@ -2530,7 +2548,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     this.seats = expandChart(view, {
       // A stacked overview is presentation-only and never opens a seat POV. The
       // per-section renderer below still resolves each object's real floor base.
-      floorBaseHeightM: this.stacked ? 0 : this.floorBaseHeightMFor()
+      floorBaseHeightM: this.stacked || this.floorOverview ? 0 : this.floorBaseHeightMFor()
     });
     for (const s of this.seats) {
       this.seatById.set(s.id, s);
@@ -2551,14 +2569,21 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     this.overlayLayer.add(this.focusRing);
     this.zoomToFit();
   }
-  /** The chart to render: all floors stacked (3D overview), the active floor, or
-   *  the whole chart for single-floor charts. */
+  /** The chart to render: authored-coordinate overview, stacked 3D overview,
+   *  the active floor, or the whole chart for single-floor charts. */
   floorView(doc) {
     if (!doc.floors || !doc.floors.length) return {
       ...doc,
       referenceImage: void 0,
       backgroundImage: buyerBackgroundImage(doc)
     };
+    if (this.floorOverview && doc.floors.length >= 2) {
+      return {
+        ...layoutFloorOverview(doc),
+        referenceImage: void 0,
+        backgroundImage: buyerBackgroundImage(doc)
+      };
+    }
     if (this.stacked && doc.floors.length >= 2) {
       return {
         ...stackFloors(doc),
@@ -2591,14 +2616,30 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     const multi = !!this.chartDoc.floors && this.chartDoc.floors.length >= 2;
     if (!multi) return;
     this.stacked = on;
+    if (on) this.floorOverview = false;
     this.setChart(this.chartDoc, { floorId: this.activeFloorId });
   }
   isStacked() {
     return this.stacked;
   }
+  /** Toggle the buyer's combined 2D floor overview. Every floor is translated
+   *  as one rigid group for clarity; its authored internal topology is exact. */
+  setFloorOverview(on) {
+    if (!this.chartDoc || on === this.floorOverview) return;
+    const multi = !!this.chartDoc.floors && this.chartDoc.floors.length >= 2;
+    if (!multi) return;
+    this.floorOverview = on;
+    if (on) this.stacked = false;
+    this.setChart(this.chartDoc, { floorId: this.activeFloorId });
+  }
+  isFloorOverview() {
+    return this.floorOverview;
+  }
   /** Switch which floor is shown (2D). Re-renders + re-fits; no-op if unchanged. */
   setActiveFloor(floorId) {
-    if (!this.chartDoc || floorId === this.activeFloorId) return;
+    if (!this.chartDoc || floorId === this.activeFloorId && !this.floorOverview && !this.stacked) return;
+    this.floorOverview = false;
+    this.stacked = false;
     this.setChart(this.chartDoc, { floorId });
   }
   /** Floors for the host's switcher (single-floor charts return one synthetic floor). */
@@ -3057,6 +3098,13 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     const h = this.stage.height();
     const b = this.viewMode === "perspective" && this.perspectiveBounds ? this.perspectiveBounds : this.bounds;
     this.fitScale = Math.min(w / b.width, h / b.height) || 1;
+    if (this.opts.portraitFitCrop && !this.exportMode) {
+      const widthBound = w / b.width <= h / b.height;
+      const projectedH = b.height * this.fitScale;
+      if (widthBound && projectedH < 0.55 * h) {
+        this.fitScale = Math.min(this.fitScale * 1.3, 0.62 * h / b.height);
+      }
+    }
     const s = this.fitScale;
     this.stage.scale({ x: s, y: s });
     this.stage.position({
@@ -3066,6 +3114,18 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     this.afterViewChange();
     this.stage.batchDraw();
   }
+  /**
+   * Reframe after a host/layout resize without throwing away section context.
+   * The stage already represents the usable map area (the picker side panel is
+   * a sibling), so measuring it here naturally respects open/closed panels.
+   */
+  refitCurrentView() {
+    if (this.focusedSectionId && this.sectionBounds(this.focusedSectionId)) {
+      this.focusRegion(this.focusedSectionId, { animate: false });
+      return;
+    }
+    this.zoomToFit();
+  }
   zoomIn() {
     const center = { x: this.stage.width() / 2, y: this.stage.height() / 2 };
     this.zoomAbout(this.stage.scaleX() * _SeatmapRenderer.ZOOM_STEP, center);
@@ -4156,8 +4216,9 @@ var _SeatmapRenderer = class _SeatmapRenderer {
   }
   /**
    * AXS section-focus: dim + desaturate every other section, draw a calm backdrop
-   * panel behind this section's seats, and glide the camera in to frame it (the
-   * seat-pick gate below only lets buyers pick once seats are ≥ LABEL_SCALE big).
+   * panel behind this section's seats, and glide the camera to a padded fit of
+   * the whole section. A large section may therefore use smaller seat markers,
+   * but it never clips its outer rows merely to meet a fixed detail scale.
    */
   focusSection(id) {
     if (!this.sections.some((section) => section.id === id || section.logicalId === id)) return;
@@ -4166,7 +4227,24 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     this.bgLayer.batchDraw();
     this.overlayLayer.batchDraw();
     this.updateLOD();
-    this.focusRegion(id, { minScale: SEAT_FOCUS_SCALE });
+    this.focusRegion(id);
+  }
+  /**
+   * Release only the focus dim + backdrop, keeping the focused-section state
+   * (summary card, adjacent-section navigation, LOD) intact. Called on the
+   * buyer's first manual pan/pinch/wheel after a section glide: the dim reads
+   * as "everything else is disabled", but every seat outside the focus was
+   * always hit-testable — free roaming across sections is the product
+   * behaviour, the glide is only an entrance.
+   */
+  releaseSectionFocusDim() {
+    if (!this.focusBackdrop && !this.focusDimOverlay) return;
+    this.focusBackdrop?.destroy();
+    this.focusBackdrop = null;
+    this.focusDimOverlay?.destroy();
+    this.focusDimOverlay = null;
+    this.bgLayer.batchDraw();
+    this.overlayLayer.batchDraw();
   }
   /** Clear an AXS section focus — restore full-bowl brightness + drop the backdrop. */
   clearSectionFocus() {
@@ -4304,6 +4382,44 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     if (!Number.isFinite(minX)) return { x: 0, y: 0, width: 1, height: 1 };
     return { x: minX, y: minY, width: Math.max(1, maxX - minX), height: Math.max(1, maxY - minY) };
   }
+  /** Live minimap geometry comes from the rendered scene, so a content-aware
+   * all-floor layout cannot collapse back onto the source coordinate stack. */
+  getMinimapSnapshot() {
+    const sections = this.sections.map((section) => {
+      const inactive = this.isSectionClosed(section) || section.free <= 0;
+      const selected = section.memberIds.some((id) => this.selection.has(id));
+      const active2 = this.focusedSectionId === section.id || this.focusedSectionId === section.logicalId;
+      return {
+        id: section.logicalId,
+        label: section.label,
+        outline: section.outline.map((point) => ({ ...point })),
+        ...this.objectFloor.get(section.id) ? { floorId: this.objectFloor.get(section.id) } : {},
+        state: selected ? "selected" : inactive ? "inactive" : "available",
+        active: active2
+      };
+    });
+    return {
+      sections,
+      seats: sections.length ? [] : this.seats.map((seat) => ({
+        x: seat.x,
+        y: seat.y,
+        categoryKey: seat.categoryKey,
+        state: this.selection.has(seat.id) ? "selected" : this.statusById.get(seat.id) === "free" ? "available" : "inactive"
+      }))
+    };
+  }
+  /** Minimap drag/click navigation: preserve zoom and move one world point to
+   * the viewport centre. Works for flat and projected views via worldToScreen. */
+  panToWorld(point) {
+    this.cancelGlide();
+    const screen = this.worldToScreen(point);
+    this.stage.position({
+      x: this.stage.x() + this.stage.width() / 2 - screen.x,
+      y: this.stage.y() + this.stage.height() / 2 - screen.y
+    });
+    this.afterViewChange();
+    this.stage.batchDraw();
+  }
   /** Legend hover: highlight one category (dim the rest), or null to clear. */
   setCategoryHighlight(key) {
     if (this.categoryHighlight === key) return;
@@ -5072,7 +5188,15 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       blockT = clamp((BLOCK_MELT_TOP - scale) / (BLOCK_MELT_TOP - SECTION_PROMINENT_SCALE), 0, 1);
       zoneT = clamp((SECTION_PROMINENT_SCALE - scale) / (SECTION_PROMINENT_SCALE - ZONE_PROMINENT_SCALE), 0, 1);
     }
-    const sectionOverview = scale < CACHE_THRESHOLD;
+    if (this.floorOverview) {
+      blockT = 0;
+      zoneT = 0;
+    }
+    if (this.focusedSectionId) {
+      blockT = 0;
+      zoneT = 0;
+    }
+    const sectionOverview = !this.floorOverview && !this.focusedSectionId && scale < CACHE_THRESHOLD;
     if (sectionOverview) blockT = 1;
     if (!this.zones.length) zoneT = 0;
     const deferPerspectiveSeatReveal = this.viewMode === "perspective" && this.glideInProgress && this.seats.length > 2500;
@@ -5271,6 +5395,14 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     zone.back.offset({ x: width / 2, y: height / 2 });
     zone.back.cornerRadius(7 * this.uiScale() / sx);
     zone.back.strokeWidth(1 / sx);
+    const abs = zone.back.getAbsolutePosition();
+    const minScreenY = 62 + height * sx / 2;
+    if (abs.y < minScreenY) {
+      const dy = (minScreenY - abs.y) / sx;
+      zone.label.y(zone.label.y() + dy);
+      if (zone.sub) zone.sub.y(zone.sub.y() + dy);
+      zone.back.y(zone.back.y() + dy);
+    }
   }
   /**
    * Map a container-relative screen point back to world coords. Inverts the
@@ -5495,7 +5627,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
    * must fall through and pick.
    */
   sectionBounds(id) {
-    const bounds2 = this.sections.filter((section) => section.id === id || section.logicalId === id).map((section) => {
+    const matching = this.sections.filter((section) => section.id === id || section.logicalId === id);
+    const bounds2 = matching.map((section) => {
       if (this.viewMode === "perspective" && section.perspectiveAffine) {
         return polyBounds(section.outline.map((point) => this.projectedSectionPoint(section, point)));
       }
@@ -5507,11 +5640,77 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       return polyBounds(points);
     });
     if (!bounds2.length) return null;
-    const left = Math.min(...bounds2.map((box) => box.x));
-    const top = Math.min(...bounds2.map((box) => box.y));
-    const right = Math.max(...bounds2.map((box) => box.x + box.width));
-    const bottom = Math.max(...bounds2.map((box) => box.y + box.height));
-    return { x: left, y: top, width: right - left, height: bottom - top };
+    let left = Math.min(...bounds2.map((box) => box.x));
+    let top = Math.min(...bounds2.map((box) => box.y));
+    let right = Math.max(...bounds2.map((box) => box.x + box.width));
+    let bottom = Math.max(...bounds2.map((box) => box.y + box.height));
+    const memberIds = new Set(matching.flatMap((section) => section.memberIds));
+    for (const seatId of memberIds) {
+      const seat = this.seatById.get(seatId);
+      if (!seat) continue;
+      const point = this.renderedSeatPoint(seat);
+      left = Math.min(left, point.x - this.seatR);
+      top = Math.min(top, point.y - this.seatR);
+      right = Math.max(right, point.x + this.seatR);
+      bottom = Math.max(bottom, point.y + this.seatR);
+    }
+    const includeBox = (box) => {
+      if (![box.x, box.y, box.width, box.height].every(Number.isFinite)) return;
+      left = Math.min(left, box.x);
+      top = Math.min(top, box.y);
+      right = Math.max(right, box.x + box.width);
+      bottom = Math.max(bottom, box.y + box.height);
+    };
+    const belongsToSection = (box) => {
+      const centre = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+      return matching.some((section) => pointInPolygonWithHoles(centre, section.outline, section.holes));
+    };
+    for (const { node, backdrop } of this.freeTextById.values()) {
+      const nodeBox = node.getClientRect({ relativeTo: this.bgLayer, skipShadow: true });
+      if (!belongsToSection(nodeBox)) continue;
+      includeBox(nodeBox);
+      if (backdrop) includeBox(backdrop.getClientRect({ relativeTo: this.bgLayer, skipShadow: true }));
+    }
+    for (const { node } of this.iconNodeById.values()) {
+      const box = node.getClientRect({ relativeTo: this.bgLayer, skipShadow: true });
+      if (belongsToSection(box)) includeBox(box);
+    }
+    const occupiedText = new WorldBoxIndex();
+    for (const { node } of this.freeTextById.values()) {
+      const box = node.getClientRect({ relativeTo: this.bgLayer, skipShadow: true, skipStroke: true });
+      occupiedText.insert({
+        x: box.x - ROW_LABEL_CLEARANCE,
+        y: box.y - ROW_LABEL_CLEARANCE,
+        width: box.width + ROW_LABEL_CLEARANCE * 2,
+        height: box.height + ROW_LABEL_CLEARANCE * 2
+      });
+    }
+    for (const plan of this.rowLabelPlan) {
+      const relevant = plan.focusKeys?.some((key) => key === id || matching.some((section) => key === section.id || key === section.logicalId || key === section.zone)) ?? false;
+      const label = new Text({
+        text: plan.text,
+        fontSize: plan.fontSize,
+        fontStyle: "700",
+        fontFamily: this.labelFont(),
+        rotation: plan.rotation,
+        listening: false
+      });
+      label.offsetX(label.width() / 2);
+      label.offsetY(label.height() / 2);
+      const resolved = this.resolveAutomaticRowLabelPosition(label, plan, occupiedText);
+      const box = this.rowLabelBox(label, resolved);
+      if (relevant) includeBox(box);
+      occupiedText.insert(box);
+      label.destroy();
+    }
+    const span = Math.max(right - left, bottom - top);
+    const padding = Math.max(this.seatR * 2, Math.min(24, span * 0.025));
+    return {
+      x: left - padding,
+      y: top - padding,
+      width: Math.max(1, right - left + padding * 2),
+      height: Math.max(1, bottom - top + padding * 2)
+    };
   }
   sectionFrameScale(id) {
     const b = this.sectionBounds(id);
@@ -5522,7 +5721,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     const margin = 1.12;
     if (b.width <= 0 || b.height <= 0) return this.stage.scaleX();
     const frameScale = Math.min(w / (b.width * margin), h / (b.height * margin));
-    return clamp(Math.max(frameScale, SEAT_FOCUS_SCALE), min, max);
+    return clamp(frameScale, min, max);
   }
   /**
    * Resolve a seat tap: honour the 3D deck-drill and the AXS seat-pick gate,
@@ -5535,7 +5734,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
    * fall through and PICK. This is the invariant: seats are never unpickable.
    */
   handleSeatTap(id) {
-    if (this.stacked && this.opts.onDeckTap) {
+    if ((this.stacked || this.floorOverview) && this.opts.onDeckTap) {
       const floorId = this.objectFloor.get(this.seatById.get(id)?.rowId ?? "");
       if (floorId) {
         this.opts.onDeckTap(floorId);
@@ -5610,6 +5809,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     });
     this.stage.on("wheel", (e) => {
       e.evt.preventDefault();
+      this.releaseSectionFocusDim();
       const r = this.container.getBoundingClientRect();
       const pointer = { x: e.evt.clientX - r.left, y: e.evt.clientY - r.top };
       const factor = Math.exp(-e.evt.deltaY * 2e-3);
@@ -5626,8 +5826,9 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         if (near) this.handleSeatTap(near);
         return;
       }
-      if (this.stacked && this.opts.onDeckTap) {
-        const floorId = this.deckFloorAt();
+      if ((this.stacked || this.floorOverview) && this.opts.onDeckTap) {
+        const sectionId = this.floorOverview ? this.sectionAt(pointer) : null;
+        const floorId = (sectionId ? this.objectFloor.get(sectionId) : null) ?? this.deckFloorAt();
         if (floorId) {
           this.opts.onDeckTap(floorId);
           return;
@@ -6025,6 +6226,28 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         ...hiddenReason ? { hiddenReason } : {}
       };
     });
+    const rowLabels = this.labelGroup.find((node) => node.getAttr("rowLabel") === true).filter((node) => node instanceof Text).map((node) => {
+      const screenBounds = node.getClientRect({
+        skipShadow: true,
+        skipStroke: true
+      });
+      const outside = screenBounds.x + screenBounds.width < 0 || screenBounds.x > viewport.width || screenBounds.y + screenBounds.height < 0 || screenBounds.y > viewport.height;
+      const ink = node.fill();
+      return {
+        text: node.text(),
+        visible: node.isVisible() && !outside,
+        renderedFontPx: rounded(node.fontSize() * effectiveScale),
+        ink: typeof ink === "string" ? ink : "",
+        ...!outside ? {
+          screenBox: {
+            x: rounded(screenBounds.x),
+            y: rounded(screenBounds.y),
+            width: rounded(screenBounds.width),
+            height: rounded(screenBounds.height)
+          }
+        } : {}
+      };
+    });
     const palette = overviewPalette(this.canvasBackground);
     const neutralSectionFills = new Set(
       ["normal", "nearly-gone", "sold-out", "closed"].map((state) => overviewStateFill(palette, state).toLowerCase())
@@ -6069,7 +6292,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       labels,
       gaAreas,
       hierarchyLabels,
-      freeTextLabels
+      freeTextLabels,
+      rowLabels
     };
   }
   /** Jump the camera to a rung's zoom band (glided). */
@@ -6081,7 +6305,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     }
     const target = rung === "sections" ? (SECTION_PROMINENT_SCALE + CACHE_THRESHOLD) / 2 : Math.max(
       this.seatLabelTargetScale() * 1.05,
-      SEAT_FOCUS_SCALE,
+      SEAT_DETAIL_SCALE,
       CACHE_THRESHOLD * 1.3
     );
     const w = this.stage.width();
@@ -6368,14 +6592,25 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     for (const { objectId, node, backdrop, categoryKey, kind } of this.freeTextById.values()) {
       const gaDimmed = categoryKey != null && (kind === "ga-label" || kind === "ga-capacity") && this.gaCategoryDimmed(categoryKey);
       const gaOverviewHidden = objectId != null && (kind === "ga-label" || kind === "ga-capacity") && this.gaById.get(objectId)?.sectionId != null && effectiveScale < CACHE_THRESHOLD;
-      const visible = !gaDimmed && !gaOverviewHidden && isBookableLabelLegibleAtScale(node.fontSize(), effectiveScale);
+      const focusedAnnotation = kind === "free-text" && this.nodeBelongsToFocusedSection(node);
+      const visible = !gaDimmed && !gaOverviewHidden && (focusedAnnotation || isBookableLabelLegibleAtScale(node.fontSize(), effectiveScale));
       node.visible(visible);
       backdrop?.visible(visible);
     }
     for (const { node, fontSize } of this.iconNodeById.values()) {
-      node.visible(isBookableLabelLegibleAtScale(fontSize, effectiveScale));
+      node.visible(this.nodeBelongsToFocusedSection(node) || isBookableLabelLegibleAtScale(fontSize, effectiveScale));
     }
   }
+  /** Geometric association only: importer data remains unchanged. */
+  nodeBelongsToFocusedSection(node) {
+    const focus = this.focusedSectionId;
+    if (!focus) return false;
+    const matching = this.sections.filter((section) => section.id === focus || section.logicalId === focus || section.zone === focus);
+    if (!matching.length) return false;
+    const box = node.getClientRect({ relativeTo: this.bgLayer, skipShadow: true });
+    const centre = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+    return matching.some((section) => pointInPolygonWithHoles(centre, section.outline, section.holes));
+  }
   /** OV-45(a): resolve authored row-letter labels for the buyer/preview map, in
    *  world space, matching the Designer's placement contract (start/end/both/none
    *  preset, a free-drag `position` that wins over the preset, rotation, and
@@ -6385,18 +6620,25 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     this.rowLabelPlan = [];
     const background = this.theme.background ?? "#0e1117";
     const seatsByRow = /* @__PURE__ */ new Map();
+    const addSeat = (key, seat) => {
+      const list = seatsByRow.get(key) ?? [];
+      list.push(seat);
+      seatsByRow.set(key, list);
+    };
     for (const seat of this.seats) {
       if (seat.kind === "booth") continue;
       const key = seat.logicalRowId ?? seat.rowId;
-      (seatsByRow.get(key) ?? seatsByRow.set(key, []).get(key)).push(seat);
+      addSeat(key, seat);
+      if (key !== seat.rowId) addSeat(seat.rowId, seat);
     }
     const seatOrder = (seat) => seat.logicalSeatIndex ?? Number(seat.id.split(":").pop() ?? 0);
     for (const obj of view.objects) {
       if (obj.type !== "row") continue;
-      if (obj.segmentedRow && obj.segmentedRow.componentIndex !== 0) continue;
-      const presentation = obj.segmentedRow?.labelPresentation ?? obj.labelPresentation;
+      const repeatOnComponents = obj.segmentedRow?.repeatLabelOnComponents === true;
+      if (obj.segmentedRow && !repeatOnComponents && obj.segmentedRow.componentIndex !== 0) continue;
+      const presentation = repeatOnComponents ? obj.labelPresentation : obj.segmentedRow?.labelPresentation ?? obj.labelPresentation;
       if (presentation?.visible === false || presentation?.positionPreset === "none") continue;
-      const key = obj.segmentedRow ? obj.segmentedRow.groupId : obj.id;
+      const key = obj.segmentedRow && !repeatOnComponents ? obj.segmentedRow.groupId : obj.id;
       const seats = (seatsByRow.get(key) ?? []).slice().sort((a, b) => seatOrder(a) - seatOrder(b));
       if (!seats.length) continue;
       const first = seats[0];
@@ -6411,6 +6653,10 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       const rotation = presentation?.rotation ?? 0;
       const text = obj.segmentedRow?.displayLabel ?? obj.displayLabel ?? obj.label;
       const opacity = this.objectFilteredOut(obj) ? 0.15 : 1;
+      const containingSection = this.seatSection.get(first.id);
+      const focusKeys = containingSection ? [...new Set([containingSection.id, containingSection.logicalId, containingSection.zone].filter(
+        (value) => Boolean(value)
+      ))] : void 0;
       const push = (x, y, automaticAway) => this.rowLabelPlan.push({
         text,
         x,
@@ -6419,6 +6665,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         fontSize,
         ink,
         opacity,
+        ...focusKeys?.length ? { focusKeys } : {},
         ...automaticAway ? { automaticAway } : {}
       });
       if (presentation?.position) {
@@ -6438,6 +6685,18 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         push(last.x + away.x * gap, last.y + away.y * gap, away);
       }
     }
+    const mergeRadius = (this.seatR + 12) * 2.2;
+    const merged = [];
+    for (const entry of this.rowLabelPlan) {
+      const partner = merged.find((candidate) => candidate.text === entry.text && Math.hypot(candidate.x - entry.x, candidate.y - entry.y) <= mergeRadius);
+      if (partner) {
+        partner.x = (partner.x + entry.x) / 2;
+        partner.y = (partner.y + entry.y) / 2;
+        continue;
+      }
+      merged.push(entry);
+    }
+    this.rowLabelPlan = merged;
   }
   /** Axis-aligned world bounds of a centred, potentially rotated row label. */
   rowLabelBox(label, position, padding = ROW_LABEL_CLEARANCE) {
@@ -6514,12 +6773,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     this.labelGroup.destroyChildren();
     this.labelLiftGroups.clear();
     this.seatLabelById.clear();
-    if (!show) {
-      this.overlayLayer.batchDraw();
-      return;
-    }
     let count = 0;
-    for (const seat of this.visibleSeatCandidates()) {
+    if (show) for (const seat of this.visibleSeatCandidates()) {
       if (seat.kind === "booth") continue;
       const screen = this.worldToScreen(seat);
       if (screen.x < -20 || screen.x > this.stage.width() + 20 || screen.y < -20 || screen.y > this.stage.height() + 20) continue;
@@ -6610,13 +6865,16 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       });
     }
     for (const rl of this.rowLabelPlan) {
+      const focused = this.focusedSectionId != null && rl.focusKeys?.includes(this.focusedSectionId);
+      const renderedFontSize = focused ? Math.max(rl.fontSize, FOCUSED_ROW_LABEL_MIN_PX / Math.max(effectiveScale, 1e-4)) : rl.fontSize;
+      if (!focused && !isBookableLabelLegibleAtScale(renderedFontSize, effectiveScale)) continue;
       const screen = this.worldToScreen({ x: rl.x, y: rl.y });
       if (screen.x < -40 || screen.x > this.stage.width() + 40 || screen.y < -40 || screen.y > this.stage.height() + 40) continue;
       const t2 = new Text({
         x: rl.x,
         y: rl.y,
         text: rl.text,
-        fontSize: rl.fontSize,
+        fontSize: renderedFontSize,
         fontStyle: "700",
         fontFamily: this.labelFont(),
         fill: rl.ink,
@@ -6645,7 +6903,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     const h = this.container.clientHeight || 1;
     if (w === this.stage.width() && h === this.stage.height()) return;
     this.stage.size({ width: w, height: h });
-    this.zoomToFit();
+    this.refitCurrentView();
   }
   startFpsLoop() {
     const tick = (now) => {
@@ -6803,6 +7061,99 @@ function pickBestAvailable(seats, available, opts) {
   return { labels: ranked.slice(0, qty).map((r) => r.seat.label) };
 }
 
+// src/core/ticketRestrictions.ts
+function ticketOptionNotApplicableIssue(labels) {
+  return {
+    code: "ticket_option_not_applicable",
+    labels,
+    message: "That ticket choice is not available for the selected seat."
+  };
+}
+function ticketTierAppliesToSeat(tier, seat) {
+  const applicability = tier.applicability;
+  if (!applicability) return true;
+  if (applicability.seatLabels?.length && !applicability.seatLabels.includes(seat.label)) return false;
+  if (applicability.accessibility?.length && !applicability.accessibility.some((key) => seat.accessibility?.includes(key))) return false;
+  return true;
+}
+function applicableTicketTiers(doc, seat) {
+  return (doc.categories.find((category) => category.key === seat.categoryKey)?.tiers ?? []).filter((tier) => ticketTierAppliesToSeat(tier, seat));
+}
+function resolveTicketTierForSeat(doc, seat, tierId) {
+  const tiers = doc.categories.find((category) => category.key === seat.categoryKey)?.tiers;
+  if (!tiers?.length) return { kind: "none" };
+  const tier = tierId == null ? tiers.find((candidate) => ticketTierAppliesToSeat(candidate, seat)) : tiers.find((candidate) => candidate.id === tierId && ticketTierAppliesToSeat(candidate, seat));
+  return tier ? { kind: "resolved", tier } : { kind: "invalid" };
+}
+function sameLogicalRow(a, b) {
+  return (a.logicalRowId ?? a.rowId) === (b.logicalRowId ?? b.rowId);
+}
+function authoredIndex(seat) {
+  if (Number.isInteger(seat.logicalSeatIndex)) return seat.logicalSeatIndex;
+  const raw = seat.id.slice(seat.id.lastIndexOf(":") + 1);
+  const index = Number(raw);
+  return Number.isInteger(index) ? index : void 0;
+}
+function observablyAdjacent(a, b) {
+  if (!sameLogicalRow(a, b)) return false;
+  const aIndex = authoredIndex(a);
+  const bIndex = authoredIndex(b);
+  return aIndex != null && bIndex != null && Math.abs(aIndex - bIndex) === 1;
+}
+function companionSelectionIssue(doc, selections) {
+  if (!selections.length) return null;
+  const byLabel = new Map(expandChart(doc, { resolveEyeHeights: false }).map((seat) => [seat.label, seat]));
+  const selected = selections.flatMap((selection) => {
+    const seat = byLabel.get(selection.label);
+    return seat ? [{ selection, seat }] : [];
+  });
+  const wheelchair = selected.map(({ seat }) => seat).filter((seat) => seat.accessibility?.includes("wheelchair"));
+  const unpaired = [];
+  for (const { selection, seat } of selected) {
+    const resolution = resolveTicketTierForSeat(doc, seat, selection.tierId);
+    const tier = resolution.kind === "resolved" ? resolution.tier : void 0;
+    const isCompanion = seat.accessibility?.includes("companion") || tier?.restriction === "companion";
+    if (isCompanion && !wheelchair.some((candidate) => candidate.id !== seat.id && observablyAdjacent(seat, candidate))) {
+      unpaired.push(seat.label);
+    }
+  }
+  return unpaired.length ? {
+    code: "companion_pair_required",
+    labels: unpaired,
+    message: "Select the adjacent wheelchair place with each companion ticket."
+  } : null;
+}
+function ticketSelectionIssue(doc, selections) {
+  if (!selections.length) return null;
+  const byLabel = new Map(expandChart(doc, { resolveEyeHeights: false }).map((seat) => [seat.label, seat]));
+  const notForSaleCategories = new Set(
+    doc.categories.filter((category) => category.notForSale).map((category) => category.key)
+  );
+  const notForSale = [];
+  const inapplicable = [];
+  for (const selection of selections) {
+    const seat = byLabel.get(selection.label);
+    if (!seat) continue;
+    if (notForSaleCategories.has(seat.categoryKey)) {
+      notForSale.push(seat.label);
+      continue;
+    }
+    const resolution = resolveTicketTierForSeat(doc, seat, selection.tierId);
+    if (resolution.kind === "invalid") inapplicable.push(seat.label);
+  }
+  if (notForSale.length) {
+    return {
+      code: "not_for_sale",
+      labels: notForSale,
+      message: "These seats are not for sale."
+    };
+  }
+  if (inapplicable.length) {
+    return ticketOptionNotApplicableIssue(inapplicable);
+  }
+  return companionSelectionIssue(doc, selections);
+}
+
 // src/core/tableInventory.ts
 var GroupedTableProjectionError = class extends Error {
   constructor(objectId, message) {
@@ -6857,6 +7208,15 @@ function groupedTableInventory(doc, modelVersion) {
 // src/picker/PickerController.ts
 var DEFAULT_MAX_SELECTION = 10;
 var MAX_BACKOFF_MS = 15e3;
+var PickerSelectionError = class extends Error {
+  constructor(issue) {
+    super(issue.message);
+    this.status = 422;
+    this.name = "PickerSelectionError";
+    this.reason = issue.code;
+    this.labels = issue.labels;
+  }
+};
 var MAP_THEME_KEYS = ["background", "rowLabelColor", "textColor", "selectionColor"];
 function sameMapTheme(a, b) {
   if (!a || !b) return !a && !b;
@@ -6986,7 +7346,9 @@ var PickerController = class {
     if (!r) return true;
     const selected = r.getSelection().map((seat) => seat.id);
     const floorId = this.getActiveFloorId();
+    const floorOverview = r.isFloorOverview?.() ?? false;
     r.setChart(this.visibleDoc(), floorId ? { floorId } : void 0);
+    if (floorOverview) r.setFloorOverview?.(true);
     if (this.opts.colorblindSafe) r.setColorblindSafe?.(true);
     if (this.closedSections.size) r.setClosedSections?.([...this.closedSections]);
     this.applySeatsMap(Object.fromEntries(this.liveStatuses), this.liveDefault);
@@ -6998,7 +7360,9 @@ var PickerController = class {
     const next = ids.filter((x) => typeof x === "string");
     if (next.length === this.hidden.size && next.every((id) => this.hidden.has(id))) return false;
     this.hidden = new Set(next);
+    const floorOverview = this.renderer?.isFloorOverview?.() ?? false;
     this.renderer?.setChart(this.visibleDoc());
+    if (floorOverview) this.renderer?.setFloorOverview?.(true);
     return true;
   }
   /** Adopt a new closed-section set; restyle (grey + non-pickable) if it differs.
@@ -7073,16 +7437,22 @@ var PickerController = class {
   /** Fetch chart, build label maps, mount the renderer, seed statuses, go live. */
   async render(host) {
     if (this.renderer) return null;
+    const renderStartedAt = performance.now();
+    const profile = {};
+    const duration = (startedAt) => Math.round((performance.now() - startedAt) * 100) / 100;
     this.closed = false;
     let res;
+    const chartStartedAt = performance.now();
     try {
       res = await this.api.chart(this.key);
     } catch (err) {
       this.emitError(err);
       return null;
     }
+    profile.loadChart = duration(chartStartedAt);
     if (this.closed) return null;
     this._doc = res.doc;
+    const normalizeStartedAt = performance.now();
     try {
       const groups = groupedTableInventory(
         res.doc,
@@ -7147,13 +7517,16 @@ var PickerController = class {
       this.labelToId.set(group.label, representative.id);
       this.labelToSeat.set(group.label, representative);
     }
+    profile.normalizeBuyerModel = duration(normalizeStartedAt);
     const currency = res.event.currency ?? this.opts.currency;
     this.currency = currency ?? "USD";
+    const rendererStartedAt = performance.now();
     const renderer = createRenderer(host, {
       // Group chairs are selected together for paint, but count as one logical
       // inventory line. The controller enforces the guest-weighted cap.
       maxSelection: this.rendererSelectionCap(),
       confirmSelection: this.opts.confirmSelection,
+      portraitFitCrop: true,
       currency,
       onSelect: (seat) => {
         this.handleRendererSelect(seat);
@@ -7174,6 +7547,7 @@ var PickerController = class {
       onDeckTap: (floorId) => this.handleDeckTap(floorId),
       onFps: this.opts.onFps
     });
+    profile.createRenderer = duration(rendererStartedAt);
     if (this.closed) {
       renderer.destroy();
       return null;
@@ -7182,6 +7556,7 @@ var PickerController = class {
     let seats = null;
     let seatsDefault = "free";
     let closedIds = [];
+    const statusesStartedAt = performance.now();
     try {
       const objs = await this.api.objects(this.key);
       this.hidden = new Set(objs.hidden ?? []);
@@ -7190,18 +7565,30 @@ var PickerController = class {
       seatsDefault = objs.default ?? "free";
     } catch {
     }
+    profile.loadStatuses = duration(statusesStartedAt);
     if (this.closed) {
       renderer.destroy();
       this.renderer = null;
       return null;
     }
+    const sceneStartedAt = performance.now();
     renderer.setChart(this.visibleDoc());
+    if ((res.doc.floors?.length ?? 0) > 1) renderer.setFloorOverview?.(true);
     if (this.opts.colorblindSafe) renderer.setColorblindSafe?.(true);
+    profile.buildScene = duration(sceneStartedAt);
     this.closedSections = new Set(closedIds);
+    const initialStateStartedAt = performance.now();
     if (closedIds.length) renderer.setClosedSections?.(closedIds);
     if (seats) this.applySeatsMap(seats, seatsDefault);
+    profile.applyInitialState = duration(initialStateStartedAt);
+    const firstPaintStartedAt = performance.now();
+    renderer.forceDraw();
+    profile.firstPaint = duration(firstPaintStartedAt);
+    const realtimeStartedAt = performance.now();
     this.attachVisibilityListener();
     this.connect();
+    profile.startRealtime = duration(realtimeStartedAt);
+    profile.controllerTotal = duration(renderStartedAt);
     return {
       doc: res.doc,
       salesClosed: !!res.event.salesClosed,
@@ -7212,7 +7599,8 @@ var PickerController = class {
       currency,
       // 'test' ⇒ sandbox event: hosts render a TEST MODE ribbon (Phase 11).
       mode: res.event.mode ?? "live",
-      posterUrl: res.event.posterUrl ?? null
+      posterUrl: res.event.posterUrl ?? null,
+      performanceProfile: profile
     };
   }
   // ---- selection ------------------------------------------------------------
@@ -7268,11 +7656,23 @@ var PickerController = class {
   select(ids) {
     const before = new Set(this.getSelection().map((seat) => seat.label));
     const expanded = /* @__PURE__ */ new Set();
+    const rejected = [];
     for (const id of ids) {
       const table = this.groupedTableBySeatId.get(id) ?? this.groupedTablesByLabel.get(id);
-      if (table) table.chairs.forEach((chair) => expanded.add(chair.id));
-      else expanded.add(id);
+      if (table) {
+        const resolution = this.tableTierResolution(table);
+        if (resolution.kind === "invalid") rejected.push(table.label);
+        else table.chairs.forEach((chair) => expanded.add(chair.id));
+      } else {
+        const seat = this.seatById.get(id);
+        if (seat && this.seatTierResolution(seat).kind === "invalid") rejected.push(seat.label);
+        else expanded.add(id);
+      }
     }
+    if (rejected.length) {
+      this.emitError(new PickerSelectionError(ticketOptionNotApplicableIssue(rejected)));
+    }
+    if (!expanded.size) return [];
     this.renderer?.select?.([...expanded]);
     if (this.selectionGuestCount() > this.maxSelection) {
       this.renderer?.deselect([...expanded]);
@@ -7340,6 +7740,13 @@ var PickerController = class {
   }
   handleRendererSelect(seat) {
     const table = this.groupedTableBySeatId.get(seat.id);
+    const resolution = table ? this.tableTierResolution(table) : this.seatTierResolution(seat);
+    if (resolution.kind === "invalid") {
+      this.renderer?.deselect(table ? table.chairs.map((chair) => chair.id) : [seat.id]);
+      this.emitError(new PickerSelectionError(ticketOptionNotApplicableIssue([table?.label ?? seat.label])));
+      this.emitSelectionChange();
+      return;
+    }
     if (table) {
       if (this.selectionGuestCount() > this.maxSelection) {
         this.renderer?.deselect(table.chairs.map((chair) => chair.id));
@@ -7421,6 +7828,8 @@ var PickerController = class {
     const existingGA = (this.hold_?.items ?? []).filter((item) => item.objectType === "ga");
     const combinedLabels = [.../* @__PURE__ */ new Set([...existingGA.map((item) => item.label), ...labels])];
     if (!combinedLabels.length) return null;
+    const restriction = this.ticketIssue(combinedLabels);
+    if (restriction) throw new PickerSelectionError(restriction);
     if (this.hold_ && this.holdCovers(combinedLabels)) return this.hold_;
     try {
       const selections = combinedLabels.map((label) => {
@@ -7592,6 +8001,7 @@ var PickerController = class {
     const available = /* @__PURE__ */ new Set();
     for (const seat of seats) {
       if (held.has(seat.label)) continue;
+      if (this.seatTierResolution(seat).kind === "invalid") continue;
       const id = this.labelToId.get(seat.label);
       const status = id ? this.getStatus(id) : void 0;
       if ((status ?? "free") === "free") available.add(seat.label);
@@ -7673,6 +8083,8 @@ var PickerController = class {
     if (!this.api.book) throw new Error("picker: transport has no book() \u2014 hold-only mode");
     const labels = labelsArg ?? this.getSelection().map((seat) => seat.label);
     if (!labels.length) return null;
+    const restriction = this.ticketIssue(labels);
+    if (restriction) throw new PickerSelectionError(restriction);
     let holdId;
     try {
       if (this.hold_ && this.holdCovers(labels)) {
@@ -7799,6 +8211,20 @@ var PickerController = class {
   getStatus(id) {
     return this.renderer?.getStatus(id);
   }
+  /** Seat ids whose category the author marked not-for-sale. */
+  notForSaleCategorySeatIds() {
+    const doc = this.doc;
+    if (!doc) return [];
+    const flagged = new Set(
+      doc.categories.filter((category) => category.notForSale).map((category) => category.key)
+    );
+    if (!flagged.size) return [];
+    const ids = [];
+    for (const [id, seat] of this.seatById) {
+      if (flagged.has(seat.categoryKey)) ids.push(id);
+    }
+    return ids;
+  }
   flashSeat(id, color) {
     this.renderer?.flashSeat(id, color);
   }
@@ -7811,6 +8237,11 @@ var PickerController = class {
   zoomToFit() {
     this.renderer?.zoomToFit();
   }
+  /** Preserve section focus while the usable map viewport changes. */
+  refitCurrentView() {
+    if (this.renderer?.refitCurrentView) this.renderer.refitCurrentView();
+    else this.renderer?.zoomToFit();
+  }
   worldToScreen(p) {
     return this.renderer?.worldToScreen(p) ?? { x: 0, y: 0 };
   }
@@ -7840,7 +8271,8 @@ var PickerController = class {
   /** Switch the shown floor (2D), then re-apply live seat statuses onto it. */
   setFloor(id) {
     const r = this.renderer;
-    if (!r?.setActiveFloor || id === r.getActiveFloorId?.()) return;
+    if (!r?.setActiveFloor || id === r.getActiveFloorId?.() && !r.isFloorOverview?.()) return;
+    r.setFloorOverview?.(false);
     r.setStacked?.(false);
     r.setActiveFloor(id);
     void this.resnapshot();
@@ -7856,12 +8288,24 @@ var PickerController = class {
   isMultiFloor() {
     return (this._doc?.floors?.length ?? 0) > 1;
   }
+  /** Enter/leave the source-coordinate all-floor buyer overview. */
+  setFloorOverview(on) {
+    const r = this.renderer;
+    if (!r?.setFloorOverview || on === r.isFloorOverview?.()) return;
+    r.setFloorOverview(on);
+    void this.resnapshot();
+    this.emitSelectionChange();
+  }
+  isFloorOverview() {
+    return this.renderer?.isFloorOverview?.() ?? false;
+  }
   /** Tap-a-deck-to-enter: leave the 3D stack, drop to flat 2D on `floorId`, and
    *  tell the host so it can sync its 2D/3D toggle + floor-switcher state. */
   handleDeckTap(floorId) {
     const r = this.renderer;
     if (!r) return;
     r.setViewMode?.("flat");
+    r.setFloorOverview?.(false);
     r.setStacked?.(false);
     r.setActiveFloor?.(floorId);
     void this.resnapshot();
@@ -7930,10 +8374,30 @@ var PickerController = class {
     if (!r?.getVisibleWorldRect || !r.getWorldBounds) return null;
     return { visible: r.getVisibleWorldRect(), bounds: r.getWorldBounds() };
   }
+  getMinimapSnapshot() {
+    return this.renderer?.getMinimapSnapshot?.() ?? { sections: [], seats: [] };
+  }
+  panToWorld(point) {
+    this.renderer?.panToWorld?.(point);
+  }
+  /** Leave section-focus dimming without changing the current zoom. Used when
+   * the minimap viewport itself is dragged to a different part of the venue. */
+  clearSectionFocus() {
+    this.renderer?.clearSectionFocus?.();
+    this.opts.onSectionFocus?.(null);
+  }
+  /** Read-only browser-render evidence for parity/performance audit tooling. */
+  getRenderedQualityEvidence() {
+    return this.renderer?.getRenderedQualityEvidence() ?? null;
+  }
   /** Glide in on a section and surface its summary (same path as a section tap). */
   focusSection(id) {
     this.handleSectionTap(id);
   }
+  /** Live seat membership count used by buyer section-navigation controls. */
+  getSectionSeatCount(id) {
+    return this.renderer?.sectionMembers?.(id)?.length ?? 0;
+  }
   /** Zoom back out to the whole chart and clear the section-summary card + focus. */
   overview() {
     this.renderer?.clearSectionFocus?.();
@@ -7986,15 +8450,21 @@ var PickerController = class {
     }
     const categories = [...byCat.entries()].map(([key, count]) => {
       const cat = doc.categories.find((c) => c.key === key);
+      const prices = cat?.tiers?.length ? cat.tiers.map((tier) => tier.price) : [cat?.price ?? 0];
+      const priceMin = Math.min(...prices);
+      const priceMax = Math.max(...prices);
       return {
         key,
         count,
         label: cat?.label ?? key,
         color: cat?.color ?? "#6e7bff",
-        price: cat?.price ?? 0
+        price: priceMin,
+        priceMin,
+        priceMax
       };
     }).sort((a, b) => a.price - b.price);
-    const prices = categories.map((c) => c.price);
+    const minimums = categories.map((c) => c.priceMin);
+    const maximums = categories.map((c) => c.priceMax);
     const zone = sec.zone ? doc.zones?.find((z) => z.id === sec.zone) : void 0;
     const color = sec.color ?? zone?.color ?? categories[0]?.color ?? "#6e7bff";
     return {
@@ -8004,8 +8474,8 @@ var PickerController = class {
       ...sec.entrance && sec.entrance.trim() ? { entrance: sec.entrance.trim() } : {},
       color,
       seatsLeft,
-      priceMin: prices.length ? prices[0] : 0,
-      priceMax: prices.length ? prices[prices.length - 1] : 0,
+      priceMin: minimums.length ? Math.min(...minimums) : 0,
+      priceMax: maximums.length ? Math.max(...maximums) : 0,
       categories
     };
   }
@@ -8046,11 +8516,12 @@ var PickerController = class {
     const accessibility = s.accessibility?.length ? { accessibility: s.accessibility } : void 0;
     const wheelchair = s.wheelchairSpaceType ? { wheelchairSpaceType: s.wheelchairSpaceType } : void 0;
     const context = this.seatContext.get(s.id);
-    const tiers = this.tiersFor(s.categoryKey);
-    if (!tiers) {
-      return { id: s.id, label: s.label, ...display, ...context, categoryKey: s.categoryKey, price: this.priceFor(s.categoryKey), ...commercial, ...accessibility, ...wheelchair };
+    const tiers = this.tiersForSeat(s);
+    const resolution = this.seatTierResolution(s);
+    if (resolution.kind !== "resolved" || !tiers) {
+      return { id: s.id, label: s.label, ...display, ...context, categoryKey: s.categoryKey, price: this.priceFor(s.categoryKey), currency: this.currency, ...commercial, ...accessibility, ...wheelchair };
     }
-    const chosen = tiers.find((t2) => t2.id === this.seatTiers.get(s.id)) ?? tiers[0];
+    const chosen = resolution.tier;
     return {
       id: s.id,
       label: s.label,
@@ -8058,6 +8529,7 @@ var PickerController = class {
       ...context,
       categoryKey: s.categoryKey,
       price: chosen.price,
+      currency: this.currency,
       tiers,
       tierId: chosen.id,
       ...commercial,
@@ -8067,8 +8539,9 @@ var PickerController = class {
   }
   toTableSeat(table) {
     const representative = table.chairs[0];
-    const tiers = this.tiersFor(table.categoryKey);
-    const chosen = tiers?.find((tier) => tier.id === this.seatTiers.get(representative?.id ?? "")) ?? tiers?.[0];
+    const tiers = this.tiersFor(table.categoryKey)?.filter((tier) => resolveTicketTierForSeat(this._doc, this.tableTierSeat(table), tier.id).kind === "resolved");
+    const resolution = this.tableTierResolution(table);
+    const chosen = resolution.kind === "resolved" ? resolution.tier : void 0;
     return {
       id: representative?.id ?? table.objectId,
       label: table.label,
@@ -8079,6 +8552,7 @@ var PickerController = class {
       rowLabel: table.displayLabel ?? table.label,
       categoryKey: table.categoryKey,
       price: chosen?.price ?? this.priceFor(table.categoryKey),
+      currency: this.currency,
       ...tiers ? { tiers, tierId: chosen?.id } : {},
       objectType: "table",
       bookingMode: table.mode,
@@ -8108,6 +8582,27 @@ var PickerController = class {
     const t2 = this._doc?.categories.find((c) => c.key === categoryKey)?.tiers;
     return t2 && t2.length ? t2 : void 0;
   }
+  tiersForSeat(seat) {
+    if (!this._doc) return void 0;
+    const tiers = applicableTicketTiers(this._doc, seat);
+    return tiers.length ? tiers : void 0;
+  }
+  seatTierResolution(seat) {
+    if (!this._doc) return { kind: "none" };
+    return resolveTicketTierForSeat(this._doc, seat, this.seatTiers.get(seat.id));
+  }
+  tableTierSeat(table) {
+    return {
+      label: table.label,
+      categoryKey: table.categoryKey,
+      accessibility: table.chairs.flatMap((chair) => chair.accessibility ?? [])
+    };
+  }
+  tableTierResolution(table) {
+    if (!this._doc) return { kind: "none" };
+    const representativeId = table.chairs[0]?.id ?? "";
+    return resolveTicketTierForSeat(this._doc, this.tableTierSeat(table), this.seatTiers.get(representativeId));
+  }
   /**
    * Choose a ticket tier for a selected seat (e.g. Adult → Child). Re-emits the
    * selection so the host's cart + the eventual hold carry the new tier + price.
@@ -8117,7 +8612,7 @@ var PickerController = class {
   setSeatTier(seatId, tierId) {
     const seat = this.seatById.get(seatId);
     if (!seat) return;
-    const tiers = this.tiersFor(seat.categoryKey);
+    const tiers = this.tiersForSeat(seat);
     if (!tiers) return;
     if (tierId == null) this.seatTiers.delete(seatId);
     else if (tiers.some((t2) => t2.id === tierId)) this.seatTiers.set(seatId, tierId);
@@ -8138,6 +8633,16 @@ var PickerController = class {
     this.opts.onSelectionChange?.(this.getSelection());
     this.emitOrphanHint();
   }
+  /** Check explicit tier applicability and companion relationships for the
+   * current (or supplied) seats. Ticket display names are never semantic input. */
+  ticketIssue(labels) {
+    if (!this._doc) return null;
+    const seats = labels ? this.seatsForLabels(labels) : this.getSelection();
+    return ticketSelectionIssue(this._doc, seats.map((seat) => ({
+      label: seat.label,
+      ...seat.tierId ? { tierId: seat.tierId } : {}
+    })));
+  }
   /**
    * Orphan-seat advice on manual selection: when the buyer's current picks
    * strand one (or more) single free seats between unavailable same-row
@@ -8148,6 +8653,12 @@ var PickerController = class {
     if (!this.opts.onHint) return;
     const r = this.renderer;
     if (!r) return;
+    const restriction = this.ticketIssue();
+    if (restriction) {
+      this.hintShown = true;
+      this.opts.onHint(restriction.code === "companion_pair_required" ? t("picker.companionPairRequired") : "That ticket choice is not available for the selected seat.");
+      return;
+    }
     const selected = new Set(r.getSelection().map((s) => s.id));
     const stranded = selected.size ? strandedSingles(this.seatById.values(), (id) => r.getStatus(id), selected) : [];
     if (stranded.length > 0) {
@@ -8269,6 +8780,8 @@ var PickerController = class {
     ["free", "held", "booked", "not_for_sale"].forEach((st) => {
       if (st !== defaultSeatStatus && byStatus[st].length) r.setStatus(byStatus[st], st);
     });
+    const notForSaleCategoryIds = this.notForSaleCategorySeatIds();
+    if (notForSaleCategoryIds.length) r.setStatus(notForSaleCategoryIds, "not_for_sale");
     this.clearBookedHoldIfSettled();
     this.opts.onStatusChange?.();
   }
@@ -9621,9 +10134,9 @@ function generateSeatThumb(seat, focalPoint, _neighborSeats) {
 
 // src/i18n/bundles.ts
 var LOADERS = {
-  es: () => import("./es-37ISLCZA.js").then((m) => ({ default: m.es })),
-  de: () => import("./de-V53JPFHN.js").then((m) => ({ default: m.de })),
-  fr: () => import("./fr-QKK2T64Q.js").then((m) => ({ default: m.fr }))
+  es: () => import("./es-VMBTGVFQ.js").then((m) => ({ default: m.es })),
+  de: () => import("./de-YGODYJ3E.js").then((m) => ({ default: m.de })),
+  fr: () => import("./fr-SLBE2ULB.js").then((m) => ({ default: m.fr }))
 };
 var loaded = /* @__PURE__ */ new Set(["en"]);
 async function loadLocale(code) {
@@ -9653,6 +10166,7 @@ export {
   MAX_EVENT_INVENTORY,
   MAX_GA_CAPACITY,
   PickerController,
+  PickerSelectionError,
   RENDERED_QUALITY_REPORT_VERSION,
   SEAT_COMMERCIAL_MARKS,
   SUPPORTED_LOCALES,
@@ -9676,6 +10190,7 @@ export {
   expandTable,
   expandTableSlots,
   floorObjects,
+  floorOverviewTranslations,
   floorsOf,
   formatDate,
   formatMinor,
@@ -9694,6 +10209,7 @@ export {
   isGaUnitLabel,
   isSectionHidden,
   layerOf,
+  layoutFloorOverview,
   loadLocale,
   objectCenter,
   owningSectionForObject,
@@ -9713,6 +10229,7 @@ export {
   tCount,
   tableInventoryCount,
   tableSeatCountsBySide,
+  translateObject,
   validGAInventorySegments
 };
 //# sourceMappingURL=index.js.map