@seatlayer/core 0.51.0 → 0.52.0

package/dist/index.cjs

@@ -45,6 +45,8 @@ var init_es = __esm({
       "picker.poweredBy": "Con la tecnolog\xEDa de SeatLayer",
       "picker.testMode": "MODO DE PRUEBA",
       "picker.orphanHint": "Esto deja un asiento aislado \u2014 considera desplazarte un asiento.",
+      "picker.companionRequiresWheelchair": "Requiere la plaza accesible contigua",
+      "picker.companionPairRequired": "Selecciona la plaza accesible contigua con cada entrada de acompa\xF1ante.",
       // renderer (drawn on the Konva map — shared by the embed SDK)
       "map.aria": "Mapa de asientos. Usa las flechas para moverte entre asientos, Intro para seleccionar.",
       "map.seatsLeft": "{count} LIBRES",
@@ -156,8 +158,6 @@ var init_es = __esm({
       "picker.fewerGuests": "Menos invitados",
       "picker.fewerSeats": "Menos asientos",
       "picker.filterAndFocusByPrice": "Filtrar y enfocar asientos por precio",
-      "picker.filteredSeat": "No disponible con los filtros actuales",
-      "picker.filteredSeatExplanation": "Cambia el filtro de precio o vista activo para poder seleccionar este asiento.",
       "picker.filters": "Filtros",
       "picker.findBestSeatsCount.one": "Buscar {count} mejor asiento",
       "picker.findBestSeatsCount.other": "Buscar {count} mejores asientos",
@@ -344,6 +344,8 @@ var init_de = __esm({
       "picker.poweredBy": "Bereitgestellt von SeatLayer",
       "picker.testMode": "TESTMODUS",
       "picker.orphanHint": "Dadurch bleibt ein einzelner Platz \xFCbrig \u2014 r\xFCcken Sie ggf. einen Platz weiter.",
+      "picker.companionRequiresWheelchair": "Benachbarter Rollstuhlplatz erforderlich",
+      "picker.companionPairRequired": "W\xE4hlen Sie zu jedem Begleitticket den benachbarten Rollstuhlplatz aus.",
       // renderer (drawn on the Konva map — shared by the embed SDK)
       "map.aria": "Sitzplan. Mit Pfeiltasten zwischen Pl\xE4tzen navigieren, Eingabe zum Ausw\xE4hlen.",
       "map.seatsLeft": "{count} FREI",
@@ -455,8 +457,6 @@ var init_de = __esm({
       "picker.fewerGuests": "Weniger G\xE4ste",
       "picker.fewerSeats": "Weniger Pl\xE4tze",
       "picker.filterAndFocusByPrice": "Pl\xE4tze nach Preis filtern und fokussieren",
-      "picker.filteredSeat": "Mit aktuellen Filtern nicht verf\xFCgbar",
-      "picker.filteredSeatExplanation": "\xC4ndern Sie den aktiven Preis- oder Ansichtsfilter, um diesen Platz ausw\xE4hlbar zu machen.",
       "picker.filters": "Filter",
       "picker.findBestSeatsCount.one": "{count} besten Platz finden",
       "picker.findBestSeatsCount.other": "{count} beste Pl\xE4tze finden",
@@ -643,6 +643,8 @@ var init_fr = __esm({
       "picker.poweredBy": "Propuls\xE9 par SeatLayer",
       "picker.testMode": "MODE TEST",
       "picker.orphanHint": "Cela laisse un si\xE8ge isol\xE9 \u2014 pensez \xE0 vous d\xE9caler d'un si\xE8ge.",
+      "picker.companionRequiresWheelchair": "N\xE9cessite la place fauteuil roulant adjacente",
+      "picker.companionPairRequired": "S\xE9lectionnez la place fauteuil roulant adjacente avec chaque billet accompagnateur.",
       // renderer (drawn on the Konva map — shared by the embed SDK)
       "map.aria": "Plan de salle. Utilisez les fl\xE8ches pour naviguer entre les si\xE8ges, Entr\xE9e pour s\xE9lectionner.",
       "map.seatsLeft": "{count} LIBRES",
@@ -754,8 +756,6 @@ var init_fr = __esm({
       "picker.fewerGuests": "Moins d\u2019invit\xE9s",
       "picker.fewerSeats": "Moins de places",
       "picker.filterAndFocusByPrice": "Filtrer et cibler les places par prix",
-      "picker.filteredSeat": "Indisponible avec les filtres actuels",
-      "picker.filteredSeatExplanation": "Modifiez le filtre de prix ou de vue actif pour rendre cette place s\xE9lectionnable.",
       "picker.filters": "Filtres",
       "picker.findBestSeatsCount.one": "Trouver {count} meilleure place",
       "picker.findBestSeatsCount.other": "Trouver {count} meilleures places",
@@ -935,6 +935,7 @@ __export(index_exports, {
   MAX_EVENT_INVENTORY: () => MAX_EVENT_INVENTORY,
   MAX_GA_CAPACITY: () => MAX_GA_CAPACITY,
   PickerController: () => PickerController,
+  PickerSelectionError: () => PickerSelectionError,
   RENDERED_QUALITY_REPORT_VERSION: () => RENDERED_QUALITY_REPORT_VERSION,
   SEAT_COMMERCIAL_MARKS: () => SEAT_COMMERCIAL_MARKS,
   SUPPORTED_LOCALES: () => SUPPORTED_LOCALES,
@@ -958,6 +959,7 @@ __export(index_exports, {
   expandTable: () => expandTable,
   expandTableSlots: () => expandTableSlots,
   floorObjects: () => floorObjects,
+  floorOverviewTranslations: () => floorOverviewTranslations,
   floorsOf: () => floorsOf,
   formatDate: () => formatDate,
   formatMinor: () => formatMinor,
@@ -976,6 +978,7 @@ __export(index_exports, {
   isGaUnitLabel: () => isGaUnitLabel,
   isSectionHidden: () => isSectionHidden,
   layerOf: () => layerOf,
+  layoutFloorOverview: () => layoutFloorOverview,
   loadLocale: () => loadLocale,
   objectCenter: () => objectCenter,
   owningSectionForObject: () => owningSectionForObject,
@@ -995,6 +998,7 @@ __export(index_exports, {
   tCount: () => tCount,
   tableInventoryCount: () => tableInventoryCount,
   tableSeatCountsBySide: () => tableSeatCountsBySide,
+  translateObject: () => translateObject,
   validGAInventorySegments: () => validGAInventorySegments
 });
 module.exports = __toCommonJS(index_exports);
@@ -1345,7 +1349,7 @@ function resolveSegmentedRowGroups(objects) {
     const expectedCount = ordered[0]?.segmentedRow?.componentCount ?? 0;
     const first = ordered[0]?.segmentedRow;
     if (!first) continue;
-    const valid = expectedCount >= 2 && ordered.length === expectedCount && first?.boundaryBefore === "start" && ordered.every((row, index) => row.segmentedRow?.kind === "segmented-row-v1" && row.segmentedRow.groupId === groupId && row.segmentedRow.componentCount === expectedCount && row.segmentedRow.componentIndex === index && (index === 0 ? row.segmentedRow.boundaryBefore === "start" : row.segmentedRow.boundaryBefore !== "start") && row.segmentedRow.displayLabel === first.displayLabel);
+    const valid = expectedCount >= 2 && ordered.length === expectedCount && first?.boundaryBefore === "start" && ordered.every((row, index) => row.segmentedRow?.kind === "segmented-row-v1" && row.segmentedRow.groupId === groupId && row.segmentedRow.componentCount === expectedCount && row.segmentedRow.componentIndex === index && row.segmentedRow.repeatLabelOnComponents === first.repeatLabelOnComponents && (index === 0 ? row.segmentedRow.boundaryBefore === "start" : row.segmentedRow.boundaryBefore !== "start") && row.segmentedRow.displayLabel === first.displayLabel);
     if (!valid) continue;
     const totalSeats = ordered.reduce((sum, row) => sum + row.seatCount, 0);
     let adjacencyOffset = 0;
@@ -2239,6 +2243,75 @@ function stackFloors(doc, spread = 900) {
   });
   return { ...doc, objects, floors: void 0 };
 }
+function layoutFloorOverview(doc) {
+  const floors = doc.floors;
+  if (!floors || floors.length < 2) return doc;
+  const translations = floorOverviewTranslations(doc);
+  const objects = [];
+  floors.forEach((floor, index) => {
+    const { x: dx, y: dy } = translations[index];
+    for (const object of floor.objects) objects.push(translateObject(object, dx, dy));
+  });
+  return {
+    ...doc,
+    objects,
+    floors: void 0,
+    referenceImage: void 0,
+    backgroundImage: void 0
+  };
+}
+function floorOverviewTranslations(doc) {
+  const floors = doc.floors;
+  if (!floors?.length) return [{ x: 0, y: 0 }];
+  if (floors.length < 2) return floors.map(() => ({ x: 0, y: 0 }));
+  const bounds2 = floors.map((floor) => chartBounds({
+    ...doc,
+    objects: floor.objects,
+    floors: void 0,
+    focalPoint: floor.focalPoint,
+    referenceImage: void 0,
+    backgroundImage: void 0
+  }));
+  const characteristic = Math.max(1, ...bounds2.map((bound) => Math.max(bound.width, bound.height)));
+  const gap = Math.max(64, Math.min(240, characteristic * 0.08));
+  const targetAspect = 16 / 10;
+  let best = null;
+  for (let columns2 = 1; columns2 <= floors.length; columns2 += 1) {
+    const rows = Math.ceil(floors.length / columns2);
+    const columnWidths2 = new Array(columns2).fill(0);
+    const rowHeights2 = new Array(rows).fill(0);
+    bounds2.forEach((bound, index) => {
+      const column = index % columns2;
+      const row = Math.floor(index / columns2);
+      columnWidths2[column] = Math.max(columnWidths2[column], bound.width);
+      rowHeights2[row] = Math.max(rowHeights2[row], bound.height);
+    });
+    const width = columnWidths2.reduce((sum, value) => sum + value, 0) + gap * (columns2 - 1);
+    const height = rowHeights2.reduce((sum, value) => sum + value, 0) + gap * (rows - 1);
+    const unusedCells = columns2 * rows - floors.length;
+    const score = Math.abs(Math.log(width / Math.max(1, height) / targetAspect)) + unusedCells * 0.04;
+    if (!best || score < best.score) best = { columns: columns2, columnWidths: columnWidths2, rowHeights: rowHeights2, score };
+  }
+  const { columns, columnWidths, rowHeights } = best;
+  const columnOffsets = [];
+  const rowOffsets = [];
+  columnWidths.reduce((offset, width, index) => {
+    columnOffsets[index] = offset;
+    return offset + width + gap;
+  }, 0);
+  rowHeights.reduce((offset, height, index) => {
+    rowOffsets[index] = offset;
+    return offset + height + gap;
+  }, 0);
+  return floors.map((_floor, index) => {
+    const bound = bounds2[index];
+    const column = index % columns;
+    const row = Math.floor(index / columns);
+    const targetX = columnOffsets[column] + (columnWidths[column] - bound.width) / 2;
+    const targetY = rowOffsets[row] + (rowHeights[row] - bound.height) / 2;
+    return { x: targetX - bound.x, y: targetY - bound.y };
+  });
+}
 function expandFloorObjects(objects, zones, fallbackFocal, activeConfigurationId, viewFallback, confidenceFallback) {
   const out = [];
   const segmented = resolveSegmentedRowGroups(objects);
@@ -3697,6 +3770,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",
@@ -3808,8 +3883,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",
@@ -4045,10 +4118,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;
@@ -4444,6 +4518,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). */
@@ -4699,6 +4775,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;
@@ -4717,6 +4794,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),
@@ -4837,13 +4915,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;
@@ -4941,7 +5029,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);
@@ -4962,14 +5050,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),
@@ -5002,14 +5097,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). */
@@ -5468,6 +5579,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({
@@ -5477,6 +5595,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);
@@ -6567,8 +6697,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;
@@ -6577,7 +6708,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() {
@@ -6715,6 +6863,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;
@@ -7483,7 +7669,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;
@@ -7682,6 +7876,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
@@ -7906,7 +8108,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)));
       }
@@ -7918,11 +8121,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 import_Text.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);
@@ -7933,7 +8202,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,
@@ -7946,7 +8215,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);
@@ -8021,6 +8290,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);
@@ -8037,8 +8307,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;
@@ -8436,6 +8707,28 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         ...hiddenReason ? { hiddenReason } : {}
       };
     });
+    const rowLabels = this.labelGroup.find((node) => node.getAttr("rowLabel") === true).filter((node) => node instanceof import_Text.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())
@@ -8480,7 +8773,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       labels,
       gaAreas,
       hierarchyLabels,
-      freeTextLabels
+      freeTextLabels,
+      rowLabels
     };
   }
   /** Jump the camera to a rung's zoom band (glided). */
@@ -8492,7 +8786,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();
@@ -8779,14 +9073,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
@@ -8796,18 +9101,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];
@@ -8822,6 +9134,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,
@@ -8830,6 +9146,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         fontSize,
         ink,
         opacity,
+        ...focusKeys?.length ? { focusKeys } : {},
         ...automaticAway ? { automaticAway } : {}
       });
       if (presentation?.position) {
@@ -8849,6 +9166,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) {
@@ -8925,12 +9254,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;
@@ -9021,13 +9346,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 import_Text.Text({
         x: rl.x,
         y: rl.y,
         text: rl.text,
-        fontSize: rl.fontSize,
+        fontSize: renderedFontSize,
         fontStyle: "700",
         fontFamily: this.labelFont(),
         fill: rl.ink,
@@ -9056,7 +9384,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) => {
@@ -9214,6 +9542,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) {
@@ -9268,6 +9689,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;
@@ -9397,7 +9827,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);
@@ -9409,7 +9841,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.
@@ -9484,16 +9918,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,
@@ -9558,13 +9998,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);
@@ -9585,6 +10028,7 @@ var PickerController = class {
       onDeckTap: (floorId) => this.handleDeckTap(floorId),
       onFps: this.opts.onFps
     });
