@seatlayer/core 0.50.2 → 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",
@@ -1324,7 +1329,241 @@ var en = {
   "picker.premiumFallbackNote": "No premium block of {count} \u2014 showing best overall",
   "picker.loading3d": "Building the 3D venue\u2026",
   "picker.unavailable3d": "3D could not start. The seat map is still available.",
-  "picker.jumpToSection": "Jump to section"
+  "picker.jumpToSection": "Jump to section",
+  "picker.salesClosedPill": "Sales are closed",
+  "picker.salesClosedCopy": "Ticket sales for this event have ended.",
+  "picker.salesClosedCta": "Sales closed",
+  "picker.salesClosedToast": "Sales are closed for this event.",
+  "picker.holdReassurance": "Yours for {time} \u2014 you won\u2019t be charged yet.",
+  "picker.securingSeats": "Securing your seats\u2026",
+  "picker.openingCheckout": "Opening secure checkout\u2026",
+  "picker.peekSecured": "\u2713 {count} secured \xB7 {total} \u2014 you won\u2019t be charged yet",
+  "picker.priceHint": "Colours on the map are ticket types \u2014 tap one below to show just those seats.",
+  "picker.findTogetherInstead": "Find seats together instead",
+  "picker.keepMyPicks": "Keep my picks",
+  // picker widget — buyer-facing SeatPicker.ts strings (localization pass)
+  "picker.accessExpiredBody": "Sign in again, or reload the page, to keep browsing these seats. Anything you are already holding stays yours.",
+  "picker.accessExpiredTitle": "Your access session has ended",
+  "picker.accessInvalidBody": "You can still book anything shown as available. Contact whoever sent you here for access to the rest.",
+  "picker.accessInvalidTitle": "We couldn\u2019t verify your access",
+  "picker.accessPausedBody": "The organizer has paused this selection. Try again in a few minutes.",
+  "picker.accessPausedTitle": "These seats are on hold right now",
+  "picker.accessRetry": "Try again",
+  "picker.accessRevokedBody": "Ask whoever sent you here for a new link to keep booking these seats.",
+  "picker.accessRevokedTitle": "This access link is no longer active",
+  "picker.accessiblePhysicalSeat": "Accessible physical seat",
+  "picker.addTime": "Add time",
+  "picker.addingEllipsis": "Adding\u2026",
+  "picker.allLevels": "All levels",
+  "picker.allPlacesBookedTogether": "All {count} places are booked together as one exclusive table.",
+  "picker.allPrices": "All prices",
+  "picker.allSeats": "All seats",
+  "picker.allSetTitle": "You\u2019re all set",
+  "picker.anyTicketType": "Any ticket type",
+  "picker.anyVenueZone": "Any venue zone",
+  "picker.areas": "Areas",
+  "picker.available": "Available",
+  "picker.backToMap": "Back to map",
+  "picker.backToVenue": "Back to venue",
+  "picker.bestSeatsStar": "\u2726 Best seats",
+  "picker.booth": "Booth",
+  "picker.capacityGuests": "{count} guests",
+  "picker.change": "Change",
+  "picker.chartDerivedModel": "Chart-derived model",
+  "picker.chartDerivedSeatEye": "Live 3D \xB7 chart-derived seat-eye \xB7 not surveyed",
+  "picker.checkConnection": "Check your connection and try again.",
+  "picker.checkoutCouldNotBeOpened": "Checkout could not be opened. Your seats are still held \u2014 please try again.",
+  "picker.chooseAnotherToCompare": "Choose another seat to compare.",
+  "picker.chooseGuestsCopy": "Choose how many guests will sit together. This table is held exclusively for your party.",
+  "picker.chooseMinMaxGuests": "Choose {min}\u2013{max} guests",
+  "picker.clearSavedSeatComparison": "Clear saved seat comparison",
+  "picker.close": "Close",
+  "picker.closeSeatStatus": "Close seat status",
+  "picker.closestGroupChosenInstantly": "Closest available group, chosen instantly.",
+  "picker.collapseTicketPanel": "Collapse ticket panel",
+  "picker.compareCount": "Compare {count}",
+  "picker.compareWithSaved": "Compare with saved",
+  "picker.confirmOrCancelSeat": "Confirm or cancel this seat",
+  "picker.confirmSeatLabel": "Confirm seat {label}",
+  "picker.confirmYourTable": "Confirm your table",
+  "picker.confirmedAndOnWay": "confirmed. A confirmation is on its way.",
+  "picker.continue": "Continue",
+  "picker.continueToCheckout": "Continue to checkout",
+  "picker.couldNotAddMoreTime": "Couldn\u2019t add more time \u2014 please head to checkout now.",
+  "picker.couldNotFindSeatsTogether": "We couldn\u2019t find {count} seats together. Try fewer seats or another ticket type.",
+  "picker.couldNotReleaseTickets": "Couldn\u2019t release your tickets. Your hold is unchanged.",
+  "picker.couldNotRemoveLabel": "Couldn\u2019t remove {label}. Your hold is unchanged.",
+  "picker.currentOffer": "Current offer",
+  "picker.currentTicketOffer": "Current ticket offer",
+  "picker.dragToLookAround": "Drag to look around \xB7 scroll to zoom",
+  "picker.emptyWheelchairSpace": "Empty wheelchair space",
+  "picker.exitFullScreen": "Exit full screen",
+  "picker.fewer": "Fewer",
+  "picker.fewerGuests": "Fewer guests",
+  "picker.fewerSeats": "Fewer seats",
+  "picker.filterAndFocusByPrice": "Filter and focus seats by price",
+  "picker.filters": "Filters",
+  "picker.findBestSeatsCount.one": "Find {count} best seat",
+  "picker.findBestSeatsCount.other": "Find {count} best seats",
+  "picker.findBestSeatsTogether": "Find the best seats together",
+  "picker.findNewSeats": "Find new seats",
+  "picker.findingBestSeats": "Finding the best seats\u2026",
+  "picker.findingEllipsis": "Finding\u2026",
+  "picker.fitToScreen": "Fit to screen",
+  "picker.flat2dMap": "Flat 2D map",
+  "picker.flexiblePartyTypeWord": "Flexible party \xB7 {typeWord}",
+  "picker.fullScreen": "Full screen",
+  "picker.generalAdmission": "General admission",
+  "picker.guestCountCouldNotBeSecured": "That guest count could not be secured. Your current table hold is unchanged.",
+  "picker.guestCountNoLongerAvailable": "That guest count is no longer available. Your current hold is unchanged.",
+  "picker.guests": "Guests",
+  "picker.guestsCount": "{count} guests",
+  "picker.guestsCountEdit": "{count} guests \xB7 Edit",
+  "picker.held": "Held",
+  "picker.heldForYou": "Held for you",
+  "picker.heldSeatExplanation": "Another buyer is holding this seat. It may become available again.",
+  "picker.heldTicketsReleased": "Held tickets released. Choose your new seats.",
+  "picker.heldTicketsRestored": "Your held tickets have been restored.",
+  "picker.hidePanel": "Hide panel",
+  "picker.hideTicketPanel": "Hide the ticket panel",
+  "picker.holdSeatsAndCheckout": "Hold seats & checkout",
+  "picker.howOfferWorks": "How the {name} offer works",
+  "picker.interactive3dVenueView": "Interactive 3D venue view",
+  "picker.keepMine": "Keep mine",
+  "picker.labelNoLongerAvailable": "{label} is no longer available.",
+  "picker.labelRemoved": "{label} removed.",
+  "picker.labelRemovedFromHold": "{label} removed from your hold.",
+  "picker.labelRestored": "{label} restored.",
+  "picker.labelsNoLongerAvailable.one": "{labels} is no longer available. Choose another seat.",
+  "picker.labelsNoLongerAvailable.other": "{labels} are no longer available. Choose another group.",
+  "picker.leftCount.one": "{count} left",
+  "picker.leftCount.other": "{count} left",
+  "picker.levelNumber": "Level {number}",
+  "picker.levels": "Levels",
+  "picker.liveAvailability": "Live availability \u2014 seats update in real time",
+  "picker.loadingSeatMap": "Loading seat map\u2026",
+  "picker.lookAroundLive3d": "Look around in live 3D",
+  "picker.manualTicketsRemovedNote": "Your manually selected tickets will be removed only after a new group is secured.",
+  "picker.map": "Map",
+  "picker.mapDidNotLoad": "The seat map didn\u2019t load",
+  "picker.maxTicketsForOrder": "You can select up to {count} tickets for this order.",
+  "picker.minToMaxGuests": "{min} to {max} guests",
+  "picker.more": "More",
+  "picker.moreGuests": "More guests",
+  "picker.moreSeats": "More seats",
+  "picker.moreSelectedCount": "{count} more selected",
+  "picker.moreTimeAdded": "More time added \u2014 your seats are still held.",
+  "picker.noAccessibilityMetadata": "No accessibility metadata supplied",
+  "picker.noAuthoredRestriction": "No organizer-authored restriction",
+  "picker.noSeatsSelected": "No seats selected",
+  "picker.notChargedYet": "You won\u2019t be charged yet.",
+  "picker.notForSale": "Not for sale",
+  "picker.notForSaleExplanation": "This seat is not included in the current sale.",
+  "picker.numberOfGuests": "Number of guests",
+  "picker.offerDetailActive": "This price applies automatically to eligible seats. Tickets in active carts temporarily reduce the available quantity; released or expired holds return it. When the offer ends, the next matching offer or normal ticket price takes over.",
+  "picker.offerDetailUpcoming": "Tickets are available at their normal price now. This scheduled offer will apply automatically to eligible seats when it starts.",
+  "picker.offerRemainingAvailable": "{count} available",
+  "picker.offerStarts": "starts {time}",
+  "picker.offerUntil": "until {time}",
+  "picker.oneSeatSaved": "1 seat saved",
+  "picker.oneSeatSavedChooseAnother": "One seat saved; choose another to compare",
+  "picker.openAuthored360": "Open venue 360\xB0",
+  "picker.openComparison": "Open comparison",
+  "picker.openComparisonOfSeats": "Open comparison of {count} seats",
+  "picker.openTicketPanel": "Open ticket panel",
+  "picker.peekFromPrice": "From {price}",
+  "picker.peekTicketsTotal.one": "{count} ticket \xB7 {total}",
+  "picker.peekTicketsTotal.other": "{count} tickets \xB7 {total}",
+  "picker.perGuestPrice": "{price} per guest",
+  "picker.pickYourSeats": "Pick your seats",
+  "picker.preferredTicketType": "Preferred ticket type",
+  "picker.preferredVenueZone": "Preferred venue zone",
+  "picker.priceNotSupplied": "Price not supplied",
+  "picker.releaseHeldTickets": "Release held tickets and choose different seats",
+  "picker.releasingEllipsis": "Releasing\u2026",
+  "picker.removeHeldTicketLabel": "Remove held ticket {label}",
+  "picker.removeSeatLabel": "Remove {label}",
+  "picker.removeTicketsUntilOrFewer": "Remove tickets until your order has {count} or fewer.",
+  "picker.replaceCurrentChoices": "Replace your current choices?",
+  "picker.review": "Review",
+  "picker.row": "Row",
+  "picker.rowLabel": "Row {label}",
+  "picker.saveToCompare": "Save to compare",
+  "picker.savedForComparison": "Saved for comparison",
+  "picker.savedSeatComparison": "Saved seat comparison",
+  "picker.scheduledOffer": "Scheduled offer",
+  "picker.seat": "Seat",
+  "picker.seatCount.one": "{count} seat",
+  "picker.seatCount.other": "{count} seats",
+  "picker.seatJustTakenByAnother": "Seat {label} was just taken by another buyer.",
+  "picker.seatLabel": "Seat {label}",
+  "picker.seatNoLongerAvailable": "That seat is no longer available.",
+  "picker.seatNoLongerYours": "Some seats are no longer available to you. They have been removed from your order.",
+  "picker.seatNumberLower": "seat {label}",
+  "picker.seatSalesClosedForEvent": "Seat sales have closed for this event.",
+  "picker.seatSelection": "Seat selection",
+  "picker.seatStatusLegend": "Seat status legend",
+  "picker.seatTaken": "Someone else took a seat you had picked. It has been removed from your order.",
+  "picker.seatsHeldForNeedMoreTime": "Your seats are held for <b>{time}</b>. Need more time?",
+  "picker.seatsJustTaken": "One or more seats were just taken. Please pick again.",
+  "picker.seatsJustTakenInCategory.one": "{count} seat just taken in {label} \xB7 {left} left",
+  "picker.seatsJustTakenInCategory.other": "{count} seats just taken in {label} \xB7 {left} left",
+  "picker.seatsNoLongerAvailableTryAnother": "Those seats are no longer available. Try another quantity or ticket type.",
+  "picker.seatsSecured": "Seats secured",
+  "picker.seatsSelectedCount.one": "{count} selected",
+  "picker.seatsSelectedCount.other": "{count} selected",
+  "picker.section": "Section",
+  "picker.secureMore": "Secure more",
+  "picker.secureMoreAndCheckout": "Secure {count} more & checkout",
+  "picker.securedCount": "{count} secured",
+  "picker.seeItIn3d": "See it in 3D",
+  "picker.select": "Select",
+  "picker.selectSeats": "Select seats",
+  "picker.selectTable": "Select table",
+  "picker.selectWholeTable": "Select whole table",
+  "picker.selected": "Selected",
+  "picker.selectingEllipsis": "Selecting\u2026",
+  "picker.showAllSeats": "Show all seats",
+  "picker.showAllTicketTypes": "Show all {count} ticket types",
+  "picker.showFewer": "Show fewer",
+  "picker.showLabelSeatsOnMap": "Show {label} seats on the map",
+  "picker.showTicketPanel": "Show the ticket panel",
+  "picker.sold": "Sold",
+  "picker.soldOutCopy": "No reserved seats are currently available for this event.",
+  "picker.soldOutEyebrow": "This event",
+  "picker.soldOutTitle": "Sold out",
+  "picker.soldSeatExplanation": "This seat has already been booked.",
+  "picker.statusAvailable": "available",
+  "picker.statusOnHold": "on hold",
+  "picker.statusTaken2": "taken",
+  "picker.table": "Table",
+  "picker.tableCapacity": "Table capacity",
+  "picker.tableUpdatedForGuests": "{label} updated for {count} guests.",
+  "picker.temporarilyHeld": "Temporarily held",
+  "picker.ticketPrices": "Ticket prices",
+  "picker.ticketTypeSoldOut": "That ticket type is sold out. Try another ticket type.",
+  "picker.tickets": "Tickets",
+  "picker.ticketsCount.one": "{count} ticket",
+  "picker.ticketsCount.other": "{count} tickets",
+  "picker.toggleColorblindColors": "Toggle colorblind-friendly colors",
+  "picker.total": "Total",
+  "picker.trayHintTapOrBest": "Tap a seat on the map, or let us pick the best available for you.",
+  "picker.trayHintTapOrStanding": "Tap a seat on the map \u2014 or grab standing tickets below.",
+  "picker.undo": "Undo",
+  "picker.upcomingTicketOffer": "Upcoming ticket offer",
+  "picker.updateTable": "Update table",
+  "picker.updatingEllipsis": "Updating\u2026",
+  "picker.venueView": "Venue view",
+  "picker.viewFromHere": "View from here",
+  "picker.viewFromThisSeat": "View from this seat",
+  "picker.wholeTypeWord": "Whole {typeWord}",
+  "picker.willChooseClosestGroup": "We\u2019ll choose the closest available group for you.",
+  "picker.willFindSeatsTogether": "We\u2019ll find {count} seats together.",
+  "picker.yourSeats": "Your seats",
+  "picker.zoomIn": "Zoom in",
+  "picker.zoomOut": "Zoom out",
+  "picker.closeVenueNav": "Close",
+  "picker.levelsAndAreas": "Levels & areas"
 };
 
 // src/i18n/index.ts
