@seatlayer/core 0.52.0 → 0.54.0

package/dist/index.d.ts

@@ -1,463 +1,13 @@
-import { a as RowObject, A as AccessibilityType, S as SeatOverride, b as SeatViewMetadata, L as LabelStyle, c as RectTableSide, C as ChartDoc, d as ChartObject, B as BoothObject, E as ExpandedSeat, T as TableObject, P as Point, F as Floor, e as SectionObject, f as RectTableSeatCounts, G as GAAreaObject, g as GAInventorySegment, h as RendererQualityEvidence, i as RenderedFreeTextEvidence, I as ISeatmapRenderer, j as RendererOptions, k as SeatStatus, l as RendererViewMode, m as RendererMinimapSnapshot, n as LodRung, o as CategoryTier, p as SeatCommercialAttributes, q as RendererCallbacks } from './types-tLOunI-B.js';
-export { r as ACCESSIBILITY_RING_COLOR, s as ACCESSIBILITY_TYPES, t as AccessibilityMeta, u as AuthoringObjectState, v as CHART_STORAGE_KEY, w as Category, x as ChartLayoutConstraint, y as ChartReferenceImage, z as ChartTheme, D as CubicPath, H as DecorImageObject, J as LABEL_STYLE_MAX_SIZE, K as LABEL_STYLE_MIN_SIZE, M as LabelPresentation, O as ObjectEditorState, N as Physical3dEvidence, Q as RadialClearanceLayoutConstraint, U as ReferenceAccessibilitySource, V as ReferenceCalibration, W as ReferenceCategorySource, X as ReferenceDerivedScale, Y as ReferenceInventoryExclusionSource, Z as ReferenceInventorySource, _ as ReferenceScanProposal, $ as ReferenceScanRowProposal, a0 as ReferenceScanSectionProposal, a1 as ReferenceSeatSeed, a2 as ReferenceSectionTraceBatchInput, a3 as ReferenceSectionTraceBatchProposal, a4 as ReferenceSectionTraceInput, a5 as ReferenceSectionTraceProposal, a6 as RenderedBookableLabelEvidence, a7 as RenderedGAAreaEvidence, a8 as RenderedHierarchyLabelEvidence, a9 as RenderedLabelHiddenReason, aa as RenderedRowLabelEvidence, ab as RendererMinimapSeat, ac as RendererMinimapSection, R as ResolvedSeatConfidenceEvidence, ad as SEAT_COMMERCIAL_MARKS, ae as SURROUNDINGS_SHAPE_ROLES, af as SeatCommercialMark, ag as SeatCommercialMeta, ah as SeatConfidenceCoverage, ai as SeatConfidenceEvidence, aj as SeatConfidenceModelLevel, ak as SeatConfidenceModeledTarget, al as SeatConfidenceRealityLevel, am as SeatViewCoverage, an as SectionOutlinePath, ao as SectionPathSegment, ap as SelectionLayer, aq as ShapeLineCap, ar as ShapeLineEnding, as as ShapeLineJoin, at as ShapeObject, au as TextAlignment, av as TextBackground, aw as TextObject, ax as TicketTierApplicability, ay as TicketTierEvidence, az as TicketTierRestriction, aA as ZoneDef, aB as accessibilityMeta, aC as accessibilityRingColor, aD as layerOf, aE as seatCommercialMeta } from './types-tLOunI-B.js';
-
-/**
- * The segmented-row model — one logical row made of several physical rows.
- *
- * A segmented row is drawn as a chain of nodes and stored as N physical
- * `RowObject`s tied together by `segmentedRow` metadata. Two questions have to
- * be answered consistently or the feature lies to somebody:
- *
- * 1. **At draft time** — given the author's nodes, exactly which components,
- *    seat counts and pitches will be committed? (`segmentedRowComponents`)
- * 2. **At read time** — given stored physical rows, what is the logical row they
- *    form, and where does each component sit inside its numbering?
- *    (`resolveSegmentedRowGroups`)
- *
- * These lived apart — (1) in `rowDraft.ts` next to the ghost preview, (2) in
- * `layout.ts` next to buyer expansion — which is precisely how the canvas came
- * to number a segmented row `1-7` / `1-6` while buyers correctly saw
- * `A-1…A-13`. They are two halves of one rule, so they live in one module.
- *
- * The standing rule this module exists to enforce: **the ghost preview and the
- * commit share one resolver.** A preview that can lie is a bug.
- */
-
-/** Resolved logical placement of one physical component inside a segmented row. */
-interface SegmentedRowPlacement {
-    groupId: string;
-    /** Buyer adjacency index base (a declared aisle break costs one index). */
-    adjacencyOffset: number;
-    /** Continuous seat-numbering base across the whole logical row. */
-    displayOffset: number;
-    displayLabel: string;
-    totalSeats: number;
-    canonical: RowObject;
-    viewFromSeatUrl?: string;
-    viewFromSeatMeta?: RowObject['viewFromSeatMeta'];
-    confidenceEvidence?: RowObject['confidenceEvidence'];
-}
-
-/**
- * Pure geometry helpers — no Konva, no DOM. Turns the parametric chart
- * document into concrete seat coordinates and computes bounding boxes.
- */
-
-/**
- * Expand a parametric row into seat positions.
- *
- * Straight (curve === 0): seat i sits at local (i·spacing, 0).
- *
- * Curved: seats lie on a circular arc. Per-seat angular step is
- * `curve/(seatCount-1)`; radius is derived so the chord between neighbours
- * equals seatSpacing → radius = spacing / (2·sin(step/2)). Seat 0 sits at the
- * bottom of the arc (local origin) with the circle centre directly above it at
- * (0,-radius); increasing index sweeps toward +x while the ends rise toward -y,
- * i.e. positive curve is concave toward -y (a row wrapping a stage above it).
- * Local points are then rotated by `rotation` and translated to `origin`.
- *
- * Numbering (labels only, never geometry): `seatNumbering.direction === 'rtl'`
- * numbers from the far physical end; `step === 2` produces odd/even numbering
- * (start at 1 → 1,3,5…; start at 2 → 2,4,6…).
- */
-/** Base (pre-override) seat centre per index — shared by expandRow + designer edit mode. */
-declare function rowSeatPositions(row: RowObject): Point[];
-/** Sellable row slots: skipped slots are absent; empty wheelchair bays remain. */
-declare function rowInventoryCount(row: RowObject): number;
-/**
- * Every seat slot of a row INCLUDING skipped ones (designer seat-edit mode uses
- * this to draw un-skip handles). Overrides (dx/dy/label/categoryKey) are applied
- * but a skipped slot is flagged, not omitted.
- */
-interface RowSeatSlot {
-    index: number;
-    x: number;
-    y: number;
-    label: string;
-    displayLabel: string;
-    categoryKey: string;
-    skipped: boolean;
-    accessible: boolean;
-    accessibility: AccessibilityType[];
-    wheelchairSpaceType?: SeatOverride['wheelchairSpaceType'];
-    commercial?: RowObject['commercial'];
-    viewUrl?: string;
-    viewMeta?: SeatViewMetadata;
-    labelStyle?: LabelStyle;
-}
-/** Every authored table-chair slot, including skipped inventory. This mirrors
- * row seat slots so Designer, MCP and buyer/event expansion share one semantic
- * source while retaining the table's stable numeric slot identity. */
-interface TableSeatSlot extends RowSeatSlot {
-    side?: RectTableSide;
-}
-/**
- * Seat slots for one physical row.
- *
- * `placement` makes the slots read as part of a logical segmented row: labels
- * continue across components (`A-8`, not a second `A-1`) using the logical row's
- * numbering scheme and total seat count.
- */
-declare function expandRowSlots(row: RowObject, placement?: SegmentedRowPlacement): RowSeatSlot[];
-declare function expandRow(row: RowObject): ExpandedSeat[];
-/**
- * Expand a table into its perimeter seats.
- *
- * Round: seats spread evenly on a circle of radius `radius + 16`, the first at
- * angle `rotation` (degrees, clockwise from +x). Rect: seats line the top and
- * bottom edges (split evenly, any remainder to the top), 16u outside the edge,
- * the whole set rotated about the table centre.
- */
-/** Legacy rect tables distribute aggregate capacity round-robin across enabled
- * sides, then emit chairs in canonical top/bottom/left/right order. */
-declare function tableSeatCountsBySide(t: TableObject): RectTableSeatCounts;
-/** Expand every authored table chair, including skipped slots needed by the
- * Designer to restore inventory. */
-declare function expandTableSlots(t: TableObject): TableSeatSlot[];
-/** Sellable individual table chairs. Grouped tables own one atomic inventory
- * unit elsewhere and therefore retain their full authored chair capacity. */
-declare function tableInventoryCount(t: TableObject): number;
-declare function expandTable(t: TableObject): ExpandedSeat[];
-/** Expand a booth into its single bookable block unit. */
-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: the centre of the largest circle that fits in
- * the polygon (holes excluded).
- *
- * This used to return the average-of-vertices centroid whenever that happened
- * to be inside, and only fell back to a coarse 24×24 grid search when it was
- * not. "Inside" is a much weaker property than "has room": on a traced arena
- * the outer arc of a wedge carries dozens of sampled vertices and the radial
- * edges carry two, so the average is dragged onto the arc and the label pill —
- * far wider than a point — straddled the boundary into the next section.
- * Measured on the 36-section traced arena corpus, 15 of 36 anchors had under
- * 75% of the clearance actually available, some as little as 43%.
- *
- * `polygonInscribedAnchor` is deterministic and coordinate-free, so callers may
- * memoize it on geometry alone.
- */
-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
- * origin when empty); tables/booths: centre; GA/section: polygon centroid;
- * shape: bbox centre; text: its position.
- */
-declare function objectCenter(o: ChartObject): Point;
-/**
- * Resolve one bookable object's owning physical section using the canonical
- * first-match rule. Generated reference inventory may name a logical section,
- * but that provenance is trusted only when the stored geometry confirms it.
- * Keeping this primitive in layout lets section inventory, category painting,
- * and buyer view inheritance share one ownership decision.
- */
-declare function owningSectionForObject(objects: ChartObject[], object: ChartObject): SectionObject | undefined;
-/**
- * Normalized floor list (Batch 5): a multi-floor chart's `floors`, or a synthetic
- * single floor wrapping a single-floor chart's `objects`. Every consumer that needs
- * to reason about floors goes through this so single-floor charts stay untouched.
- */
-declare function floorsOf(doc: ChartDoc): Floor[];
-/** Objects of one floor by id (defaults to the first floor). */
-declare function floorObjects(doc: ChartDoc, floorId?: string): ChartObject[];
-/** Every object across ALL floors — the whole venue (single-floor = `doc.objects`). */
-declare function allObjects(doc: ChartDoc): ChartObject[];
-/** A copy of an object translated by (dx, dy) — every coordinate field shifted. */
-declare function translateObject(o: ChartObject, dx: number, dy: number): ChartObject;
-/**
- * Multi-floor 3D stack (Batch 5): flatten every floor into ONE doc with floor `i`
- * lifted by `i * spread` in −y, so the isometric view shows the floors as stacked
- * decks (ground at the bottom). Returns a single-floor doc (no `floors`). Meant
- * only for the 3D overview render — 2D still shows one floor via `floorObjects`.
- */
-declare function stackFloors(doc: ChartDoc, spread?: number): ChartDoc;
-/**
- * Build the buyer-facing 2D overview of a multi-floor chart.
- *
- * Floors commonly reuse the same drawing origin (a balcony is authored over
- * the stalls it overlooks). Flattening those source coordinates makes a valid
- * import look corrupt because every level is painted on top of every other
- * level. This projection packs complete floors into a compact, content-aware
- * grid. Each floor receives one rigid translation: no seat, row, section,
- * annotation, gap, or rotation changes, and the canonical document is never
- * mutated.
- */
-declare function layoutFloorOverview(doc: ChartDoc): ChartDoc;
-/**
- * Rigid per-floor translations used by the buyer's complete-venue overview.
- *
- * Kept as a pure public helper so 2D and 3D can present the same non-overlapping
- * level arrangement without either renderer rewriting the authored chart. A
- * zero translation is returned for a single-floor document.
- */
-declare function floorOverviewTranslations(doc: ChartDoc): Point[];
-interface ExpandChartOptions {
-    /** Physical height for a single-floor projection extracted from a multi-floor
-     * document. Full multi-floor documents resolve each floor directly. */
-    floorBaseHeightM?: number;
-    /** Resolve per-seat 3D eye heights (default true). Two-dimensional consumers
-     * such as thumbnails can disable this expensive stand-structure pass. */
-    resolveEyeHeights?: boolean;
-}
-/** Expand every seat-bearing object across all floors (rows, tables, booths).
- * Multi-floor ownership is resolved one floor at a time: local coordinates may
- * overlap between floors and must never assign a seat to another floor's section. */
-declare function expandChart(doc: ChartDoc, options?: ExpandChartOptions): ExpandedSeat[];
-/** Axis-aligned bounds over every object plus the background image, with padding. */
-declare function chartBounds(doc: ChartDoc): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-
-declare const MAX_GA_CAPACITY = 100000;
-declare const MAX_EVENT_INVENTORY = 100000;
-/** Stable internal inventory label for one unit of a GA area's capacity. */
-declare function gaUnitLabel(areaId: string, index: number): string;
-/** Strict, bounded validation for durable Join Areas inventory provenance. */
-declare function validGAInventorySegments(area: GAAreaObject): boolean;
-/** Canonical source ranges. Invalid explicit provenance intentionally yields no
- * labels: chart validation blocks publication instead of inventing identities. */
-declare function gaInventorySegments(area: GAAreaObject): GAInventorySegment[];
-declare function gaUnitLabels(area: GAAreaObject): string[];
-/** Append-only capacity semantics for an already joined GA surface. */
-declare function growJoinedGAInventory(area: GAAreaObject, nextCapacity: number): GAInventorySegment[] | undefined;
-declare function gaAreasOf(doc: ChartDoc): GAAreaObject[];
-declare function isGaUnitLabel(label: string): boolean;
-
-/**
- * Real-world scale primitives — the ONE place the app fixes chart-unit ↔ metre ↔
- * renderer-world scale, and the section 3D-geometry resolver that rides on it.
- *
- * Everything that converts between chart units, metres, and renderer "world"
- * units derives from {@link METRES_PER_CHART_UNIT}. Renderer world units and
- * chart units are 1:1, so metres → world is exactly {@link CHART_UNITS_PER_METRE}
- * (the single m→world conversion constant Phase B consumers use).
- *
- * This is a leaf module (types only) so both `layout.ts` and `sections.ts` can
- * import it without the two forming an import cycle.
- */
-
-/**
- * Metres of front-edge height one elevation tier represents. Chosen (not guessed)
- * so `elevation × TIER_HEIGHT_M` metres, scaled back through
- * {@link CHART_UNITS_PER_METRE}, equals the legacy `elevation × LIFT_PER_STEP`
- * world lift exactly — an un-authored chart stays pixel-identical. ≈ 1.329 m/tier.
- */
-declare const TIER_HEIGHT_M: number;
-/**
- * Resolve a section's real 3D geometry, applying the legacy-elevation fallback so
- * old charts and new charts share ONE code path. Every consumer (iso lift, 360°
- * eye-height, author lint, any 2D depth cue) must call this and never read the raw
- * {@link SectionObject.height}/{@link SectionObject.rake} fields — that is what
- * keeps un-authored charts rendering identically to today.
- *
- * - `height`: authored absolute metres if present, else owning-floor base height
- *   plus `elevation × TIER_HEIGHT_M`.
- * - `rake`: authored degrees if present, else 0 (flat).
- *
- * Malformed values are bounded here as a last defensive barrier. Structural
- * validation still reports them so drafts can be repaired instead of silently
- * persisting a renderer-only interpretation.
- *
- * Pure — no document mutation, no side effects.
- */
-interface SectionGeometryContext {
-    /** Absolute physical height of the owning floor above the venue datum. */
-    floorBaseHeightM?: number;
-}
-declare function sectionGeometry(section: Pick<SectionObject, 'elevation' | 'height' | 'rake'>, context?: SectionGeometryContext): {
-    height: number;
-    rake: number;
-};
-
-/**
- * Section membership + hide/show resolution (Batch 3.3).
- *
- * A `SectionObject` is a polygon drawn over existing seat objects; an object
- * "belongs" to a section when its visual centre (`objectCenter`) falls inside
- * the section outline, first section in doc order winning. This is the same
- * spatial notion `objectCenter`'s doc-comment describes, resolved once here so
- * BOTH the event manager (Sections tab counts) and the buyer picker (omit
- * hidden seats) agree on which seats live in which section.
- *
- * Hiding is per-EVENT (the EventDO holds the hidden id set), not a chart edit —
- * so a republish of the chart never disturbs it. A hidden id may be a section
- * id, a zone id (hides every section in the zone), or `UNGROUPED_ID` (the
- * catch-all bucket of seat objects that sit in no section).
- */
-
-/** Synthetic section id for seat objects that fall in no drawn section. */
-declare const UNGROUPED_ID = "__ungrouped__";
-/**
- * A per section/zone availability window (Batch 3.4). Wire-compatible with the
- * EventDO's own `AvailabilityRule`. Absence of a rule for an id = on sale.
- *   'hidden'    — manual: hidden until the organizer reveals it (3.3).
- *   'timed'     — hidden until `revealAt` (epoch ms), then auto-reveals.
- *   'threshold' — auto-reveals once the on-sale inventory is `thresholdPct`% sold.
- *   'closed'    — visible to buyers but not purchasable (rendered flat grey);
- *                 unlike 'hidden', the seats stay on the map, just off sale.
- * `labels` are the seat labels the id governs, so a threshold's denominator can
- * exclude still-hidden seats.
- */
-interface AvailabilityRule {
-    mode: 'hidden' | 'timed' | 'threshold' | 'closed';
-    revealAt?: number;
-    thresholdPct?: number;
-    labels?: string[];
-}
-interface SectionNode {
-    /** Section id (a `SectionObject.id`, or `UNGROUPED_ID`). */
-    id: string;
-    label: string;
-    /** Zone id this section points at (`SectionObject.zone`), if any. */
-    zone?: string;
-    /** Total seats across the member objects. */
-    seatCount: number;
-    /** Ids of the seat-bearing objects that belong to this section. */
-    objectIds: string[];
-    /** Seat labels across the member objects (for availability-rule denominators). */
-    seatLabels: string[];
-}
-/**
- * Resolve section membership for a chart. Returns one node per drawn section
- * (doc order), a synthetic "Ungrouped" node for loose seat objects (null when
- * every seat sits in a section), and the object→section id map.
- */
-declare function computeSections(doc: ChartDoc): {
-    sections: SectionNode[];
-    ungrouped: SectionNode | null;
-    /** seat-object id → owning section id (or `UNGROUPED_ID`). */
-    objectToSection: Map<string, string>;
-};
-/** Is a drawn section hidden under `hidden` — directly, or via its zone? */
-declare function isSectionHidden(s: SectionObject, hidden: ReadonlySet<string>): boolean;
-/**
- * The set of seat-object ids to omit from the buyer view for a given hidden id
- * set. An object is hidden when its owning section is hidden (directly or via
- * zone), or it is ungrouped and the catch-all bucket is hidden.
- */
-declare function hiddenObjectIds(doc: ChartDoc, hidden: ReadonlySet<string>): Set<string>;
-/**
- * A copy of the doc with hidden sections' member objects removed, plus the
- * hidden section overlays themselves (so no empty block renders). Returns the
- * SAME reference when nothing is hidden — callers can skip a re-render on `===`.
- */
-declare function applyHidden(doc: ChartDoc, hidden: ReadonlySet<string>): ChartDoc;
-
-declare const RENDERED_QUALITY_REPORT_VERSION = 3;
-type RenderedEvidenceState = 'overview' | 'interaction';
-type RenderedQualityFindingCode = 'bookable-label-undersized' | 'bookable-label-contrast-low' | 'bookable-label-collision' | 'hierarchy-label-undersized' | 'hierarchy-label-contrast-low' | 'hierarchy-label-outside-section' | 'hierarchy-label-collision' | 'hierarchy-bookable-collision' | 'overview-section-category-paint' | 'overview-category-detail-visible' | 'overview-row-hints-visible' | 'overview-availability-clutter' | 'overview-ga-detail-visible' | 'free-text-undersized' | 'free-text-contrast-low' | 'free-text-collision' | 'free-text-bookable-collision' | 'free-text-hierarchy-collision' | 'ga-contrast-low' | 'detail-rung-missing' | 'detail-inventory-not-visible' | 'pointer-target-undersized' | 'pointer-target-inactive' | 'selected-state-missing' | 'selected-state-contrast-low' | 'held-state-missing' | 'booked-state-missing' | 'status-state-indistinct' | 'section-focus-missing' | 'category-filter-missing' | 'category-filter-ineffective' | 'target-category-not-visible' | 'target-category-filter-mismatch';
-interface RenderedQualitySample {
-    primaryId: string;
-    primaryLabel: string;
-    secondaryId?: string;
-    secondaryLabel?: string;
-    measured?: number;
-    minimum?: number;
-}
-interface RenderedQualityFinding {
-    code: RenderedQualityFindingCode;
-    message: string;
-    count: number;
-    samples: RenderedQualitySample[];
-}
-interface RenderedQualityReport {
-    version: typeof RENDERED_QUALITY_REPORT_VERSION;
-    passed: boolean;
-    state: RenderedEvidenceState;
-    /** Server-selected category exercised by a category-specific detail scene. */
-    targetCategoryKey: string | null;
-    /** Exact overview checks discharged by this browser-rendered report. */
-    resolvedRules: string[];
-    viewport: {
-        width: number;
-        height: number;
-    };
-    canvasBackground: string;
-    effectiveScale: number;
-    rung: RendererQualityEvidence['rung'];
-    inventory: {
-        totalBookableUnits: number;
-        totalLabelledBookableUnits: number;
-        visibleBookableLabels: number;
-        hiddenBookableLabels: number;
-        visibleHierarchyLabels: number;
-        visibleFreeTextLabels: number;
-        visibleGAAreas: number;
-    };
-    overviewStyle?: RendererQualityEvidence['overviewStyle'];
-    /**
-     * Coordinate-free identity evidence from the exact buyer scene. The Worker
-     * uses this to compare persisted reference semantics with what Chromium
-     * actually painted, without exposing screen boxes or accepting geometry.
-     */
-    composition: {
-        hierarchy: Array<{
-            id: string;
-            kind: 'section' | 'zone';
-            label: string;
-            visible: boolean;
-        }>;
-        labelledObjects: Array<{
-            objectId: string;
-            kind: RenderedFreeTextEvidence['kind'];
-            text: string;
-            visible: boolean;
-        }>;
-        gaAreas: Array<{
-            areaId: string;
-            label: string;
-            categoryKey: string;
-            sectionId?: string;
-            visible: boolean;
-        }>;
-        bookableSectionIds: string[];
-        categoryKeys: string[];
-        /** Categories whose non-dimmed bookable paint is visible in this scene. */
-        activeCategoryKeys: string[];
-    };
-    metrics: {
-        minimumRenderedBookableLabelPx: number | null;
-        minimumBookableLabelContrast: number | null;
-        minimumRenderedHierarchyLabelPx: number | null;
-        minimumHierarchyLabelContrast: number | null;
-        minimumRenderedFreeTextPx: number | null;
-        minimumFreeTextContrast: number | null;
-        minimumGAContrast: number | null;
-        minimumEffectivePointerTargetPx: number | null;
-        selectedRingContrast: number | null;
-    };
-    interaction: {
-        applicable: {
-            detail: boolean;
-            pointer: boolean;
-            held: boolean;
-            booked: boolean;
-            sectionFocus: boolean;
-            categoryFilter: boolean;
-        };
-        selectedUnits: number;
-        heldUnits: number;
-        bookedUnits: number;
-        activePointerTargets: number;
-        focusedSectionId: string | null;
-        focusBackdropVisible: boolean;
-        categoryFilterKeys: string[] | null;
-    };
-    findings: RenderedQualityFinding[];
-}
-/**
- * Inspect what the buyer renderer actually decided to paint at one exact
- * viewport. This is deliberately downstream of ChartDoc validation: screen
- * size, LOD visibility, fitted hierarchy text, transient paint, and label
- * collisions cannot be proven from stored geometry alone.
- */
-declare function inspectRenderedQualityEvidence(evidence: RendererQualityEvidence, state?: RenderedEvidenceState, targetCategoryKey?: string | null): RenderedQualityReport;
+import { C as ChartDoc, P as Point, A as AccessibilityType, l as CategoryTier, f as SeatCommercialAttributes } from './types-COfJorq_.js';
+export { t as ACCESSIBILITY_RING_COLOR, u as ACCESSIBILITY_TYPES, v as AccessibilityMeta, w as AuthoringObjectState, B as BoothObject, x as Category, y as ChartLayoutConstraint, c as ChartObject, m as ChartReferenceImage, z as ChartTheme, r as CubicPath, D as DecorImageObject, F as Floor, G as GAAreaObject, k as GAInventorySegment, E as LABEL_STYLE_MAX_SIZE, H as LABEL_STYLE_MIN_SIZE, I as LabelPresentation, L as LabelStyle, O as ObjectEditorState, J as Physical3dEvidence, K as RadialClearanceLayoutConstraint, e as RectTableSeatCounts, b as RectTableSide, M as ReferenceAccessibilitySource, N as ReferenceCalibration, Q as ReferenceCategorySource, U as ReferenceDerivedScale, V as ReferenceInventoryExclusionSource, W as ReferenceInventorySource, X as ReferenceScanProposal, Y as ReferenceScanRowProposal, Z as ReferenceScanSectionProposal, _ as ReferenceSeatSeed, $ as ReferenceSectionTraceBatchInput, a0 as ReferenceSectionTraceBatchProposal, a1 as ReferenceSectionTraceInput, a2 as ReferenceSectionTraceProposal, g as ResolvedSeatConfidenceEvidence, R as RowObject, a3 as SEAT_COMMERCIAL_MARKS, a4 as SURROUNDINGS_SHAPE_ROLES, a5 as SeatCommercialMark, a6 as SeatCommercialMeta, a7 as SeatConfidenceCoverage, a8 as SeatConfidenceEvidence, a9 as SeatConfidenceModelLevel, aa as SeatConfidenceModeledTarget, ab as SeatConfidenceRealityLevel, S as SeatOverride, h as SeatViewCoverage, a as SeatViewMetadata, d as SectionObject, i as SectionOutlinePath, j as SectionPathSegment, ac as SelectionLayer, n as ShapeLineCap, o as ShapeLineEnding, p as ShapeLineJoin, q as ShapeObject, T as TableObject, ad as TextAlignment, ae as TextBackground, s as TextObject, af as TicketTierApplicability, ag as TicketTierEvidence, ah as TicketTierRestriction, ai as ZoneDef, aj as accessibilityMeta, ak as accessibilityRingColor, al as layerOf, am as seatCommercialMeta } from './types-COfJorq_.js';
+export { E as ExpandChartOptions, R as RowSeatSlot, T as TableSeatSlot, a as allObjects, c as chartBounds, e as expandBooth, b as expandChart, d as expandRow, f as expandRowSlots, g as expandTable, h as expandTableSlots, i as floorObjects, j as floorOverviewTranslations, k as floorsOf, l as layoutFloorOverview, o as objectCenter, m as owningSectionForObject, p as pointInPolygon, n as pointInPolygonWithHoles, q as polygonLabelPoint, r as rowInventoryCount, s as rowSeatPositions, t as stackFloors, u as tableInventoryCount, v as tableSeatCountsBySide, w as translateObject } from './layout-B5UYbwnv.js';
+import { c as TicketSelectionIssue } from './ticketRestrictions-ChHJwvTq.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-ChHJwvTq.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-mLOZrGrI.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-DbZM034G.js';
+import { I as ISeatmapRenderer, b as RendererOptions, S as SeatStatus, E as ExpandedSeat, c as RendererViewMode, d as RendererMinimapSnapshot, L as LodRung, R as RendererQualityEvidence, e as RendererCallbacks } from './renderer-IBi9YKWR.js';
+export { C as CHART_STORAGE_KEY, f as RenderedBookableLabelEvidence, a as RenderedFreeTextEvidence, g as RenderedGAAreaEvidence, h as RenderedHierarchyLabelEvidence, i as RenderedLabelHiddenReason, j as RenderedRowLabelEvidence, k as RendererMinimapSeat, l as RendererMinimapSection } from './renderer-IBi9YKWR.js';
+import './segmentedRowModel-BPTnJ7Tz.js';
 
 declare class SeatmapRenderer implements ISeatmapRenderer {
     private container;
@@ -635,35 +185,18 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private resizeObs;
     /** Coalesces bursty view-change sources (pointermove, wheel) into ≤1 callback/frame. */
     private viewChangeRaf;
-    private pointers;
-    private pinch;
-    private panLast;
-    private panStart;
-    private panStarted;
-    /** Maximum displacement from gesture start — suppress taps only after a real pan/pinch. */
-    private moved;
-    /**
-     * Ghost-click guard. Konva binds `_pointerup` to mouseup, touchend AND
-     * pointerup, so `on('click tap')` is two handlers for one finger tap unless
-     * the browser's synthesized compatibility click is suppressed. Konva only
-     * suppresses it when the touch lands on a LISTENING SHAPE (Stage.js returns
-     * early before its preventDefault() when `!shape || !shape.isListening()`),
-     * so a near-miss rescued by nearestSeatToScreen used to fire `tap` (select)
-     * then `click` (deselect) 1-3ms apart and net to nothing. With
-     * SEAT_TAP_SLOP_PX=14 against a ~12px seat radius, that broken annulus is
-     * ~3.7x the area of the seat itself — i.e. most successful mobile taps.
-     * `touch-action: none` does NOT suppress compatibility mouse events.
-     */
-    private lastTapAt;
-    /**
-     * True when this is the browser's synthesized compatibility click following a
-     * finger tap we already handled. Discriminates on `e.type` deliberately —
-     * `PointerEvent extends MouseEvent`, so an `instanceof MouseEvent` test
-     * matches genuine pointer taps too. One shared timestamp across the layer and
-     * stage handlers: a tap consumed at the layer must also suppress the ghost at
-     * the stage, and only `click` is ever rejected, so bubbling stays intact.
+    /**
+     * Pan/pinch state machine (`render/interaction/pointer`). Raw pointer events
+     * on the container, not Konva stage dragging — its touch pipeline proved
+     * unreliable for multi-touch on real devices. Also owns the ghost-click
+     * timestamp shared by the layer and stage tap handlers.
      */
+    private gestures;
+    /** Displacement of the current gesture — a tap must stay under the slop. */
+    private get moved();
     private isGhostClick;
+    /** Behavioural surface the gesture machine calls back into. */
+    private get pointerHost();
     /**
      * Manage-mode rubber-band marquee (option-gated). `start`/`cur` are WORLD-space
      * points (overlayLayer rides the stage transform); `rect` is the on-canvas
@@ -806,6 +339,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     setViewMode(mode: RendererViewMode): void;
     /** Current projection — reflects the tween target, not the mid-tween isoT. */
     getViewMode(): RendererViewMode;
+    /** Live ISO projection state handed to the `render/projection` free functions. */
+    private get isoState();
     /** Iso angle (rad) + y-squash for the current isoT. */
     private isoParams;
     /** Effective vertical scale = stage scale × iso squash — legibility math uses this. */
@@ -839,6 +374,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private resetLayerTransforms;
     /** Restore section-owned containers before applying another projection. */
     private resetSectionProjection;
+    /** Node/cache context the shared seat-anchor pass reads and updates. */
+    private get seatAnchorContext();
     /** Move native seat/booth hit shapes to or from their exact pinhole anchors. */
     private applyExactSeatAnchors;
     /**
@@ -1020,12 +557,12 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * single drawImage per frame, and it rides the same layer cache — effectively
      * zero per-frame cost. Never listens, so it can't intercept a seat click.
      */
+    /** Node/registry surface the `render/objectDrawing` factories draw into. */
+    private get objectDrawContext();
     private renderDecorImage;
     private renderTable;
     private renderText;
     private renderShape;
-    /** Prominent stage caption: uppercase, letter-spaced, larger, softly dimmed. */
-    private addStageLabel;
     private renderGA;
     /**
      * A section renders in three coordinated layers driven by the LOD melt:
@@ -1037,62 +574,17 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      */
     private renderSection;
     private refreshSectionHeat;
-    /** Recompute a section's availability shading + retained availability text. */
     private refreshSectionFill;
-    /** True when a section/zone is currently in the `closed` event-state. */
     private isSectionClosed;
-    /** Resolve the four-bucket overview availability state for a section (OV-69).
-     *  `closed` (operator) outranks live availability; the availability buckets
-     *  only apply to seated sections (GA-only shells have no seat capacity here). */
     private sectionAvailabilityState;
-    /** Overview shells stay neutral except for the bounded availability shading
-     *  (nearly-gone / sold-out) and the operator `closed` slab — never category
-     *  or price paint, which is deferred to section focus/seat detail. */
     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).
      */
     private renderZones;
