@seatlayer/core 0.16.0 → 0.17.0

package/dist/index.d.ts

@@ -11,12 +11,44 @@ interface Point {
     x: number;
     y: number;
 }
+interface CubicPath {
+    start: Point;
+    control1: Point;
+    control2: Point;
+    end: Point;
+}
+/** A real closed section boundary. `outline` remains its sampled collision and
+ * persistence fallback; this path is the smooth authoring/buyer paint source. */
+type SectionPathSegment = {
+    kind: 'line';
+    end: Point;
+} | {
+    kind: 'arc';
+    center: Point;
+    radius: number;
+    clockwise: boolean;
+    end: Point;
+} | {
+    kind: 'bezier';
+    control1: Point;
+    control2: Point;
+    end: Point;
+};
+interface SectionOutlinePath {
+    version: 1;
+    closed: true;
+    start: Point;
+    segments: SectionPathSegment[];
+}
 interface Category {
     key: string;
     label: string;
     color: string;
     /** Base price — used when the category has no explicit tiers. */
     price?: number;
+    /** Durable evidence for semantic/display facts proposed while converting a
+     * private reference into sellable inventory. */
+    referenceCategorySource?: ReferenceCategorySource;
     /**
      * Ticket tiers (Adult / Child / Senior…). When present, a buyer picks a tier
      * per seat in this category and the tier's price applies; the first tier is the
@@ -25,6 +57,33 @@ interface Category {
      */
     tiers?: CategoryTier[];
 }
