@seatlayer/core 0.68.1 → 0.70.0

package/dist/index.d.ts

@@ -1,15 +1,15 @@
-import { C as ChartDoc, P as Point, A as AccessibilityType, m as CategoryTier, g as SeatCommercialAttributes } from './types-BjTzKc2D.js';
-export { v as ACCESSIBILITY_RING_COLOR, w as ACCESSIBILITY_TYPES, x as AccessibilityMeta, y as AuthoringObjectState, B as BoothObject, o as Category, z as ChartLayoutConstraint, d as ChartObject, n as ChartReferenceImage, D as ChartTheme, E as ConfidenceEvidenceScope, t as CubicPath, H as DecorImageObject, F as Floor, G as GAAreaObject, l as GAInventorySegment, I as LABEL_STYLE_MAX_SIZE, J as LABEL_STYLE_MIN_SIZE, K as LabelPresentation, L as LabelStyle, O as ObjectEditorState, M as Physical3dEvidence, N as RadialClearanceLayoutConstraint, f as RectTableSeatCounts, c as RectTableSide, Q as ReferenceAccessibilitySource, U as ReferenceCalibration, V as ReferenceCategorySource, W as ReferenceDerivedScale, X as ReferenceEnrichmentStatus, Y as ReferenceExtractEmptyReason, Z as ReferenceExtractEnrichment, _ as ReferenceExtractInput, $ as ReferenceExtractProposal, a0 as ReferenceExtractRegionSeats, a1 as ReferenceInventoryExclusionSource, a2 as ReferenceInventorySource, a3 as ReferenceMatchReport, a4 as ReferenceScanProposal, a5 as ReferenceScanRowProposal, a6 as ReferenceScanSectionProposal, a7 as ReferenceSeatSeed, a8 as ReferenceSectionTraceBatchInput, a9 as ReferenceSectionTraceBatchProposal, aa as ReferenceSectionTraceInput, ab as ReferenceSectionTraceProposal, h as ResolvedSeatConfidenceEvidence, R as RowObject, ac as SEAT_COMMERCIAL_MARKS, ad as SURROUNDINGS_SHAPE_ROLES, ae as SeatCommercialMark, af as SeatCommercialMeta, ag as SeatConfidenceCoverage, ah as SeatConfidenceEvidence, ai as SeatConfidenceModelLevel, aj as SeatConfidenceModeledTarget, ak as SeatConfidenceRealityLevel, a as SeatGlyphKind, S as SeatOverride, i as SeatViewCoverage, b as SeatViewMetadata, al as SeatViewVariant, e as SectionObject, j as SectionOutlinePath, k as SectionPathSegment, am as SelectionLayer, p as ShapeLineCap, q as ShapeLineEnding, r as ShapeLineJoin, s as ShapeObject, T as TableObject, an as TextAlignment, ao as TextBackground, u as TextObject, ap as TicketTierApplicability, aq as TicketTierEvidence, ar as TicketTierRestriction, as as Venue3DMaterialPalette, at as VenueSurveyRegistrationEvidence, au as ZoneDef, av as accessibilityMeta, aw as accessibilityRingColor, ax as layerOf, ay as seatCommercialMeta } from './types-BjTzKc2D.js';
-import { E as EventConfigurationRef, a as EventConfigurationVersion } from './eventConfigurations-kZpADDdx.js';
-export { b as EVENT_CONFIGURATION_EXPORT_SCHEMA, c as EVENT_CONFIGURATION_SCHEMA, d as EventConfigurationBaseVenue, e as EventConfigurationCompatibilityIssue, f as EventConfigurationCompatibilityIssueCode, g as EventConfigurationCompatibilityResult, h as EventConfigurationExportEnvelope, i as EventConfigurationLifecycleStatus, j as EventConfigurationOcclusion, k as EventConfigurationOverlay, l as EventConfigurationParseIssue, m as EventConfigurationParseIssueCode, n as EventConfigurationParseResult, o as EventConfigurationProductionElement, p as EventConfigurationProductionElementKind, q as EventConfigurationVenueSnapshot, r as EventConfigurationVersionParseResult, s as EventConfigurationVersionSummary, L as LegacyEventConfigurationMigrationResult, t as canTransitionEventConfiguration, u as canonicalEventConfigurationJson, v as inspectEventConfigurationCompatibility, w as migrateLegacyEventConfigurations, x as parseEventConfigurationExport, y as parseEventConfigurationVersion, z as resolveEventConfigurationRollback } from './eventConfigurations-kZpADDdx.js';
-export { E as ExpandChartOptions, R as RowSeatSlot, T as TABLE_SEAT_OFFSET, a as TableSeatSlot, b as allObjects, c as chartBounds, e as expandBooth, d as expandChart, f as expandRow, g as expandRowSlots, h as expandTable, i as expandTableSlots, j as floorObjects, k as floorOverviewTranslations, l as floorsOf, m as floorsShareFootprint, n as layoutFloorOverview, o as layoutFloorRings, p as objectCenter, q as owningSectionForObject, r as pointInPolygon, s as pointInPolygonWithHoles, t as polygonLabelPoint, u as rowInventoryCount, v as rowSeatPositions, w as stackFloors, x as tableInventoryCount, y as tableSeatCountsBySide, z as translateObject } from './layout-BdeBpWf8.js';
-import { c as TicketSelectionIssue } from './ticketRestrictions-CtgOd-2p.js';
-export { M as MAX_EVENT_INVENTORY, a as MAX_GA_CAPACITY, g as gaAreasOf, h as gaInventorySegments, i as gaUnitLabel, j as gaUnitLabels, k as growJoinedGAInventory, l as isGaUnitLabel, v as validGAInventorySegments } from './ticketRestrictions-CtgOd-2p.js';
-export { A as AvailabilityRule, S as SectionNode, T as TIER_HEIGHT_M, U as UNGROUPED_ID, a as applyHidden, c as computeSections, h as hiddenObjectIds, i as isSectionHidden, s as sectionGeometry } from './sections-DCRfHaw4.js';
-export { R as RENDERED_QUALITY_REPORT_VERSION, a as RenderedEvidenceState, b as RenderedQualityFinding, c as RenderedQualityFindingCode, d as RenderedQualityReport, e as RenderedQualitySample, i as inspectRenderedQualityEvidence } from './renderedQuality-Dn6GyPPj.js';
-import { I as ISeatmapRenderer, b as RendererOptions, S as SeatStatus, c as SeatMark, E as ExpandedSeat, G as GAAreaState, d as RendererViewMode, e as RendererMinimapSnapshot, L as LodRung, R as RendererQualityEvidence, f as RendererCallbacks } from './renderer-BGmZn_bq.js';
-export { C as CHART_STORAGE_KEY, g as RenderedBookableLabelEvidence, a as RenderedFreeTextEvidence, h as RenderedGAAreaEvidence, i as RenderedHierarchyLabelEvidence, j as RenderedLabelHiddenReason, k as RenderedRowLabelEvidence, l as RendererHoverDetails, m as RendererMinimapSeat, n as RendererMinimapSection, o as SeatMarkKind } from './renderer-BGmZn_bq.js';
-import './segmentedRowModel-DQggl3UO.js';
+import { C as ChartDoc, P as Point, A as AccessibilityType, m as CategoryTier, g as SeatCommercialAttributes } from './types-DNztpn7q.js';
+export { v as ACCESSIBILITY_RING_COLOR, w as ACCESSIBILITY_TYPES, x as AccessibilityMeta, y as AuthoringObjectState, B as BoothObject, o as Category, z as ChartLayoutConstraint, d as ChartObject, n as ChartReferenceImage, D as ChartTheme, E as ConfidenceEvidenceScope, t as CubicPath, H as DecorImageObject, F as Floor, G as GAAreaObject, l as GAInventorySegment, I as LABEL_STYLE_MAX_SIZE, J as LABEL_STYLE_MIN_SIZE, K as LabelPresentation, L as LabelStyle, O as ObjectEditorState, M as Physical3dEvidence, N as RadialClearanceLayoutConstraint, f as RectTableSeatCounts, c as RectTableSide, Q as ReferenceAccessibilitySource, U as ReferenceCalibration, V as ReferenceCategorySource, W as ReferenceDerivedScale, X as ReferenceEnrichmentStatus, Y as ReferenceExtractEmptyReason, Z as ReferenceExtractEnrichment, _ as ReferenceExtractInput, $ as ReferenceExtractProposal, a0 as ReferenceExtractRegionSeats, a1 as ReferenceInventoryExclusionSource, a2 as ReferenceInventorySource, a3 as ReferenceMatchReport, a4 as ReferenceScanProposal, a5 as ReferenceScanRowProposal, a6 as ReferenceScanSectionProposal, a7 as ReferenceSeatSeed, a8 as ReferenceSectionTraceBatchInput, a9 as ReferenceSectionTraceBatchProposal, aa as ReferenceSectionTraceInput, ab as ReferenceSectionTraceProposal, h as ResolvedSeatConfidenceEvidence, R as RowObject, ac as SEAT_COMMERCIAL_MARKS, ad as SURROUNDINGS_SHAPE_ROLES, ae as SeatCommercialMark, af as SeatCommercialMeta, ag as SeatConfidenceCoverage, ah as SeatConfidenceEvidence, ai as SeatConfidenceModelLevel, aj as SeatConfidenceModeledTarget, ak as SeatConfidenceRealityLevel, a as SeatGlyphKind, S as SeatOverride, i as SeatViewCoverage, b as SeatViewMetadata, al as SeatViewVariant, e as SectionObject, j as SectionOutlinePath, k as SectionPathSegment, am as SelectionLayer, p as ShapeLineCap, q as ShapeLineEnding, r as ShapeLineJoin, s as ShapeObject, T as TableObject, an as TextAlignment, ao as TextBackground, u as TextObject, ap as TicketTierApplicability, aq as TicketTierEvidence, ar as TicketTierRestriction, as as Venue3DMaterialPalette, at as VenueSurveyRegistrationEvidence, au as ZoneDef, av as accessibilityMeta, aw as accessibilityRingColor, ax as layerOf, ay as seatCommercialMeta } from './types-DNztpn7q.js';
+import { E as EventConfigurationRef, a as EventConfigurationVersion } from './eventConfigurations-CA2XhDig.js';
+export { b as EVENT_CONFIGURATION_EXPORT_SCHEMA, c as EVENT_CONFIGURATION_SCHEMA, d as EventConfigurationBaseVenue, e as EventConfigurationCompatibilityIssue, f as EventConfigurationCompatibilityIssueCode, g as EventConfigurationCompatibilityResult, h as EventConfigurationExportEnvelope, i as EventConfigurationLifecycleStatus, j as EventConfigurationOcclusion, k as EventConfigurationOverlay, l as EventConfigurationParseIssue, m as EventConfigurationParseIssueCode, n as EventConfigurationParseResult, o as EventConfigurationProductionElement, p as EventConfigurationProductionElementKind, q as EventConfigurationVenueSnapshot, r as EventConfigurationVersionParseResult, s as EventConfigurationVersionSummary, L as LegacyEventConfigurationMigrationResult, t as canTransitionEventConfiguration, u as canonicalEventConfigurationJson, v as inspectEventConfigurationCompatibility, w as migrateLegacyEventConfigurations, x as parseEventConfigurationExport, y as parseEventConfigurationVersion, z as resolveEventConfigurationRollback } from './eventConfigurations-CA2XhDig.js';
+export { C as ChartBoundsOptions, E as ExpandChartOptions, R as RowSeatSlot, T as TABLE_SEAT_OFFSET, a as TableSeatSlot, b as allObjects, c as chartBounds, e as expandBooth, d as expandChart, f as expandRow, g as expandRowSlots, h as expandTable, i as expandTableSlots, j as floorObjects, k as floorOverviewTranslations, l as floorsOf, m as floorsShareFootprint, n as layoutFloorOverview, o as layoutFloorRings, p as objectCenter, q as owningSectionForObject, r as pointInPolygon, s as pointInPolygonWithHoles, t as polygonLabelPoint, u as rowInventoryCount, v as rowSeatPositions, w as stackFloors, x as tableInventoryCount, y as tableSeatCountsBySide, z as translateObject } from './layout-C6YaCOnZ.js';
+import { c as TicketSelectionIssue } from './ticketRestrictions-B_qXQobd.js';
+export { M as MAX_EVENT_INVENTORY, a as MAX_GA_CAPACITY, g as gaAreasOf, h as gaInventorySegments, i as gaUnitLabel, j as gaUnitLabels, k as growJoinedGAInventory, l as isGaUnitLabel, v as validGAInventorySegments } from './ticketRestrictions-B_qXQobd.js';
+export { A as AvailabilityRule, S as SectionNode, T as TIER_HEIGHT_M, U as UNGROUPED_ID, a as applyHidden, c as computeSections, h as hiddenObjectIds, i as isSectionHidden, s as sectionGeometry } from './sections-87qiciyN.js';
+export { R as RENDERED_QUALITY_REPORT_VERSION, a as RenderedEvidenceState, b as RenderedQualityFinding, c as RenderedQualityFindingCode, d as RenderedQualityReport, e as RenderedQualitySample, i as inspectRenderedQualityEvidence } from './renderedQuality-CWwy14lb.js';
+import { I as ISeatmapRenderer, b as RendererOptions, S as SeatStatus, c as SeatMark, E as ExpandedSeat, G as GAAreaState, d as RendererViewMode, e as RendererMinimapSnapshot, L as LodRung, R as RendererQualityEvidence, f as RendererCallbacks } from './renderer-DIcDImOu.js';
+export { C as CHART_STORAGE_KEY, g as RenderedBookableLabelEvidence, a as RenderedFreeTextEvidence, h as RenderedGAAreaEvidence, i as RenderedHierarchyLabelEvidence, j as RenderedLabelHiddenReason, k as RenderedRowLabelEvidence, l as RendererHoverDetails, m as RendererMinimapSeat, n as RendererMinimapSection, o as SeatMarkKind } from './renderer-DIcDImOu.js';
+import './segmentedRowModel-CEP6crcl.js';
 
 declare class SeatmapRenderer implements ISeatmapRenderer {
     private container;
@@ -85,6 +85,10 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private selection;
     /** Seat-contained selection markers: outline + non-colour check cue. */
     private selectionMarkers;
+    /** Selection markers, the pick moment and the touch loupe — see seatMoments. */
+    private momentsCache;
+    /** Overview marks for the sections the buyer holds seats in — see ownedSections. */
+    private ownedCache;
     /** Held by this picker instance, not by another buyer. */
     private ownedHold;
     private seatMarks;
@@ -110,6 +114,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private commercialLimitedFilter;
     private sections;
     private zones;
+    /** World boxes of the fixed landmarks hierarchy chips must not sit on. */
+    private landmarkBoxes;
     private seatSection;
     /** Seats outside every authored section retain the legacy path in one group. */
     private unsectionedSeatGroup;
@@ -125,6 +131,10 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private closedSections;
     /** AXS section-focus: the currently-focused section id (others dim), or null. */
     private focusedSectionId;
+    /** Tap point the focus was entered on (replayed on a resize refit), and
+     *  whether a manual pan has since put the locator on the buyer's camera. */
+    private focusAnchor;
+    private focusRoams;
     /** Light backdrop panel drawn behind the focused section (removed on clear). */
     private focusBackdrop;
     /** Non-listening visual dim outside the focused section. One overlay replaces
@@ -174,9 +184,10 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private lodScale;
     /** prefers-reduced-motion → hard-swap rungs instead of cross-fading. */
     private reducedMotion;
-    /** Touch camera travel follows native mobile timing; desktop keeps the calmer glide. */
     private readonly cameraGlideMs;
     private fitScale;
+    /** Stage pose the last overview fit landed on — see zoomToFit. */
+    private fitPose;
     /** Effective seat radius (base × theme.seatScale), set per chart in setChart. */
     private seatR;
     private bounds;
@@ -187,10 +198,40 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private assetPromises;
     private assetErrors;
     private assetCancels;
+    /**
+     * Progressive reveal: what a big chart does instead of appearing all at once.
+     *
+     * Section shells paint with the chart doc; the seats then build a section at
+     * a time in idle slices, nearest the viewport first. Non-null only while that
+     * is in flight — every path that needs a complete scene right now (an export,
+     * a chart replacement, teardown) finishes or cancels it first.
+     */
+    private seatReveal;
+    /**
+     * True from the moment `setChart` decides to defer the seats until the last
+     * one has landed — which starts BEFORE `seatReveal` exists, because the
+     * schedule is only created after the fit, and the fit itself runs the LOD
+     * pass that would otherwise bake an empty seat layer into the overview.
+     */
+    private seatRevealPending;
+    /** Below this the whole scene is cheap enough to build in one step. */
+    private readonly progressiveSeatFloor;
+    private readonly loadingReveal;
+    /** Host callback for the moment the last section's seats finish arriving. */
+    private readonly onSeatsRevealed;
     private rafId;
-    private frames;
-    private lastFpsAt;
     private recacheTimer;
+    /**
+     * True between `setChart()` and the first overview bake of that chart.
+     *
+     * `setChart` → `zoomToFit` → `updateLOD` reaches the bake BEFORE the host has
+     * applied inventory; the picker then applies statuses and calls `forceDraw()`
+     * in the same task, throwing that bitmap away and building it again. Two full
+     * rasterizations of one chart for one paint — 19ms where 10 will do at 760
+     * seats. So the mount bake waits a tick: `forceDraw()` flushes it, and a host
+     * that never calls it bakes on the next tick instead.
+     */
+    private mountCachePending;
     private resizeObs;
     /** Coalesces bursty view-change sources (pointermove, wheel) into ≤1 callback/frame. */
     private viewChangeRaf;
@@ -205,6 +246,21 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private get moved();
     private isGhostClick;
     /** Behavioural surface the gesture machine calls back into. */
+    /**
+     * The overlay-layer moments (marker, pop/pulse, loupe). Built once and kept:
+     * a pointermove drives the loupe, and allocating a host per frame would be
+     * paid for on exactly the device that can least afford it.
+     */
+    private get moments();
+    /** The buyer's seats, still visible once the seats have melted into blocks. */
+    private get owned();
+    /**
+     * Where a tap on this section should land the camera: on the buyer's own
+     * seats when they have some in there, otherwise on the point they touched.
+     */
+    private sectionTapAnchor;
+    /** World points of the seats in this section the buyer has taken or holds. */
+    private ownedSeatPoints;
     private get pointerHost();
     /**
      * Manage-mode rubber-band marquee (option-gated). `start`/`cur` are WORLD-space
@@ -217,6 +273,36 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     setChart(doc: ChartDoc, opts?: {
         floorId?: string;
     }): void;
+    /**
+     * Should this chart's seats arrive a section at a time?
+     *
+     * Only when there are enough of them to be worth it, the host asked for it,
+     * and the scene is one a buyer will look at. An export renders once to a
+     * file: a reveal there would either be captured half-built or have to be
+     * finished synchronously anyway, which is the plain path with extra steps.
+     */
+    private seatRevealWanted;
+    /**
+     * Build the seats a section at a time, nearest the buyer first.
+     *
+     * Every seat's STATUS is already in `statusById` (setChart seeds it, and the
+     * controller's inventory apply writes it whether or not a node exists yet),
+     * and node construction paints from it — so a section built late arrives with
+     * the right colours and never needs a second pass. That is the whole reason
+     * inventory can land during the build without re-rasterizing anything.
+     */
+    private startSeatReveal;
+    /** Centre of what the buyer can currently see, in chart coordinates. */
+    private viewportCentreInChartSpace;
+    /**
+     * Complete an in-flight reveal NOW, synchronously.
+     *
+     * Anything that reads or replaces the whole scene — a chart swap, an export,
+     * quality evidence, teardown — must see every seat. The reveal is a way of
+     * spreading construction over time, never a scene that is allowed to stay
+     * incomplete.
+     */
+    private cancelSeatReveal;
     /** The chart to render: authored-coordinate overview, stacked 3D overview,
      *  the active floor, or the whole chart for single-floor charts. */
     private floorView;
@@ -290,13 +376,15 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * fire `onMarquee`. A near-zero drag reads as a click: clear the selection.
      */
     private finishMarquee;
+    /** Throw a ring off one seat — "this is the one" without moving the camera. */
     flashSeat(seatId: string, color?: string): void;
     /**
      * Pulse a section outline without moving the camera or mutating the authored
-     * geometry. The temporary halo is drawn in the non-listening overlay layer,
-     * so the apparent 4% lift never changes hit testing or selection bounds.
+     * geometry. The halo lives in the non-listening overlay layer, so its
+     * apparent 4% lift never changes hit testing or selection bounds.
      */
     flashSection(sectionId: string, color?: string): void;
+    private get flashHost();
     private onKeyDown;
     /** Nearest seat from `fromId` in a cardinal direction (aligned + close wins). */
     private nearestSeat;
@@ -351,12 +439,7 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /** Host-pushed GA availability / pending quantity — see {@link paintGAState}. */
     setGAStates(states: Record<string, GAAreaState>): void;
     setGAState(areaId: string, state: GAAreaState): void;
-    /** Frame the currently available inventory that survived a buyer price
-     *  filter. A category may span most of a venue, so framing only its bounds
-     *  can leave a phone at the section overview and make the price control look
-     *  inert. Narrow maps enter seat detail around an actual matching seat;
-     *  desktop retains the complete category frame. Clearing the filter glides
-     *  back to the full venue. */
+    /** Frame available inventory; narrow maps enter usable seat detail. */
     focusCategories(keys: string[] | null, opts?: {
         animate?: boolean;
     }): void;
@@ -406,6 +489,11 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /** Restore section-owned containers before applying another projection. */
     private resetSectionProjection;
     /** Node/cache context the shared seat-anchor pass reads and updates. */
+    /** Cached, unlike its siblings, because it holds only stable references and
+     *  no camera reading that could go stale; setChart (which reassigns `seats`)
+     *  drops it. It is also the hot one — `updateSeatGroupVisibility` builds it
+     *  per visible section on every pointermove of a perspective pan. */
+    private seatAnchorContextCache;
     private get seatAnchorContext();
     /** Move native seat/booth hit shapes to or from their exact pinhole anchors. */
     private applyExactSeatAnchors;
@@ -437,11 +525,18 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private seatContainer;
     /** True when a section belongs to the active logical section/zone focus. */
     private sectionMatchesFocus;
-    /** Visual opacity after the section-focus overlay is composed. */
+    /**
+     * Visual opacity after the section-focus overlay is composed.
+     *
+     * Gated on the dim ACTUALLY BEING ON SCREEN, not merely on a focus existing.
+     * releaseSectionFocusDim drops the overlay on the buyer's first pan — free
+     * roaming across sections is the product behaviour, the glide is only an
+     * entrance — and reporting a stale 0.16 after that told the label pass that
+     * every neighbouring seat was invisible. Pan from a focused Stalls F to
+     * Grand Circle and its seats lost their numbers (owner report 2026-08-27),
+     * at a zoom where they were fully bright on screen.
+     */
     private focusedSeatOpacity;
-    /** Project a section outline through elevation + the active affine view and
-     *  then into viewport pixels. The result is conservative (AABB), so a visible
-     *  section is never clipped even for rotated or isometric outlines. */
     private sectionScreenBounds;
     /** Hide only section groups wholly outside a padded viewport at the live-seat
      *  rung. Overview caching always restores all groups first, so panning a
@@ -461,9 +556,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      *  the small transient set aligned explicitly. Selection is capped in buyer
      *  mode, making this constant-sized work during the iso tween. */
     private syncSeatOverlayPositions;
+    /** Build every seat + booth node — see render/seatScene.ts. */
     private renderSeats;
-    /** A booth renders as a click-selectable rounded block (dims from the doc). */
-    private renderBoothUnit;
     /**
      * Build the centred accessibility glyph for a seat. Sized relative to the seat
      * radius (so it always fills the marker at any zoom) and given a contrast-aware
@@ -521,15 +615,13 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      */
     setClosedSections(ids: string[] | null): void;
     /**
-     * AXS section-focus: dim + desaturate every other section, draw a calm backdrop
-     * panel behind this section's seats, and glide the camera to a padded fit.
-     * Wide desktop maps retain the complete-section frame. A narrow phone crops
-     * a section that cannot reach seat detail as a whole, anchoring the entrance
-     * on a real available seat so the first tap exposes usable inventory.
+     * Focus one section; narrow phones enter at usable seat detail. `opts.anchor`
+     * is the world point the buyer tapped — when the phone entrance has to crop
+     * the section, it crops around THAT point instead of the viewport centre.
      */
-    focusSection(id: string): void;
-    /** Preserve the section-focus camera contract across the initial tap and a
-     * later host resize (for example when native ticket chrome expands). */
+    focusSection(id: string, opts?: {
+        anchor?: Point;
+    }): void;
     private focusSectionCamera;
     /**
      * Release only the focus dim + backdrop, keeping the focused-section state
@@ -544,13 +636,19 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     clearSectionFocus(): void;
     /** The currently AXS-focused section id, or null. */
     getFocusedSection(): string | null;
-    /** Draw (or replace) the light backdrop panel behind the focused section. */
+    /**
+     * Are seats what the buyer SEES (and therefore taps)? True inside a section
+     * focus and on a floor overview (the melt is forced off there), otherwise
+     * once the camera passes the half-melt point. The cache flag is a rendering
+     * strategy, not a visual state — never use it to route a tap.
+     */
+    seatsRevealed(): boolean;
+    /**
+     * Draw (or replace) the focus treatment: the light backdrop panel behind the
+     * focused section, and the dim that pushes the rest of the venue back.
+     */
     private drawFocusBackdrop;
-    /** Dim everything outside the active section with one paint-only shape. Group
-     *  opacity would make Konva recursively invalidate absolute-opacity caches on
-     *  all 14k descendants. The cut-out follows the live elevation offset and is
-     *  non-listening, so direct seat hit-testing is unchanged. */
-    private drawFocusDimOverlay;
+    private get focusBackdropHost();
     /** Repaint every seat + section block to reflect closed/focus state, then redraw. */
     private repaintSectionsAndSeats;
     /** The world-space rectangle currently visible in the viewport (minimap F3). */
@@ -612,14 +710,25 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private refreshSectionHeat;
     private refreshSectionFill;
     private isSectionClosed;
-    private sectionAvailabilityState;
-    private sectionBlockFill;
-    private get sectionLodPaintContext();
     /**
-     * Zone rung: one giant screen-constant label per zone (+ optional "FROM $n"),
-     * shown at the farthest zoom in place of per-section detail. Skipped entirely
-     * when the doc declares no zones — sections then stay the far rung (graceful).
+     * Display colour of the dominant SELLABLE category across these seats — the
+     * hue an overview block is tinted with. Ties break on the stable category key
+     * so the same chart always tints the same way. Null when nothing here is for
+     * sale: a block with no price keeps the neutral treatment.
      */
+    private dominantSellableColor;
+    /**
+     * Free seats in this section that satisfy the active accessibility filter.
+     *
+     * The count, not a boolean, because the block rung has two jobs for it: mark
+     * the sections that have anything at all, and tell the buyer how much. Zero
+     * when no filter is on — nothing at that rung asks the question then, and
+     * walking every section's members on every paint to answer an unasked
+     * question is exactly the per-frame cost this rung exists to avoid.
+     */
+    private sectionAccessibleFree;
+    private get sectionLodPaintContext();
+    /** Build the zone pills (name + FROM price) — see render/zoneScene.ts. */
     private renderZones;
     /**
      * Map a container-relative screen point back to world coords. Inverts the
@@ -635,6 +744,20 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /** Seat ids belonging to a section (Slice 5 section-summary card). */
     sectionMembers(id: string): string[];
     private isSelectable;
+    /**
+     * Is this seat out of the sale purely because the accessibility filter is on?
+     *
+     * The filter used to be paint only: non-matching seats dimmed to 25% and were
+     * still selectable, so a buyer who turned on "wheelchair-accessible seats"
+     * could — and did — pick a faded ordinary seat and never learn why the map
+     * looked odd. A filter that does not filter is a lie about the inventory.
+     *
+     * Kept separate from {@link isSelectable} because the answer is also the
+     * REASON: everything downstream (the tap explanation, the toast, best-seats)
+     * needs to distinguish "sold" from "you filtered this out", which is
+     * reversible by one tap.
+     */
+    private hiddenByAccessFilter;
     private toggleSeat;
     /**
      * Selection/hover ring color. An explicit theme.selectionColor always wins;
@@ -648,14 +771,16 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private resolveCanvasBackground;
     private resolveSelectionColor;
     private setSelected;
-    /** Rebuild one marker after selected/held/candidate state changes. */
+    /** Rebuild one seat's marker after selected/held/candidate state changes. */
     private syncSelectionMarker;
+    /** The buyer's own pick: pop the marker and throw a pulse ring out of it. */
+    private playSeatPickMoment;
+    /** A finger is on a seat — lift it out from under the fingertip, and back. */
+    private showTouchLoupe;
+    private hideTouchLoupe;
     /**
-     * The stage scale `focusRegion(id)` would settle at — i.e. the zoom that
-     * frames this section in the current viewport. Used to decide whether
-     * redirecting a seat tap to section-focus would actually zoom in FURTHER, or
-     * whether the section already fills the viewport (small container) so the tap
-     * must fall through and pick.
+     * The world rect that frames one whole section — outline, member seats,
+     * annotations, icons and placed row labels. See sectionCameraBounds.
      */
     private sectionBounds;
     private sectionFrameScale;
@@ -670,22 +795,12 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * fall through and PICK. This is the invariant: seats are never unpickable.
      */
     private handleSeatTap;
-    /**
-     * Nearest SELECTABLE seat whose centre is within `slopPx` (screen space) of a
-     * seat circle edge, or null. Enlarges the effective tap target for small seats
-     * so a near-miss on mobile still lands on the intended seat, without ever
-     * hijacking a clean tap on empty space beyond the slop.
-     */
+    /** Deck under the pointer in the 3D stacked overview — see screenPicking. */
+    private deckFloorAt;
+    /** Nearest selectable seat within `slopPx` of a screen point, or null. */
     private nearestSeatToScreen;
+    private get screenPickingHost();
     private wireInteraction;
-    /**
-     * Which deck (floor) a screen tap landed on in the 3D stacked overview. The
-     * seat layer is melt-cached at that zoom so individual seat nodes aren't
-     * hit-testable; instead we invert the iso+stage transform via the layer's
-     * relative pointer and take the nearest seat's floor. Only the floor matters,
-     * so within-floor elevation offsets don't affect the result. Null if none.
-     */
-    private deckFloorAt;
     /**
      * Min is chart-relative (never lose the room); max is absolute so seats
      * reach a readable size on any chart, however large the venue.
@@ -719,13 +834,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /** Explicit view of this renderer as the evidence pass's declared surface. */
     private get renderedQualityContext();
     getRenderedQualityEvidence(): RendererQualityEvidence;
-    /** Jump the camera to a rung's zoom band (glided). */
     setRung(rung: LodRung): void;
-    /** Minimum zoom at which seat markers and their labels are genuinely usable. */
     private seatRungScale;
-    /** On a phone, a wide ring/section can fit completely while its seats remain
-     * tiny. Crop that automatic entrance around a real matching seat; desktop
-     * keeps the full authored frame and manual pan/zoom remains unchanged. */
     private narrowSeatDetailFocus;
     /**
      * The seat rung must account for labels that auto-fit inside a seat circle.
@@ -737,6 +847,18 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private seatLabelTargetScale;
     /** Recompute LOD (cache/labels) after any pan/zoom settles. */
     private afterViewChange;
+    /**
+     * A camera move has FINISHED: drop any onViewChange scheduled from a frame
+     * the camera was merely passing through, and schedule exactly one from the
+     * settled state. Without it a backdrop tap (clearSectionFocus + zoomToFit)
+     * left the widget's deep state on the pre-settle reading — the map back at
+     * the overview, the chrome still saying the buyer was inside a section.
+     */
+    private settleView;
+    /** Once the buyer is roaming, the locator names what is ON SCREEN rather than
+     *  what they tapped — WITHOUT moving the camera. Retargeting is a
+     *  relabelling; a glide here would fight the pan that caused it. */
+    private retargetRoamingFocus;
     /** rAF-coalesced `onViewChange` — at most one host callback per animation frame. */
     private scheduleViewChange;
     /** Keep focal labels centred while their world font size tracks camera scale. */
@@ -746,21 +868,7 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      *  debounced cacheSeatLayer() and the synchronous forceDraw() catch-up. */
     private rebuildSeatCache;
     private cacheSeatLayer;
-    /**
-     * Drop the seat-layer overview bitmap while PRESERVING every descendant's
-     * cached local transform + clientRect.
-     *
-     * Konva's public `Layer.clearCache()` releases the bitmap and then runs a deep
-     * `_clearSelfAndDescendantCache()` that clears those caches on all 14k seat
-     * nodes. Recomputing them on the single frame the melt first reveals a section's
-     * live seats is the ~480ms first-drill stall (OV-80). A camera glide only marks
-     * each seat's ABSOLUTE_TRANSFORM dirty (recomputed lazily at ordinary pan cost)
-     * and never moves a seat's LOCAL transform, so the local caches stay valid —
-     * keeping them lets the first melt paint at pan cost, matching the ~17ms of
-     * every subsequent glide on the same section. Any edit that actually moves a
-     * seat invalidates its own transform cache through the attr setter, so only
-     * still-valid caches survive here.
-     */
+    /** See `render/seatLayerBitmap.releaseLayerBitmap` — NOT `clearCache()`. */
     private releaseSeatLayerBitmap;
     /**
      * SYNCHRONOUS repaint that bypasses requestAnimationFrame — see the
@@ -805,7 +913,6 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private updateLabels;
     private get viewportLabelContext();
     private handleResize;
-    private startFpsLoop;
 }
 declare function createRenderer(container: HTMLDivElement, opts?: RendererOptions): ISeatmapRenderer;
 
@@ -883,6 +990,17 @@ interface SeatHoverDetails extends PickerSeat {
     currency: string;
     /** Renderer mark (e.g. partly available across performances), when set. */
     mark?: SeatMark | null;
+    /** A deliberate press pins interactive details; hover remains preview-only. */
+    interaction?: 'hover' | 'press';
+    /**
+     * The press landed on a seat that cannot be taken (held by another buyer,
+     * sold, not for sale, filtered out). Touch has no hover, so this is how a
+     * finger gets the explanation a mouse gets for free.
+     */
+    unavailable?: boolean;
+    /** Unavailable ONLY because the buyer's accessibility filter is on — one tap
+     *  from being takeable again, so the host prompts rather than refuses. */
+    filteredOut?: boolean;
 }
 interface PickerGAArea {
     id: string;
@@ -949,6 +1067,12 @@ interface SectionSummary {
     color: string;
     /** Free member seats right now. */
     seatsLeft: number;
+    /**
+     * Free member seats matching the buyer's accessibility filter. Present ONLY
+     * while a filter is on — a card that always said "0 accessible" would report
+     * the filter's absence as an absence of provision.
+     */
+    accessibleLeft?: number;
     priceMin: number;
     priceMax: number;
     /** Per-category breakdown, cheapest first. */
@@ -1182,6 +1306,15 @@ interface PickerOptions extends PickerCallbacks {
     flashOnLiveChange?: boolean;
     /** Start in colorblind-safe rendering (Okabe-Ito hues + hollow booked seats). */
     colorblindSafe?: boolean;
+    /**
+     * How a big chart's seats arrive: 'progressive' (default) shows the venue's
+     * sections as soon as the chart doc lands and fills the seats in a section at
+     * a time, nearest the viewport first; 'plain' builds the whole scene in one
+     * step, as every chart used to.
+     */
+    loadingReveal?: 'progressive' | 'plain';
+    /** Every seat of a progressively revealed chart is now on screen. */
+    onSeatsRevealed?: () => void;
     /**
      * Keep painting seat-status deltas even while the tab is hidden/backgrounded.
      *
@@ -1235,6 +1368,19 @@ interface PickerRenderPerformanceProfile {
     firstPaint: number;
     startRealtime: number;
     controllerTotal: number;
+    /** Buyer chrome up with the loading skeleton in the map host. Widget-owned. */
+    skeletonPaint?: number;
+    /** Section shells on screen — the first frame that shows the actual venue. */
+    shellsPaint?: number;
+    /**
+     * Every seat on screen, measured from the same start as the rest.
+     *
+     * Filled in AFTER `render()` resolves, on the profile object it returned:
+     * a progressive reveal is by definition still finishing when the chart is
+     * usable, and pretending otherwise would be the number this whole change
+     * exists to stop reporting.
+     */
+    seatsComplete?: number;
 }
 /**
  * The subset of `ChartTheme` a HOST may override on the drawn canvas.
@@ -1573,7 +1719,19 @@ declare class PickerController {
         y: number;
     };
     setSelectionFocus(seatId: string | null): void;
+    /**
+     * The buyer's accessibility filter, remembered here as well as pushed at the
+     * renderer.
+     *
+     * The renderer owns the paint; the controller owns everything the paint is
+     * not — the section summaries the dock bar reads, best-available, and the
+     * host's own queries. Keeping a copy is what lets those answer the filter
+     * without reaching into the canvas for it.
+     */
+    private accessFilter;
     setAccessibilityFilter(types: string[] | null): void;
+    /** The buyer's active accessibility filter, or null. */
+    getAccessibilityFilter(): AccessibilityType[] | null;
     /**
      * "Hide limited-view seats" toggle — dims free seats flagged
      * restricted/obstructed view. Additive commercial parallel to the
@@ -1606,6 +1764,10 @@ declare class PickerController {
     /** The AXS-focused section id, or null — the widget shows its "−" (back a
      *  level) control whenever a focus is active, not only at the seats rung. */
     getFocusedSection(): string | null;
+    /** Seats are the visible, tappable layer (focus, floor overview, or past the
+     *  half-melt scale). Drives the widget's "deep" state — the cache-based seats
+     *  rung flips at a scale where the chart still reads as section blocks. */
+    seatsRevealed(): boolean;
     /** Jump to a rung; ZONES clears any focused summary (back to overview). */
     setRung(rung: LodRung): void;
     /** Price-band filter (F4): dim free seats whose category is outside `keys`
@@ -1646,7 +1808,10 @@ declare class PickerController {
     /** Read-only browser-render evidence for parity/performance audit tooling. */
     getRenderedQualityEvidence(): RendererQualityEvidence | null;
     /** Glide in on a section and surface its summary (same path as a section tap). */
-    focusSection(id: string): void;
+    focusSection(id: string, anchor?: {
+        x: number;
+        y: number;
+    }): void;
     /** Live seat membership count used by buyer section-navigation controls. */
     getSectionSeatCount(id: string): number;
     /** Zoom back out to the whole chart and clear the section-summary card + focus. */
@@ -1656,14 +1821,14 @@ declare class PickerController {
      *  closed section is framed but never opens a buyer card. */
     private handleSectionTap;
     /**
-     * Build a section summary from the renderer's spatial membership: section +
-     * zone labels, live seats-left, price range, and the per-category breakdown.
+     * Build a section summary from the renderer's spatial membership. The
+     * derivation itself lives in pickerSectionSummary.ts — it reads nothing this
+     * object owns beyond four values, and this file is at its size cap.
      */
     private sectionSummary;
     destroy(): void;
     private toSeat;
     private toTableSeat;
-    /** Tooltip payload for a hovered seat — see PickerCallbacks.onSeatHover. */
     private describeSeat;
     private priceFor;
     private tiersFor;