-    /**
-     * THE MELT — a continuous, scale-driven cross-fade across the three rungs:
-     *   seats ⇄ section blocks ⇄ zone blocks.
-     * `blockT` ramps 0→1 as scale falls through [SECTION_PROMINENT, CACHE_THRESHOLD]
-     * so the solid fill is fully present exactly as seats become the cached bitmap
-     * and fade out; `zoneT` ramps 0→1 across [ZONE_PROMINENT, SECTION_PROMINENT] so
-     * per-section detail hands off to giant zone labels. Reduced-motion hard-swaps.
-     * 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;
-    /**
-     * Keep transitional zone pills from covering section names, and keep section
-     * names off each other.
-     *
-     * This used to assume section labels "do not collide by construction",
-     * because each is proven to fit inside its own shell. That holds only while
-     * shells are disjoint. Hand-traced and imported plans routinely produce
-     * shells that touch or overlap slightly along a shared edge, and a label
-     * fitted into one can then land under its neighbour's — which is exactly the
-     * unreadable smear a 36-section arena showed. Section labels now block each
-     * other too, largest shell first so the big stands keep their names.
-     */
-    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;
-    /**
-     * 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.
-     */
-    private uiScale;
-    /** 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
@@ -1106,7 +598,6 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     }): string | null;
     /** Seat ids belonging to a section (Slice 5 section-summary card). */
     sectionMembers(id: string): string[];