@@ -1398,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;
@@ -1797,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). */
@@ -2052,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;
@@ -2070,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),
@@ -2190,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;
@@ -2294,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);
@@ -2315,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),
@@ -2355,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). */
@@ -2821,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({
@@ -2830,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);
@@ -3920,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;
@@ -3930,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() {
@@ -4068,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;
@@ -4836,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;
@@ -4981,8 +5341,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
   fitSectionRungLabels(sec, sx) {
     const paddingPx = 8;
     sec.subLabelFits = false;
-    const maxPx = SECTION_LABEL_PX * sec.labelScale;
-    const minPx = MIN_SECTION_LABEL_PX * sec.labelScale;
+    const maxPx = SECTION_LABEL_PX * sec.labelScale * this.uiScale();
+    const minPx = Math.min(MIN_SECTION_LABEL_PX * sec.labelScale, maxPx);
     for (let fontPx = maxPx; fontPx >= minPx; fontPx -= 1) {
       for (const rotation of [0, -90]) {
         sec.nameLabel.rotation(rotation);
@@ -5008,13 +5368,24 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     sec.nameLabel.rotation(0);
     sec.nameLabelFits = false;
   }
+  /**
+   * Screen-constant chrome must still respect the screen it is constant on:
+   * an 18px zone cap sized for a 900px designer canvas eats a 360px phone map
+   * (owner report, 2026-08-14). Scales the fixed-px chrome down to 66% on the
+   * smallest containers; never up.
+   */
+  uiScale() {
+    const w = this.stage?.width() ?? 900;
+    return Math.min(1, Math.max(0.66, w / 900));
+  }
   /** Size one screen-constant zone name/price pill around its shared anchor. */
   sizeZonePill(zone, sx) {
-    const padX = 10 / sx;
-    const padY = 6 / sx;
-    const gap = zone.sub ? 3 / sx : 0;
-    this.sizeLabel(zone.label, ZONE_LABEL_PX / sx, zone.anchor.y);
-    if (zone.sub) this.sizeLabel(zone.sub, ZONE_SUB_PX / sx, zone.anchor.y);
+    const k = this.uiScale();
+    const padX = 10 * k / sx;
+    const padY = 6 * k / sx;
+    const gap = zone.sub ? 3 * k / sx : 0;
+    this.sizeLabel(zone.label, ZONE_LABEL_PX * k / sx, zone.anchor.y);
+    if (zone.sub) this.sizeLabel(zone.sub, ZONE_SUB_PX * k / sx, zone.anchor.y);
     const width = Math.max(zone.label.width(), zone.sub?.width() ?? 0) + padX * 2;
     const height = zone.label.height() + (zone.sub ? gap + zone.sub.height() : 0) + padY * 2;
     zone.label.y(zone.anchor.y - (zone.sub ? (gap + zone.sub.height()) / 2 : 0));
@@ -5022,8 +5393,16 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     zone.back.position(zone.anchor);
     zone.back.size({ width, height });
     zone.back.offset({ x: width / 2, y: height / 2 });
-    zone.back.cornerRadius(7 / sx);
+    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
@@ -5248,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)));
       }
@@ -5260,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);
@@ -5275,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,
@@ -5288,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);
@@ -5363,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);
@@ -5379,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;
@@ -5778,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())
@@ -5822,7 +6292,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       labels,
       gaAreas,
       hierarchyLabels,