+    profile.createRenderer = duration(rendererStartedAt);
     if (this.closed) {
       renderer.destroy();
       return null;
@@ -9593,6 +10037,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 ?? []);
@@ -9601,18 +10046,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,
@@ -9623,7 +10080,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 ------------------------------------------------------------
@@ -9679,11 +10137,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]);
@@ -9751,6 +10221,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));
@@ -9832,6 +10309,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) => {
@@ -10003,6 +10482,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);
@@ -10084,6 +10564,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)) {
@@ -10210,6 +10692,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);
   }
@@ -10222,6 +10718,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 };
   }
@@ -10251,7 +10752,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();
@@ -10267,12 +10769,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();
@@ -10341,10 +10855,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?.();
@@ -10397,15 +10931,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 {
@@ -10415,8 +10955,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
     };
   }
@@ -10457,11 +10997,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,
@@ -10469,6 +11010,7 @@ var PickerController = class {
       ...context,
       categoryKey: s.categoryKey,
       price: chosen.price,
+      currency: this.currency,
       tiers,
       tierId: chosen.id,
       ...commercial,
@@ -10478,8 +11020,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,
@@ -10490,6 +11033,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,
@@ -10519,6 +11063,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.
@@ -10528,7 +11093,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);
@@ -10549,6 +11114,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
@@ -10559,6 +11134,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) {
@@ -10680,6 +11261,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?.();
   }
@@ -12065,6 +12648,7 @@ async function loadLocale(code) {
   MAX_EVENT_INVENTORY,
   MAX_GA_CAPACITY,
   PickerController,
+  PickerSelectionError,
   RENDERED_QUALITY_REPORT_VERSION,
   SEAT_COMMERCIAL_MARKS,
   SUPPORTED_LOCALES,
@@ -12088,6 +12672,7 @@ async function loadLocale(code) {
   expandTable,
   expandTableSlots,
   floorObjects,
+  floorOverviewTranslations,
   floorsOf,
   formatDate,
   formatMinor,
@@ -12106,6 +12691,7 @@ async function loadLocale(code) {
   isGaUnitLabel,
   isSectionHidden,
   layerOf,
+  layoutFloorOverview,
   loadLocale,
   objectCenter,
   owningSectionForObject,
@@ -12125,6 +12711,7 @@ async function loadLocale(code) {
   tCount,
   tableInventoryCount,
   tableSeatCountsBySide,
+  translateObject,
   validGAInventorySegments
 });
 //# sourceMappingURL=index.cjs.map