-    private addCentredLabel;
     private isSelectable;
     private toggleSeat;
     /**
@@ -1159,10 +650,6 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * so within-floor elevation offsets don't affect the result. Null if none.
      */
     private deckFloorAt;
-    private toLocal;
-    private onPointerDown;
-    private onPointerMove;
-    private onPointerEnd;
     /**
      * Min is chart-relative (never lose the room); max is absolute so seats
      * reach a readable size on any chart, however large the venue.
@@ -1193,6 +680,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private cancelGlide;
     /** Current LOD rung derived from effective zoom — drives the ZONES/SECTIONS/SEATS pill. */
     getRung(): LodRung;
+    /** 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;
@@ -1208,6 +697,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private afterViewChange;
     /** 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. */
+    private sizeLabel;
     private updateLOD;
     /** Rebuild the seat-layer bitmap synchronously (no paint). Shared by the
      *  debounced cacheSeatLayer() and the synchronous forceDraw() catch-up. */
@@ -1260,46 +751,30 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /** Geometric association only: importer data remains unchanged. */
     private nodeBelongsToFocusedSection;
     /** 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
-     *  labelStyle colour/size fed through the same auto-contrast guard). Segmented
-     *  rows keep their own logical-label handling and are resolved by their owner. */
+     *  world space (see `render/rowLabelPlan`). */
     private buildRowLabelPlan;
     /** Axis-aligned world bounds of a centred, potentially rotated row label. */
     private rowLabelBox;