-      freeTextLabels
+      freeTextLabels,
+      rowLabels
     };
   }
   /** Jump the camera to a rung's zoom band (glided). */
@@ -5834,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();
@@ -6121,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
@@ -6138,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];
@@ -6164,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,
@@ -6172,6 +6665,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         fontSize,
         ink,
         opacity,
+        ...focusKeys?.length ? { focusKeys } : {},
         ...automaticAway ? { automaticAway } : {}
       });
       if (presentation?.position) {
@@ -6191,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) {
@@ -6267,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;
@@ -6363,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,
@@ -6398,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) => {
@@ -6556,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) {
@@ -6610,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;
@@ -6739,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);
@@ -6751,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.
@@ -6826,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,
@@ -6900,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);
@@ -6927,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;
@@ -6935,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 ?? []);
@@ -6943,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,
@@ -6965,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 ------------------------------------------------------------
@@ -7021,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]);
@@ -7093,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));
@@ -7174,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) => {
@@ -7345,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);
@@ -7426,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)) {
@@ -7552,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);
   }
@@ -7564,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 };
   }
@@ -7593,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();
@@ -7609,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();
@@ -7683,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?.();
@@ -7739,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 {
@@ -7757,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
     };
   }
@@ -7799,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,
@@ -7811,6 +8529,7 @@ var PickerController = class {
       ...context,
       categoryKey: s.categoryKey,
       price: chosen.price,
+      currency: this.currency,
       tiers,
       tierId: chosen.id,
       ...commercial,
@@ -7820,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,
@@ -7832,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,
@@ -7861,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.
@@ -7870,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);
@@ -7891,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
@@ -7901,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) {
@@ -8022,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?.();
   }