+interface ReferenceCategorySource {
+    assetId: string;
+    /** Original sampled section color. `Category.color` is the approved output
+     * color and may differ only with separately recorded evidence. */
+    sourceColor: string;
+    /** Every exact sampled color normalized into the same original 4-bit/channel
+     * segmentation class. Older documents may contain only `sourceColor`. */
+    sourceColors?: string[];
+    /** Logical sections whose generated inventory uses this category. */
+    logicalSectionIds?: string[];
+    /** Source-color grouping is deterministic; a semantic regrouping needs its
+     * own confirmed assignment evidence. */
+    assignmentDerivation?: 'source-color-class' | 'confirmed-logical-sections';
+    assignmentEvidence?: 'user-confirmed' | 'authoritative-source';
+    assignmentSourceDescription?: string;
+    /** Optional legend/commercial swatch stated by the source. This remains
+     * immutable provenance when the approved accessible output color differs. */
+    sourcePaletteColor?: string;
+    sourcePaletteColorEvidence?: 'user-confirmed' | 'authoritative-source';
+    sourcePaletteColorSourceDescription?: string;
+    labelEvidence: 'user-confirmed' | 'authoritative-source';
+    labelSourceDescription: string;
+    priceEvidence: 'user-confirmed' | 'authoritative-source';
+    priceSourceDescription: string;
+    outputColorEvidence?: 'user-confirmed' | 'authoritative-source';
+    outputColorSourceDescription?: string;
+}
 /** One ticket tier within a category: a named price (Adult, Child, Senior…). */
 interface CategoryTier {
     id: string;
@@ -111,7 +170,14 @@ interface RowObject {
     seatCount: number;
     /** Distance between adjacent seat centers, in chart units. */
     seatSpacing: number;
+    /** Optional exact cubic centreline. Normal code owns these coordinates and
+     * distributes seats by arc length; MCP/model inputs never submit them. */
+    path?: CubicPath;
     categoryKey: string;
+    /** Deterministic provenance for rows fitted from confirmed reference
+     * inventory. It enables revision-safe replacement without touching manually
+     * authored rows or accepting client coordinates. */
+    referenceInventorySource?: ReferenceInventorySource;
     /** First seat number (default 1). */
     seatLabelStart?: number;
     /** Seat numbering within the row (default ltr, step 1). */
@@ -141,8 +207,59 @@ interface GAAreaObject {
     label: string;
     /** Closed polygon, in chart units. */
     points: Point[];
+    /** Explicit aisles/pillars/cutouts excluded from the sellable GA surface. */
+    holes?: Point[][];
     capacity: number;
     categoryKey: string;
+    referenceInventorySource?: ReferenceInventorySource;
+}
+/**
+ * Durable evidence link for sellable objects generated from a private reference.
+ * The client supplies facts and stable logical-section ids, never coordinates.
+ */
+interface ReferenceAccessibilitySource {
+    placementDerivation: 'server-synthesized-row-edges';
+    groupLogicalSectionIds: string[];
+    assignmentEvidence: 'user-confirmed' | 'authoritative-source';
+    assignmentSourceDescription: string;
+    counts: Array<{
+        type: AccessibilityType;
+        count: number;
+        evidence: 'user-confirmed' | 'authoritative-source';
+        sourceDescription: string;
+    }>;
+}
+interface ReferenceInventorySource {
+    assetId: string;
+    logicalSectionId: string;
+    evidence: 'user-confirmed' | 'authoritative-source';
+    sourceDescription: string;
+    /** Distinguishes directly supplied inventory from a user-approved server
+     * distribution based only on an aggregate capacity. */
+    derivation?: 'explicit-inventory' | 'server-synthesized-from-aggregate';
+    /** Evidence for the aggregate figure; synthesized rows remain
+     * `user-confirmed` and are never mislabeled as source-extracted. */
+    aggregateEvidence?: 'user-confirmed' | 'authoritative-source';
+    /** Separate evidence for assigning standing inventory to this logical
+     * section. Aggregate evidence alone cannot prove section placement. */
+    sectionAssignmentEvidence?: 'user-confirmed' | 'authoritative-source';
+    sectionAssignmentSourceDescription?: string;
+    /** Aggregate row synthesis may propose numbering, but persistence requires
+     * the applying user/agent to confirm that policy explicitly. */
+    numberingEvidence?: 'user-confirmed';
+    numberingSourceDescription?: string;
+    /** Evidence and deterministic placement contract for synthesized accessible
+     * units in this logical section. */
+    accessibility?: ReferenceAccessibilitySource;
+}
+/** Durable evidence that a visible source-backed section shell intentionally
+ * carries no generated sellable inventory in this reference configuration. */
+interface ReferenceInventoryExclusionSource {
+    assetId: string;
+    logicalSectionId: string;
+    reason: string;
+    evidence: 'user-confirmed' | 'authoritative-source';
+    sourceDescription: string;
 }
 /** Non-bookable décor: stage, walls, exits. */
 interface ShapeObject {
@@ -198,6 +315,7 @@ interface TableObject {
     categoryKey: string;
     /** Whole-table booking: buyers get all seats or none (per-event override later). */
     bookAsWhole?: boolean;
+    referenceInventorySource?: ReferenceInventorySource;
 }
 /** A booth: one bookable unit rendered as a block (trade shows, VIP boxes). */
 interface BoothObject {
@@ -209,6 +327,7 @@ interface BoothObject {
     height: number;
     rotation: number;
     categoryKey: string;
+    referenceInventorySource?: ReferenceInventorySource;
 }
 /**
  * A named region of the venue (Balcony Left, Floor B…). Sections are outlines
@@ -221,8 +340,40 @@ interface SectionObject {
     type: 'section';
     id: string;
     label: string;
+    /**
+     * Stable management/inventory identity shared by disconnected visual
+     * components of one logical section. When absent, `id` is the logical id.
+     * Each component keeps its own `id` and reference provenance so rendering,
+     * editing, measured diffs, and source restoration remain exact.
+     */
+    logicalSectionId?: string;
     /** Closed polygon, chart units. */
     outline: Point[];
+    /** Optional true line/arc/cubic boundary. `outline` is a deterministic sample
+     * of this path and remains authoritative for membership, validation, and
+     * clients that predate curved section rendering. */
+    outlinePath?: SectionOutlinePath;
+    /** Explicit aisle/cutout polygons excluded from rendering, hit-testing, and membership. */
+    holes?: Point[][];
+    /** Durable opaque link to the private reference component. Unlike generator
+     * provenance, this survives manual geometry edits so a measured diff can
+     * report drift and server-owned code can restore the source contour. */
+    referenceSource?: {
+        assetId: string;
+        regionId: string;
+    };
+    /** Evidence-backed reason this source section remains a visible shell without
+     * synthesized sellable inventory (press, closed technical zone, etc.). */
+    referenceInventoryExclusion?: ReferenceInventoryExclusionSource;
+    /** Deterministic generator provenance for editable reference/parametric shells. */
+    geometry?: {
+        kind: 'rectangle' | 'tapered' | 'bezier' | 'contour';
+        sourceRegionId?: string;
+        contourMethod?: 'pixel-edge-loops-rdp' | 'shared-edge-vector-fit-v1';
+        simplificationTolerancePx?: number;
+        vectorFitErrorPx?: number;
+        sharedEdgeCount?: number;
+    };
     /** Optional tint override (defaults to a neutral fill / dominant category mix). */
     color?: string;
     /** Zone this section belongs to (id into `ChartDoc.zones`). Far-zoom nav + pricing group. */
@@ -306,6 +457,53 @@ interface Floor {
     focalPoint: Point;
     backgroundImage?: ChartDoc['backgroundImage'];
 }
+interface ReferenceCalibration {
+    type: 'two-point';
+    /** Points in immutable source-image pixels, selected by a human or trusted detector. */
+    sourceA: Point;
+    sourceB: Point;
+    /** Verified real-world distance between the two source points. */
+    distance: number;
+    unit: 'm' | 'ft' | 'chart-unit';
+    /** Derived and stored for deterministic geometry compilers. */
+    pixelsPerUnit: number;
+}
+/** Coordinate-free physical scale derived by server code from a confirmed
+ * semantic feature. Unlike manual two-point calibration, no source points pass
+ * through an MCP client or language model. */
+interface ReferenceDerivedScale {
+    method: 'confirmed-focal-axis-v1';
+    feature: 'focal-long-axis' | 'focal-short-axis';
+    distance: number;
+    unit: 'm' | 'ft';
+    evidence: 'user-confirmed' | 'authoritative-source';
+    sourceDescription: string;
+    chartUnitsPerUnit: number;
+}
+interface ChartReferenceImage {
+    /** Stable private reference asset. New cloud-authored charts use this. */
+    assetId?: string;
+    /** Legacy/self-contained source. Optional when assetId is present. */
+    url?: string;
+    center: Point;
+    /** Rendered width in chart units (height follows the cropped image aspect). */
+    width: number;
+    opacity: number;
+    rotation?: number;
+    visible?: boolean;
+    layer?: 'below' | 'above';
+    locked?: boolean;
+    /** Normalized source crop; defaults to the full image. */
+    crop?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    calibration?: ReferenceCalibration;
+    /** Server-derived semantic calibration without source-image coordinates. */
+    derivedScale?: ReferenceDerivedScale;
+}
 interface ChartDoc {
     version: 1;
     name: string;
@@ -322,14 +520,7 @@ interface ChartDoc {
     floors?: Floor[];
     objects: ChartObject[];
     /** Floor-plan photo the organizer traces over (designer-only aid, also rendered dimly in picker if kept). */
-    backgroundImage?: {
-        url: string;
-        center: Point;
-        /** Rendered width in chart units (height follows the image aspect). */
-        width: number;
-        opacity: number;
-        locked?: boolean;
-    };
+    backgroundImage?: ChartReferenceImage;
     /** Brand/venue theming (colors); categories carry their own colors separately. */
     theme?: ChartTheme;
     /** Parametric-template provenance: present ⇒ the chart came from a capacity-
@@ -362,6 +553,8 @@ type SeatStatus = 'free' | 'held' | 'booked' | 'not_for_sale';
 interface RendererCallbacks {
     onSelect?: (seat: ExpandedSeat) => void;
     onDeselect?: (seat: ExpandedSeat) => void;
+    /** Buyer tried to add a seat after the active selection cap was reached. */
+    onSelectionLimit?: (maxSelection: number) => void;
     /** seat is null when the pointer leaves any seat. */
     onHover?: (seat: ExpandedSeat | null) => void;
     /** Keyboard focus moved to a seat (arrow-key navigation) — for screen-reader announcements. */
@@ -425,6 +618,130 @@ interface RendererOptions extends RendererCallbacks {
      */
     marqueeSelect?: boolean;
 }
+type RenderedLabelHiddenReason = 'below-minimum-size' | 'outside-viewport' | 'dimmed-or-unavailable' | 'clutter-or-fit' | 'renderer-hidden';
+/** Browser-renderer evidence used by visual QA and catalog release gates. */
+interface RenderedBookableLabelEvidence {
+    seatId: string;
+    label: string;
+    kind: 'seat' | 'booth';
+    categoryKey: string;
+    sectionId?: string;
+    zoneId?: string;
+    status: SeatStatus;
+    selected: boolean;
+    visible: boolean;
+    renderedFontPx: number;
+    fill: string;
+    ink: string;
+    opacity: number;
+    /** Direct Konva shape bounds and the production near-miss rescue combined. */
+    pointerTarget: {
+        active: boolean;
+        directWidthPx: number;
+        directHeightPx: number;
+        effectiveMinimumPx: number;
+    };
+    /** Centre of the painted unit, even when its text is intentionally hidden. */
+    screenCenter: {
+        x: number;
+        y: number;
+    };
+    screenBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    hiddenReason?: RenderedLabelHiddenReason;
+}
+interface RenderedHierarchyLabelEvidence {
+    id: string;
+    kind: 'section' | 'zone';
+    role: 'name' | 'availability' | 'price';
+    label: string;
+    visible: boolean;
+    renderedFontPx: number;
+    opacity: number;
+    fill: string;
+    ink: string;
+    /** Independent geometric containment check for section-owned text. */
+    fitsContainer?: boolean;
+    screenBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+interface RenderedFreeTextEvidence {
+    objectId: string;
+    kind: 'free-text' | 'stage' | 'table' | 'decor' | 'ga-label' | 'ga-capacity';
+    text: string;
+    visible: boolean;
+    renderedFontPx: number;
+    ink: string;
+    background: string;
+    opacity: number;
+    screenBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    hiddenReason?: 'below-minimum-size' | 'outside-viewport' | 'renderer-hidden';
+}
+interface RenderedGAAreaEvidence {
+    areaId: string;
+    label: string;
+    capacity: number;
+    categoryKey: string;
+    /** Owning logical section when the rendered GA surface is section-contained. */
+    sectionId?: string;
+    visible: boolean;
+    interactive: boolean;
+    opacity: number;
+    fill: string;
+    effectiveBackground: string;
+    screenBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+interface RendererQualityEvidence {
+    viewport: {
+        width: number;
+        height: number;
+    };
+    canvasBackground: string;
+    effectiveScale: number;
+    rung: LodRung;
+    minimumVisibleLabelPx: number;
+    totalLabelledBookableUnits: number;
+    visibleLabels: number;
+    hiddenLabels: number;
+    /** Seats/table-seats/booths plus the full GA capacity. */
+    totalBookableUnits: number;
+    selectionRingSeatIds: string[];
+    selectionRingColor: string;
+    focusedSectionId: string | null;
+    focusBackdropVisible: boolean;
+    categoryFilterKeys: string[] | null;
+    /** Exact scene-graph proof for the clean section-first overview contract. */
+    overviewStyle: {
+        visibleSectionShells: number;
+        categoryPaintedSectionShells: number;
+        visibleCategoryDetailOutlines: number;
+        visibleSectionRowHints: number;
+        visibleSectionAvailabilityLabels: number;
+        visibleSectionGADetails: number;
+    };
+    labels: RenderedBookableLabelEvidence[];
+    gaAreas: RenderedGAAreaEvidence[];
+    hierarchyLabels: RenderedHierarchyLabelEvidence[];
+    freeTextLabels: RenderedFreeTextEvidence[];
+}
 interface ISeatmapRenderer {
     /** Replace the chart. Resets selection and statuses, zooms to fit.
      *  `opts.floorId` picks which floor to render on a multi-floor chart (Batch 5). */
@@ -461,6 +778,13 @@ interface ISeatmapRenderer {
     getStatus(seatId: string): SeatStatus;
     getSelection(): ExpandedSeat[];
     clearSelection(): void;
+    /** Update the buyer selection cap without rebuilding the chart or camera. */
+    setMaxSelection?(maxSelection: number): void;
+    /**
+     * Programmatically restore free seats (for example an Undo action). Added
+     * seats respect the active cap and do not reopen a confirmation popover.
+     */
+    select?(seatIds: string[]): ExpandedSeat[];
     /**
      * Dynamically update organizer-only interaction without rebuilding the
      * renderer. No buyer surface calls this; every behavior remains gated by
@@ -483,6 +807,8 @@ interface ISeatmapRenderer {
      */
     selectAllSelectable?(): ExpandedSeat[];
     selectByLabels?(labels: string[]): ExpandedSeat[];
+    /** Exact-render QA only: select one server-chosen unit without label ambiguity. */
+    setEvidenceSelection?(seatId: string): boolean;
     /** Selectable seats belonging to a section OR zone id (no selection side-effect). */
     getSelectableInSection?(sectionId: string): ExpandedSeat[];
     /** Programmatic deselect of specific seats (e.g. chip × in the cart). */
@@ -493,13 +819,21 @@ interface ISeatmapRenderer {
      * delta. Purely visual; no state change. `color` overrides the default.
      */
     flashSeat(seatId: string, color?: string): void;
+    /**
+     * Brief organizer attention pulse around a whole section. This is a visual
+     * overlay only: it never changes section geometry, hit targets, selection, or
+     * the active camera. Useful for grouped realtime operations at venue overview.
+     */
+    flashSection?(sectionId: string, color?: string): void;
     zoomToFit(): void;
     /** Zoom in one step about the viewport center, clamped to the usual zoom bounds. */
     zoomIn(): void;
     /** Zoom out one step about the viewport center, clamped to the usual zoom bounds. */
     zoomOut(): void;
-    /** Total seat count of the current chart. */
+    /** Individually status-managed seats/table-seats/booths; excludes GA capacity. */
     seatCount(): number;
+    /** Seats/table-seats/booths plus the full capacity of rendered GA areas. */
+    bookableCount(): number;
     /**
      * Maps a chart-space point (or a seat, by its x/y) to container-relative
      * screen pixels, using the current stage scale/position. Lets host UI anchor
@@ -607,6 +941,9 @@ interface ISeatmapRenderer {
     getRung?(): LodRung;
     /** Jump the camera to a rung's zoom band, centred on the chart (glided). */
     setRung?(rung: LodRung): void;
+    /** Read actual browser-rendered label visibility, size, fill, ink and state.
+     *  Pure diagnostic: it never changes chart or renderer state. */
+    getRenderedQualityEvidence(): RendererQualityEvidence;
     destroy(): void;
 }
 /** localStorage key the Designer writes and the Picker reads. */
@@ -647,6 +984,9 @@ declare function expandTable(t: TableObject): ExpandedSeat[];
 declare function expandBooth(b: BoothObject): ExpandedSeat[];
 /** Ray-cast point-in-polygon test — odd crossings ⇒ inside. */
 declare function pointInPolygon(p: Point, poly: Point[]): boolean;
+declare function pointInPolygonWithHoles(p: Point, outer: Point[], holes: Point[][] | undefined): boolean;
+/** Stable interior label anchor that cannot land inside a polygon cutout. */
+declare function polygonLabelPoint(outer: Point[], holes: Point[][] | undefined): Point;
 /**
  * Visual centre of any object — used for spatial section membership and for
  * rotating an object about its centre. Rows: centroid of expanded seats (or
@@ -792,11 +1132,21 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private circleById;
     /** Booth block geometry, keyed by booth id (= the unit's rowId). */
     private boothDims;
-    /** Booth label node so status changes can say HELD/SOLD on the full block. */
+    /** Booth labels live with the booth shape but obey the shared rendered-size LOD. */
     private boothLabelById;
+    /** Viewport seat labels are rebuilt after each settled camera change. */
+    private seatLabelById;
+    /** Authored free-text nodes obey the same rendered-size visibility floor. */
+    private freeTextById;
+    /** Stage/rink landmarks retain a readable screen-space caption at overview. */
+    private primaryFocalLabels;
+    /** GA paint and text share price/highlight filter state. */
+    private gaById;
     private statusById;
     private catColor;
     private theme;
+    /** Opaque paint actually visible behind transparent Konva canvases. */
+    private canvasBackground;
     /** Effective selection/hover ring color — resolved per chart in setChart(). */
     private effSelection;
     /** Colorblind-safe mode (Okabe-Ito hues + hollow booked seats). */
@@ -913,6 +1263,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     getStatus(seatId: string): SeatStatus;
     getSelection(): ExpandedSeat[];
     clearSelection(): void;
+    setMaxSelection(maxSelection: number): void;
+    select(seatIds: string[]): ExpandedSeat[];
     /** Switch organizer interaction in place so the host preserves camera, LOD,
      * focus and live status state while moving between Monitor and Block. */
     setManageInteraction(options: {
@@ -930,6 +1282,9 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /** Select the selectable seats matching these public labels (category/row/
      *  section bulk resolves to labels host-side). Returns the newly added seats. */
     selectByLabels(labels: string[]): ExpandedSeat[];
+    /** Exact SDK capture helper. MCP never accepts this id; the SDK derives it
+     * from the persisted floor and uses the normal selected paint/ring path. */
+    setEvidenceSelection(seatId: string): boolean;
     /** Selectable seats in a section OR zone id — pure read (no selection change). */
     getSelectableInSection(sectionId: string): ExpandedSeat[];
     /**
@@ -950,6 +1305,12 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      */
     private finishMarquee;
     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.
+     */
+    flashSection(sectionId: string, color?: string): void;
     private onKeyDown;
     /** Nearest seat from `fromId` in a cardinal direction (aligned + close wins). */
     private nearestSeat;
@@ -962,6 +1323,7 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     zoomIn(): void;
     zoomOut(): void;
     seatCount(): number;
+    bookableCount(): number;
     worldToScreen(point: Point): {
         x: number;
         y: number;
@@ -975,6 +1337,10 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * widget resolves which categories fall inside the buyer's chosen band.
      */
     setCategoryFilter(keys: string[] | null): void;
+    private gaCategoryDimmed;
+    /** Keep GA paint and its two labels in the same legend/price-filter state. */
+    private applyGAFilterState;
+    private paintGAStateForView;
     /** Frame the currently available inventory that survived a buyer price
      *  filter. Clearing the filter glides back to the full venue. */
     focusCategories(keys: string[] | null): void;
@@ -1028,6 +1394,9 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private renderBoothUnit;
     /** The category's display color — Okabe-Ito hue when colorblind-safe is on. */
     private seatBaseColor;
+    /** Authored free fills retain the chart's validated ink. Renderer-owned
+     * transient fills choose an ink against the paint that is actually visible. */
+    private renderedBookableLabelInk;
     /** Apply fill/stroke/opacity for a seat's current status + selection. */
     private paintSeat;
     /** True when a seat sits in a section/zone currently marked `closed`. */
@@ -1070,7 +1439,7 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
         width: number;
         height: number;
     };
-    /** Axis-aligned world bounds of all seats + section outlines (minimap F3 frame). */
+    /** Axis-aligned world bounds of seats, section outlines, and GA polygons (minimap F3 frame). */
     getWorldBounds(): {
         x: number;
         y: number;
@@ -1099,22 +1468,18 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /**
      * A section renders in three coordinated layers driven by the LOD melt:
      *   • a faint outline (the existing near-zoom look, untouched),
-     *   • a solid category-mix block that fades in at the block rung, and
-     *   • a name + "N LEFT" sublabel.
-     * Membership (which seats live inside the outline) + the mix fill + the live
-     * availability count are precomputed here (once), not per frame.
+     *   • a neutral solid shell that fades in at the overview rung, and
+     *   • one readable, contained section name.
+     * Category, row, seat, and availability detail belongs to section focus/zoom.
+     * Membership and category mix are still precomputed for the detailed state.
      */
     private renderSection;
     private refreshSectionHeat;
-    /** Recompute a section's availability-tinted fill + "N LEFT" (cheap; on status change). */
+    /** Recompute a section's neutral overview state and retained detail count. */
     private refreshSectionFill;
     /** True when a section/zone is currently in the `closed` event-state. */
     private isSectionClosed;
-    /**
-     * The block-fill colour for a section: flat desaturated grey when `closed`,
-     * else the availability-darkened category mix; then desaturated toward neutral
-     * when another section holds focus (AXS dim treatment).
-     */
+    /** Clean overview shells never leak category, price, or live availability paint. */
     private sectionBlockFill;
     /**
      * Zone rung: one giant screen-constant label per zone (+ optional "FROM $n"),
@@ -1132,17 +1497,19 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * Section/zone labels are scale-compensated to hold a roughly constant screen size.
      */
     private applySectionLod;
+    /** One semantic section gets one overview label, even across split contours. */
+    private dedupeLogicalSectionLabels;
     /**
-     * Greedy label de-collision for the zone/section rungs (same approach as the
-     * designer's cullRowLabels): price/"N LEFT" sublabels are lowest priority and
-     * drop first; name labels keep top-to-bottom, left-to-right; anything whose
-     * on-screen box (+4px gap) overlaps an already-kept box hides. Recomputed on
-     * every LOD pass so hidden labels reappear as zoom spreads them apart.
-     * Culling multiplies the opacity applySectionLod just assigned (never raises).
+     * Keep transitional zone pills from covering section names. Section names
+     * are already proven inside disjoint shells, so they must not cull each other.
      */
     private decollideRungLabels;
     /** Set a centred label's world fontSize (for a target screen px) and re-anchor it. */
     private sizeLabel;
+    /** Fit one centred section name, rotating narrow shells like the target chart. */
+    private fitSectionRungLabels;
+    /** Size one screen-constant zone name/price pill around its shared anchor. */
+    private sizeZonePill;
     /**
      * Map a container-relative screen point back to world coords. Inverts the
      * stage (scale/pos) and, in iso view, the iso affine — so screen-space taps
@@ -1168,6 +1535,7 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * the container's computed CSS background (walking up past transparent
      * ancestors). Unknown/unparseable backgrounds keep the dark default.
      */
+    private resolveCanvasBackground;
     private resolveSelectionColor;
     private setSelected;
     /** Rebuild one marker after selected/held/candidate state changes. */
@@ -1179,6 +1547,7 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * whether the section already fills the viewport (small container) so the tap
      * must fall through and pick.
      */
+    private sectionBounds;
     private sectionFrameScale;
     /**
      * Resolve a seat tap: honour the 3D deck-drill and the AXS seat-pick gate,
@@ -1241,8 +1610,17 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private cancelGlide;
     /** Current LOD rung derived from effective zoom — drives the ZONES/SECTIONS/SEATS pill. */
     getRung(): LodRung;
-    /** Jump the camera to a rung's zoom band, centred on the chart (glided). */
+    getRenderedQualityEvidence(): RendererQualityEvidence;
+    /** Jump the camera to a rung's zoom band (glided). */
     setRung(rung: LodRung): void;
+    /**
+     * The seat rung must account for labels that auto-fit inside a seat circle.
+     * A short `A-1` remains at the normal 7u target; a table label such as
+     * `T13-10` may fit at 4u and therefore needs a deeper camera target to reach
+     * the same 12 CSS-pixel floor. Measurement happens only on explicit rung
+     * navigation, never during pan/zoom frames.
+     */
+    private seatLabelTargetScale;
     /** Recompute LOD (cache/labels) after any pan/zoom settles. */
     private afterViewChange;
     /** rAF-coalesced `onViewChange` — at most one host callback per animation frame. */
@@ -1264,6 +1642,7 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * byte-identical.
      */
     forceDraw(): void;
+    private updateFreeTextVisibility;
     private updateLabels;
     private handleResize;
     private startFpsLoop;
@@ -1462,7 +1841,7 @@ declare class PickerController {
     private readonly opts;
     private readonly api;
     private readonly key;
-    private readonly maxSelection;
+    private maxSelection;
     private renderer;
     private _doc;
     /** Section/zone ids hidden from buyers this event (3.3) — seats vanish, not grey. */
@@ -1523,6 +1902,8 @@ declare class PickerController {
     seatDetails(seatId: string): SeatHoverDetails | null;
     clearSelection(): void;
     deselect(ids: string[]): void;
+    setMaxSelection(maxSelection: number): void;
+    select(ids: string[]): PickerSeat[];
     /**
      * Hold the current selection (or a given label set). The controller does the
      * renderer/hold side (409 → deselect + repaint the taken seats held) and then
@@ -1802,4 +2183,4 @@ declare function formatMoney(amount: number, currency?: string, fractionDigits?:
 /** Bare symbol for input adornments ("€", "$", "₹"). */
 declare function currencySymbol(currency?: string): string;
 
-export { ACCESSIBILITY_TYPES, type AccessibilityMeta, type AccessibilityType, type AvailabilityRule, type BoothObject, CHART_STORAGE_KEY, type Category, type CategoryTier, type ChartDoc, type ChartObject, type ChartTheme, DEFAULT_CURRENCY, type DecorImageObject, type Dict, type ExpandedSeat, type Floor, type GAAreaObject, type HoldConflict, type HoldInfo, type HoldSelectionRequest, type HoldServerItem, type ISeatmapRenderer, type Locale, type LodRung, MAX_EVENT_INVENTORY, MAX_GA_CAPACITY, type PanoramaResult, type PickerCallbacks, PickerController, type PickerOptions, type PickerSeat, type PickerTransport, type Point, type RendererCallbacks, type RendererOptions, type RowObject, type RowSeatSlot, SUPPORTED_LOCALES, type SeatHoverDetails, type SeatOverride, type SeatStatus, SeatmapRenderer, type SectionCategory, type SectionNode, type SectionObject, type SectionSummary, type SelectionLayer, type ShapeObject, type TableObject, type TextObject, UNGROUPED_ID, type ZoneDef, accessibilityMeta, allObjects, applyHidden, chartBounds, computeSections, createRenderer, currencySymbol, expandBooth, expandChart, expandRow, expandRowSlots, expandTable, floorObjects, floorsOf, formatDate, formatMoney, gaAreasOf, gaUnitLabel, gaUnitLabels, generateSeatPanorama, generateSeatThumb, getLocale, hiddenObjectIds, isGaUnitLabel, isSectionHidden, layerOf, loadLocale, objectCenter, pointInPolygon, resolveLocale, setLocale, setMoneyLocale, setStringOverrides, stackFloors, t, tCount };
+export { ACCESSIBILITY_TYPES, type AccessibilityMeta, type AccessibilityType, type AvailabilityRule, type BoothObject, CHART_STORAGE_KEY, type Category, type CategoryTier, type ChartDoc, type ChartObject, type ChartReferenceImage, type ChartTheme, type CubicPath, DEFAULT_CURRENCY, type DecorImageObject, type Dict, type ExpandedSeat, type Floor, type GAAreaObject, type HoldConflict, type HoldInfo, type HoldSelectionRequest, type HoldServerItem, type ISeatmapRenderer, type Locale, type LodRung, MAX_EVENT_INVENTORY, MAX_GA_CAPACITY, type PanoramaResult, type PickerCallbacks, PickerController, type PickerOptions, type PickerSeat, type PickerTransport, type Point, type ReferenceAccessibilitySource, type ReferenceCalibration, type ReferenceCategorySource, type ReferenceDerivedScale, type ReferenceInventoryExclusionSource, type ReferenceInventorySource, type RenderedBookableLabelEvidence, type RenderedFreeTextEvidence, type RenderedGAAreaEvidence, type RenderedHierarchyLabelEvidence, type RenderedLabelHiddenReason, type RendererCallbacks, type RendererOptions, type RendererQualityEvidence, type RowObject, type RowSeatSlot, SUPPORTED_LOCALES, type SeatHoverDetails, type SeatOverride, type SeatStatus, SeatmapRenderer, type SectionCategory, type SectionNode, type SectionObject, type SectionOutlinePath, type SectionPathSegment, type SectionSummary, type SelectionLayer, type ShapeObject, type TableObject, type TextObject, UNGROUPED_ID, type ZoneDef, accessibilityMeta, allObjects, applyHidden, chartBounds, computeSections, createRenderer, currencySymbol, expandBooth, expandChart, expandRow, expandRowSlots, expandTable, floorObjects, floorsOf, formatDate, formatMoney, gaAreasOf, gaUnitLabel, gaUnitLabels, generateSeatPanorama, generateSeatThumb, getLocale, hiddenObjectIds, isGaUnitLabel, isSectionHidden, layerOf, loadLocale, objectCenter, pointInPolygon, pointInPolygonWithHoles, polygonLabelPoint, resolveLocale, setLocale, setMoneyLocale, setStringOverrides, stackFloors, t, tCount };