-    /**
-     * Keep an automatic start/end label out of seat markers and already-painted
-     * text. The authored point is never altered. Candidates are deliberately
-     * bounded and deterministic: the closest clear offset wins; if a chart is so
-     * dense that none is clear, the least-colliding candidate wins so the required
-     * row label remains present rather than being silently dropped.
-     */
+    /** Keep an automatic start/end label out of seats and already-painted text. */
     private resolveAutomaticRowLabelPosition;
     /** Row labels never carry status; the buyer just dims them under the same
      *  category/price filters that dim their seats. */
     private objectFilteredOut;
     private updateLabels;
+    private get viewportLabelContext();
     private handleResize;
     private startFpsLoop;
 }
 declare function createRenderer(container: HTMLDivElement, opts?: RendererOptions): ISeatmapRenderer;
 
-interface CompanionSelectionIssue {
-    code: 'companion_pair_required';
-    labels: string[];
-    message: string;
-}
-interface TicketOptionApplicabilityIssue {
-    code: 'ticket_option_not_applicable';
-    labels: string[];
-    message: string;
-}
-interface NotForSaleSelectionIssue {
-    code: 'not_for_sale';
-    labels: string[];
-    message: string;
-}
-type TicketSelectionIssue = CompanionSelectionIssue | TicketOptionApplicabilityIssue | NotForSaleSelectionIssue;
+/**
+ * Public host contracts for the framework-agnostic buyer picker.
+ *
+ * Kept separate from `PickerController` so SDK and application consumers can
+ * find the integration surface without wading through controller state and
+ * transport orchestration. `PickerController` re-exports these names for
+ * source compatibility.
+ */
 
 interface PickerSeat {
     id: string;
@@ -1680,6 +1155,7 @@ interface PickerMapTheme {
     /** Selection / hover ring. */
     selectionColor?: string;
 }
+
 declare class PickerController {
     private readonly opts;
     private readonly api;
@@ -2120,11 +1596,8 @@ declare class PickerController {
     private connect;
     /**
      * Backoff for the PLAIN-socket fallback (a transport with no v1 client of its
-     * own). Full jitter, for the same reason BuyerRealtimeClient uses it: a
-     * deterministic `2**attempt` schedule brings every browser that lost the same
-     * socket back in the same millisecond, and an on-sale crowd reconnecting in
-     * lockstep turns one blip into a thundering herd. The ceiling still doubles,
-     * so a sustained outage still backs off.
+     * own). Full jitter, for the same reason BuyerRealtimeClient uses it — see
+     * `core/backoff`, which now owns that rationale and the schedule.
      */
     private scheduleReconnect;
 }
@@ -2212,6 +1685,14 @@ declare function setStringOverrides(next: Dict): void;
 declare function t(key: string, vars?: Record<string, string | number>): string;
 /** "1 seat" / "3 seats" without hand-rolled concatenation. */
 declare function tCount(key: string, count: number, vars?: Record<string, string | number>): string;
+/**
+ * Kept for the SDK surface that imports dates from here. It is a thin pass to
+ * `core/datetime`, which owns every date shape in the app and caches its
+ * formatters per (locale, shape) — the defaults below are the same ones it
+ * uses, so the two were already interchangeable and are now literally the same
+ * code. `active` is passed explicitly so this cannot drift from `t()` even if
+ * something calls `setDateTimeLocale` on its own.
+ */
 declare function formatDate(value: number | Date, opts?: Intl.DateTimeFormatOptions): string;
 
 /**
@@ -2252,12 +1733,22 @@ declare const DEFAULT_CURRENCY = "USD";
  *  express create forms so the two can never offer different lists. */
 declare const CURRENCY_CHOICES: string[];
 declare function setMoneyLocale(locale: string | undefined): void;
-/**
- * "€45" / "$1,500" / "45 €" (locale-dependent placement).
- * Whole amounts render without ".00" (design shows "$45", "$120"); pass
- * `fractionDigits` for fixed precision (e.g. 3 for "$0.045 / credit").
- */
-declare function formatMoney(amount: number, currency?: string, fractionDigits?: number): string;
+interface MoneyFormatOptions {
+    /** BCP 47 locale for this value; takes precedence over `setMoneyLocale`. */
+    locale?: string;
+    /** Leave unset to use the currency's standard exponent (`$45.00`, `¥45`). */
+    minimumFractionDigits?: number;
+    /** Leave unset to use the currency's standard exponent (`$45.00`, `¥45`). */
+    maximumFractionDigits?: number;
+    /**
+     * Rendering for invalid/unknown currency input. Required by buyer SDK
+     * surfaces that must remain usable even when a host supplies a bad code.
+     * Without one, the original `Intl.NumberFormat` error is rethrown.
+     */
+    fallback?: (amount: number, currency: string) => string;
+}
+declare function formatMoney(amount: number, currency: string, options: MoneyFormatOptions): string;
+declare function formatMoney(amount: number, currency?: string, fractionDigits?: number, locale?: string): string;
 /**
  * How many decimal places a currency has — 2 for USD/EUR, 0 for JPY/KRW/VND,
  * 3 for KWD/BHD/JOD.
@@ -2281,8 +1772,8 @@ declare function currencyExponent(currency?: string): number;
  */
 declare function fromMinorUnits(minor: number, currency?: string): number;
 /** "$90" / "¥9,000" — a minor-unit integer rendered for display. */
-declare function formatMinor(minor: number, currency?: string): string;
+declare function formatMinor(minor: number, currency?: string, locale?: string): string;
 /** Bare symbol for input adornments ("€", "$", "₹"). */
 declare function currencySymbol(currency?: string): string;
 
-export { AccessibilityType, type AvailabilityRule, BoothObject, CURRENCY_CHOICES, CategoryTier, ChartDoc, ChartObject, DEFAULT_CURRENCY, type Dict, type ExpandChartOptions, ExpandedSeat, Floor, GAAreaObject, GAInventorySegment, type HoldConflict, type HoldInfo, type HoldSelectionRequest, type HoldServerItem, ISeatmapRenderer, LabelStyle, type Locale, LodRung, MAX_EVENT_INVENTORY, MAX_GA_CAPACITY, type PanoramaResult, type PickerCallbacks, PickerController, type PickerGAArea, type PickerMapTheme, type PickerOptions, type PickerRealtimeConnection, type PickerRealtimeSink, type PickerRenderPerformanceProfile, type PickerSeat, PickerSelectionError, type PickerStatusChange, type PickerTransport, Point, RENDERED_QUALITY_REPORT_VERSION, RectTableSeatCounts, RectTableSide, type RenderedEvidenceState, RenderedFreeTextEvidence, type RenderedQualityFinding, type RenderedQualityFindingCode, type RenderedQualityReport, type RenderedQualitySample, RendererCallbacks, RendererMinimapSnapshot, RendererOptions, RendererQualityEvidence, RendererViewMode, RowObject, type RowSeatSlot, SUPPORTED_LOCALES, SeatCommercialAttributes, type SeatHoverDetails, SeatOverride, SeatStatus, SeatViewMetadata, SeatmapRenderer, type SectionCategory, type SectionNode, SectionObject, type SectionSummary, TIER_HEIGHT_M, TableObject, type TableSeatSlot, type TableSelectionDetails, UNGROUPED_ID, allObjects, applyHidden, chartBounds, computeSections, createRenderer, currencyExponent, currencySymbol, expandBooth, expandChart, expandRow, expandRowSlots, expandTable, expandTableSlots, floorObjects, floorOverviewTranslations, floorsOf, formatDate, formatMinor, formatMoney, fromMinorUnits, gaAreasOf, gaInventorySegments, gaUnitLabel, gaUnitLabels, generateSeatPanorama, generateSeatThumb, getLocale, growJoinedGAInventory, hiddenObjectIds, inspectRenderedQualityEvidence, isGaUnitLabel, isSectionHidden, layoutFloorOverview, loadLocale, objectCenter, owningSectionForObject, pointInPolygon, pointInPolygonWithHoles, polygonLabelPoint, resolveLocale, rowInventoryCount, rowSeatPositions, sectionGeometry, setLocale, setMoneyLocale, setStringOverrides, stackFloors, t, tCount, tableInventoryCount, tableSeatCountsBySide, translateObject, validGAInventorySegments };
+export { AccessibilityType, CURRENCY_CHOICES, CategoryTier, ChartDoc, DEFAULT_CURRENCY, type Dict, ExpandedSeat, type HoldConflict, type HoldInfo, type HoldSelectionRequest, type HoldServerItem, ISeatmapRenderer, type Locale, LodRung, type MoneyFormatOptions, type PanoramaResult, type PickerCallbacks, PickerController, type PickerGAArea, type PickerMapTheme, type PickerOptions, type PickerRealtimeConnection, type PickerRealtimeSink, type PickerRenderPerformanceProfile, type PickerSeat, PickerSelectionError, type PickerStatusChange, type PickerTransport, Point, RendererCallbacks, RendererMinimapSnapshot, RendererOptions, RendererQualityEvidence, RendererViewMode, SUPPORTED_LOCALES, SeatCommercialAttributes, type SeatHoverDetails, SeatStatus, SeatmapRenderer, type SectionCategory, type SectionSummary, type TableSelectionDetails, createRenderer, currencyExponent, currencySymbol, formatDate, formatMinor, formatMoney, fromMinorUnits, generateSeatPanorama, generateSeatThumb, getLocale, loadLocale, resolveLocale, setLocale, setMoneyLocale, setStringOverrides, t, tCount };