@@ -9374,9 +10134,9 @@ function generateSeatThumb(seat, focalPoint, _neighborSeats) {
 
 // src/i18n/bundles.ts
 var LOADERS = {
-  es: () => import("./es-WEC5NHRT.js").then((m) => ({ default: m.es })),
-  de: () => import("./de-ST4H423D.js").then((m) => ({ default: m.de })),
-  fr: () => import("./fr-SGBFNAQV.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) {
@@ -9406,6 +10166,7 @@ export {
   MAX_EVENT_INVENTORY,
   MAX_GA_CAPACITY,
   PickerController,
+  PickerSelectionError,
   RENDERED_QUALITY_REPORT_VERSION,
   SEAT_COMMERCIAL_MARKS,
   SUPPORTED_LOCALES,
@@ -9429,6 +10190,7 @@ export {
   expandTable,
   expandTableSlots,
   floorObjects,
+  floorOverviewTranslations,
   floorsOf,
   formatDate,
   formatMinor,
@@ -9447,6 +10209,7 @@ export {
   isGaUnitLabel,
   isSectionHidden,
   layerOf,
+  layoutFloorOverview,
   loadLocale,
   objectCenter,
   owningSectionForObject,
@@ -9466,6 +10229,7 @@ export {
   tCount,
   tableInventoryCount,
   tableSeatCountsBySide,
+  translateObject,
   validGAInventorySegments
 };
 //# sourceMappingURL=index.js.map