@seatlayer/core 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -15,8 +15,21 @@ interface Category {
     key: string;
     label: string;
     color: string;
-    /** Demo-only convenience; real pricing comes from ticket tiers server-side. */
+    /** Base price — used when the category has no explicit tiers. */
     price?: number;
+    /**
+     * 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
+     * default. Per-category (not per-seat) pricing — see Batch 3.5. Empty/absent =
+     * a single price (the `price` above).
+     */
+    tiers?: CategoryTier[];
+}
+/** One ticket tier within a category: a named price (Adult, Child, Senior…). */
+interface CategoryTier {
+    id: string;
+    name: string;
+    price: number;
 }
 /**
  * Accessibility accommodations a seat can carry. Mirrors the taxonomy real
@@ -103,7 +116,9 @@ interface RowObject {
     seatLabelStart?: number;
     /** Seat numbering within the row (default ltr, step 1). */
     seatNumbering?: {
-        direction: 'ltr' | 'rtl';
+        /** ltr / rtl number from an end; `center` numbers outward from the middle
+         *  (centre seat lowest — the premium-centre theatre convention). */
+        direction: 'ltr' | 'rtl' | 'center';
         /** 2 = odd/even numbering (1,3,5… — start at 2 for evens). */
         step?: 1 | 2;
     };
@@ -170,6 +185,13 @@ interface TableObject {
     rotation: number;
     /** Round tables. */
     radius?: number;
+    /**
+     * Round tables: the arc (in degrees) the seats occupy, default 360 (full
+     * ring). Below 360 leaves an open side — e.g. a service gap for waiters, a
+     * head table facing the room, or clearance against a wall. The opening is
+     * centred on the `rotation` direction; seats spread across the rest.
+     */
+    seatArc?: number;
     /** Rect tables. */
     width?: number;
     height?: number;
@@ -246,15 +268,33 @@ interface TextObject {
     color?: string;
 }
 type ChartObject = RowObject | GAAreaObject | ShapeObject | TableObject | BoothObject | TextObject | SectionObject;
+/**
+ * One floor / level of a multi-floor venue (Batch 5). Each floor owns its own
+ * geometry, stage focal point, and trace image; categories/zones/tiers stay
+ * chart-global (one event, one inventory). A single-floor chart has NO `floors`
+ * — its `objects[]` is the whole venue — so all existing charts are untouched.
+ */
+interface Floor {
+    id: string;
+    name: string;
+    objects: ChartObject[];
+    focalPoint: Point;
+    backgroundImage?: ChartDoc['backgroundImage'];
+}
 interface ChartDoc {
     version: 1;
     name: string;
     venueType: 'SIMPLE' | 'MIXED';
-    /** The stage / point every seat looks at. Anchors seat-view + sightlines. */
+    /** The stage / point every seat looks at. Anchors seat-view + sightlines.
+     *  Multi-floor: mirrors floor 0; each floor also carries its own focalPoint. */
     focalPoint: Point;
     categories: Category[];
     /** Section groupings for far-zoom navigation + pricing (optional; sections reference by id). */
     zones?: ZoneDef[];
+    /** Multi-floor venues (Batch 5): present ⇒ floors[] is the source of truth;
+     *  absent ⇒ single-floor and `objects` below is the whole chart. `objects`
+     *  is kept mirroring floor 0 so single-floor readers never branch. */
+    floors?: Floor[];
     objects: ChartObject[];
     /** Floor-plan photo the organizer traces over (designer-only aid, also rendered dimly in picker if kept). */
     backgroundImage?: {
@@ -267,6 +307,13 @@ interface ChartDoc {
     };
     /** Brand/venue theming (colors); categories carry their own colors separately. */
     theme?: ChartTheme;
+    /** Parametric-template provenance: present ⇒ the chart came from a capacity-
+     *  adjustable template family, and the designer offers a capacity control that
+     *  regenerates it at a new target seat count (Batch 4 "curated singles + resize"). */
+    template?: {
+        family: string;
+        targetSeats: number;
+    };
 }
 interface ExpandedSeat {
     /** Stable id: `${rowId}:${index}` */
@@ -298,9 +345,22 @@ interface RendererCallbacks {
     onFps?: (fps: number) => void;
     /** Fired when a GA area is clicked (quantity picking is UI-side). */
     onGAClick?: (areaId: string) => void;
+    /**
+     * Fired when a tap lands on a section outline while seats are NOT the active
+     * rung (i.e. zoomed out, section/zone LOD). The host glides in + shows a
+     * section-summary card instead of trying to select a 4px seat (Slice 5).
+     */
+    onSectionTap?: (sectionId: string) => void;
+    /**
+     * Fired when a seat/deck is tapped in the 3D all-floors stacked overview — the
+     * host drops back to the flat 2D map on that floor ("tap a deck to enter").
+     */
+    onDeckTap?: (floorId: string) => void;
     /** Fired after any pan/zoom/resize settles — re-anchor screen-space overlays. */
     onViewChange?: () => void;
 }
+/** Far-zoom level-of-detail rung: whole zones → section blocks → individual seats. */
+type LodRung = 'zones' | 'sections' | 'seats';
 interface RendererOptions extends RendererCallbacks {
     /** Max seats selectable at once (default 10). */
     maxSelection?: number;
@@ -314,10 +374,16 @@ interface RendererOptions extends RendererCallbacks {
      * pushing straight into the cart; `deselect([seat.id])` on Cancel un-highlights.
      */
     confirmSelection?: boolean;
+    /** ISO 4217 currency for on-map prices ("FROM …"); defaults to money.DEFAULT_CURRENCY.
+     *  Locale for grouping/symbol placement comes from the active i18n locale. */
+    currency?: string;
 }
 interface ISeatmapRenderer {
-    /** Replace the chart. Resets selection and statuses, zooms to fit. */
-    setChart(doc: ChartDoc): void;
+    /** Replace the chart. Resets selection and statuses, zooms to fit.
+     *  `opts.floorId` picks which floor to render on a multi-floor chart (Batch 5). */
+    setChart(doc: ChartDoc, opts?: {
+        floorId?: string;
+    }): void;
     /** Bulk status update; re-renders affected seats only. */
     setStatus(seatIds: string[], status: SeatStatus): void;
     getStatus(seatId: string): SeatStatus;
@@ -357,12 +423,32 @@ interface ISeatmapRenderer {
     setAccessibilityFilter(types: AccessibilityType[] | null): void;
     /** Legend hover-highlight: dim free seats of other categories (null clears). */
     setCategoryHighlight?(key: string | null): void;
+    /** Dim the seats of these section/zone ids (organizer manager: held-back inventory). */
+    setDimmedSections?(ids: string[] | null): void;
+    /**
+     * Colorblind-safe mode: category hues switch to an Okabe-Ito palette and
+     * booked seats render hollow (a non-color cue), so seat state never relies
+     * on hue alone. Off (the default) renders exactly as before.
+     */
+    setColorblindSafe?(on: boolean): void;
     /**
      * Switch the projection. `'flat'` = normal top-down; `'isometric'` = the "3D"
      * view (affine skew/rotate + elevation lift), hit-testing preserved in screen
      * space. Purely visual — the chart is authored flat. Animated unless reduced-motion.
      */
     setViewMode?(mode: 'flat' | 'isometric'): void;
+    /** Current projection (defaults to 'flat' when unimplemented). */
+    getViewMode?(): 'flat' | 'isometric';
+    /** Multi-floor (Batch 5): switch the shown floor; list floors; read the active id. */
+    setActiveFloor?(floorId: string): void;
+    getFloors?(): {
+        id: string;
+        name: string;
+    }[];
+    getActiveFloorId?(): string;
+    /** Render all floors stacked (3D overview) vs the active floor. No-op single-floor. */
+    setStacked?(on: boolean): void;
+    isStacked?(): boolean;
     /**
      * Section id whose outline contains a container-relative screen point (or null).
      * Feeds the far-zoom "tap a section to zoom in" flow (Slice 5).
@@ -370,6 +456,23 @@ interface ISeatmapRenderer {
     sectionAt?(clientPoint: Point): string | null;
     /** Seat ids belonging to a section — for the section-summary card (Slice 5). */
     sectionMembers?(id: string): string[];
+    /**
+     * Smoothly glide (pan+zoom) the camera to frame a section (by id) or a world-
+     * space bounds rect over ~450ms easeInOutCubic. `prefers-reduced-motion` snaps.
+     * A pointer-down (grab/pan) cancels an in-flight glide. Slice 5 "glide in".
+     */
+    focusRegion?(target: string | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, opts?: {
+        animate?: boolean;
+    }): void;
+    /** Current LOD rung derived from zoom (for the ZONES/SECTIONS/SEATS pill). */
+    getRung?(): LodRung;
+    /** Jump the camera to a rung's zoom band, centred on the chart (glided). */
+    setRung?(rung: LodRung): void;
     destroy(): void;
 }
 /** localStorage key the Designer writes and the Picker reads. */
@@ -417,7 +520,24 @@ declare function pointInPolygon(p: Point, poly: Point[]): boolean;
  * shape: bbox centre; text: its position.
  */
 declare function objectCenter(o: ChartObject): Point;
-/** Expand every seat-bearing object (rows, tables, booths). */
+/**
+ * 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[];
+/**
+ * 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;
+/** Expand every seat-bearing object across all floors (rows, tables, booths). */
 declare function expandChart(doc: ChartDoc): ExpandedSeat[];
 /** Axis-aligned bounds over every object plus the background image, with padding. */
 declare function chartBounds(doc: ChartDoc): {
@@ -427,6 +547,78 @@ declare function chartBounds(doc: ChartDoc): {
     height: 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.
+ * `labels` are the seat labels the id governs, so a threshold's denominator can
+ * exclude still-hidden seats.
+ */
+interface AvailabilityRule {
+    mode: 'hidden' | 'timed' | 'threshold';
+    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;
+
 /**
  * SeatmapRenderer — the shared canvas rendering core (buyer picker shell).
  *
@@ -447,6 +639,11 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private labelGroup;
     private seats;
     private seatById;
+    /** Multi-floor (Batch 5): the last-set chart + which floor we're rendering. */
+    private chartDoc;
+    private activeFloorId;
+    /** When true on a multi-floor chart, render ALL floors stacked (3D overview). */
+    private stacked;
     /** Interactive node per seat/booth — a Circle for seats, a Rect for booths. */
     private circleById;
     /** Booth block geometry, keyed by booth id (= the unit's rowId). */
@@ -454,6 +651,10 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private statusById;
     private catColor;
     private theme;
+    /** Colorblind-safe mode (Okabe-Ito hues + hollow booked seats). */
+    private colorblind;
+    /** Category order from the doc — the stable index into the CB palette. */
+    private catOrder;
     private selection;
     private selectionRings;
     private hoverRing;
@@ -471,6 +672,12 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private zones;
     private seatSection;
     private catPrice;
+    /** ISO 4217 currency for on-map "FROM …" prices (undefined ⇒ money default). */
+    private currency;
+    /** Section/zone ids to render dimmed (organizer manager: held-back inventory). */
+    private dimmedSections;
+    /** Object id → floor id (multi-floor only) — resolves a deck tap in the 3D stack. */
+    private objectFloor;
     /** Zone id → colour (drives extruded side faces in iso view). */
     private zoneColor;
     private hasSections;
@@ -482,6 +689,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private isoRaf;
     /** Chart centre the iso projection pivots about (bounds centre). */
     private isoCentre;
+    /** rAF for an in-flight camera glide (focusRegion / setRung); 0 = none. */
+    private glideRaf;
     /** Set in destroy() so an in-flight iso tween bails. */
     private destroyed;
     /** Cached scale the section/zone labels were last sized for (scale-compensation). */
@@ -507,7 +716,24 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /** Cumulative gesture movement in px — clicks are suppressed after a real pan/pinch. */
     private moved;
     constructor(container: HTMLDivElement, options?: RendererOptions);
-    setChart(doc: ChartDoc): void;
+    setChart(doc: ChartDoc, opts?: {
+        floorId?: string;
+    }): void;
+    /** The chart to render: all floors stacked (3D overview), the active floor, or
+     *  the whole chart for single-floor charts. */
+    private floorView;
+    /** Toggle the 3D all-floors stacked overview (Batch 5). Re-renders; no-op on
+     *  single-floor charts. The caller re-applies statuses + animates the iso view. */
+    setStacked(on: boolean): void;
+    isStacked(): boolean;
+    /** Switch which floor is shown (2D). Re-renders + re-fits; no-op if unchanged. */
+    setActiveFloor(floorId: string): void;
+    /** Floors for the host's switcher (single-floor charts return one synthetic floor). */
+    getFloors(): {
+        id: string;
+        name: string;
+    }[];
+    getActiveFloorId(): string;
     setStatus(seatIds: string[], status: SeatStatus): void;
     getStatus(seatId: string): SeatStatus;
     getSelection(): ExpandedSeat[];
@@ -541,6 +767,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * inverse) keeps landing on the projected seats/sections.
      */
     setViewMode(mode: 'flat' | 'isometric'): void;
+    /** Current projection — reflects the tween target, not the mid-tween isoT. */
+    getViewMode(): 'flat' | 'isometric';
     /** Iso angle (rad) + y-squash for the current isoT. */
     private isoParams;
     /** Effective vertical scale = stage scale × iso squash — legibility math uses this. */
@@ -579,8 +807,21 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private renderSeats;
     /** A booth renders as a click-selectable rounded block (dims from the doc). */
     private renderBoothUnit;
+    /** The category's display color — Okabe-Ito hue when colorblind-safe is on. */
+    private seatBaseColor;
     /** Apply fill/stroke/opacity for a seat's current status + selection. */
     private paintSeat;
+    /**
+     * Colorblind-safe mode: swap category hues for the Okabe-Ito palette and
+     * render booked seats hollow. Off restores the exact default rendering.
+     */
+    setColorblindSafe(on: boolean): void;
+    /**
+     * Dim the seats of these section/zone ids (organizer manager use) so held-back
+     * inventory is visually distinct on the canvas without hiding it. `null`/empty
+     * clears. Unlike the buyer's applyHidden, the sections stay rendered.
+     */
+    setDimmedSections(ids: string[] | null): void;
     /** Legend hover: highlight one category (dim the rest), or null to clear. */
     setCategoryHighlight(key: string | null): void;
     private renderBackground;
@@ -639,6 +880,14 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private toggleSeat;
     private setSelected;
     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;
     private toLocal;
     private onPointerDown;
     private onPointerMove;
@@ -652,6 +901,27 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private zoomAbout;
     /** Zoom + pan so world-rect `b` fills the viewport (with a small margin). */
     private zoomToBounds;
+    /**
+     * Smoothly glide the camera to frame a section (by id) or a world-space bounds
+     * rect — the Slice 5 "glide in". Pan+zoom tween over ~450ms easeInOutCubic; the
+     * melt/LOD rides the camera every frame. `prefers-reduced-motion` (or
+     * `opts.animate === false`) snaps via zoomToBounds. A grab (pointer-down) or a
+     * newer glide cancels an in-flight one.
+     */
+    focusRegion(target: string | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, opts?: {
+        animate?: boolean;
+    }): void;
+    /** Cancel an in-flight camera glide (a grab or a newer glide interrupts it). */
+    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). */
+    setRung(rung: LodRung): void;
     /** Recompute LOD (cache/labels) after any pan/zoom settles. */
     private afterViewChange;
     /** rAF-coalesced `onViewChange` — at most one host callback per animation frame. */
@@ -668,7 +938,12 @@ interface PickerSeat {
     id: string;
     label: string;
     categoryKey: string;
+    /** Price for the chosen tier when the category has tiers, else the base price. */
     price: number;
+    /** Ticket tiers the seat's category offers (Adult/Child/…); absent when none. */
+    tiers?: CategoryTier[];
+    /** The chosen tier's id — defaults to the first tier; absent when no tiers. */
+    tierId?: string;
 }
 interface HoldConflict {
     label: string;
@@ -679,6 +954,35 @@ interface HoldInfo {
     holdId: string;
     labels: string[];
     expiresAt: number;
+    /** The held seats with their chosen ticket tier — what the host books against. */
+    seats: PickerSeat[];
+}
+/** One category's slice of a section (dot + price + count) for the summary card. */
+interface SectionCategory {
+    key: string;
+    label: string;
+    color: string;
+    price: number;
+    count: number;
+}
+/**
+ * Big-venue section-summary — everything the tapped-section card renders: name,
+ * its zone, live seats-left, price range, and the per-category breakdown.
+ * Computed from the renderer's spatial section membership (Slice 5).
+ */
+interface SectionSummary {
+    id: string;
+    label: string;
+    /** Zone label (from ChartDoc.zones); '' when the section has no zone. */
+    zoneLabel: string;
+    /** Mix/section colour for the card's dot (section.color → zone colour → dominant category). */
+    color: string;
+    /** Free member seats right now. */
+    seatsLeft: number;
+    priceMin: number;
+    priceMax: number;
+    /** Per-category breakdown, cheapest first. */
+    categories: SectionCategory[];
 }
 interface HoldResponse {
     holdId: string;
@@ -697,10 +1001,12 @@ interface PickerTransport {
             salesClosed?: boolean;
             venue?: string | null;
             startsAt?: number | null;
+            currency?: string;
         };
     }>;
     objects(key: string): Promise<{
         seats: Record<string, string>;
+        hidden?: string[];
     }>;
     hold(key: string, labels: string[]): Promise<HoldResponse>;
     bestAvailable(key: string, qty: number, categoryKey?: string): Promise<BestAvailableResponse>;
@@ -722,6 +1028,20 @@ interface PickerCallbacks extends RendererCallbacks {
     onStatusChange?: () => void;
     /** The server declared the event closed (a 409 event_closed). */
     onSalesClosed?: () => void;
+    /**
+     * A section block was tapped at the far/zone rung — the controller has glided
+     * the camera in and passes the computed summary (or null when cleared, e.g.
+     * overview() / zoom-to-zones) so the host can show/hide the summary card.
+     */
+    onSectionFocus?: (summary: SectionSummary | null) => void;
+    /** A deck was tapped in the 3D all-floors overview — host enters that floor in 2D. */
+    onDeckTap?: (floorId: string) => void;
+    /**
+     * Non-blocking selection advice (localized): currently the orphan-seat hint —
+     * the selection would strand a single free seat between unavailable
+     * neighbors. `null` clears a previously shown hint. Never prevents anything.
+     */
+    onHint?: (message: string | null) => void;
     onError?: (err: unknown) => void;
 }
 interface PickerOptions extends PickerCallbacks {
@@ -730,8 +1050,12 @@ interface PickerOptions extends PickerCallbacks {
     maxSelection?: number;
     /** Renderer confirm-card mode (host shows a confirm popover instead of instant cart add). */
     confirmSelection?: boolean;
+    /** ISO 4217 currency for on-map prices (default from money.DEFAULT_CURRENCY). */
+    currency?: string;
     /** Flash a pulse when a seat we didn't touch goes free→taken (live-activity cue). */
     flashOnLiveChange?: boolean;
+    /** Start in colorblind-safe rendering (Okabe-Ito hues + hollow booked seats). */
+    colorblindSafe?: boolean;
 }
 declare class PickerController {
     private readonly opts;
@@ -740,9 +1064,15 @@ declare class PickerController {
     private readonly maxSelection;
     private renderer;
     private _doc;
+    /** Section/zone ids hidden from buyers this event (3.3) — seats vanish, not grey. */
+    private hidden;
     /** label ⇄ id maps — backend speaks labels, the engine speaks ids. */
     private labelToId;
     private labelToSeat;
+    /** seatId → chosen ticket-tier id (absent ⇒ the category's first/default tier). */
+    private seatTiers;
+    /** id → seat, for the section-summary breakdown (renderer members are ids). */
+    private seatById;
     private allIds;
     private ws;
     private reconnectTimer;
@@ -752,6 +1082,10 @@ declare class PickerController {
     private expiryTimer;
     constructor(options: PickerOptions);
     get doc(): ChartDoc | null;
+    /** The chart with hidden sections' seats removed — what buyers actually see. */
+    private visibleDoc;
+    /** Adopt a new hidden set; rebuild the visible chart only if it differs. */
+    private syncHidden;
     currentHold(): HoldInfo | null;
     getRenderer(): ISeatmapRenderer | null;
     seatByLabel(label: string): ExpandedSeat | undefined;
@@ -763,6 +1097,7 @@ declare class PickerController {
         eventName: string;
         venue?: string | null;
         startsAt?: number | null;
+        currency?: string;
     } | null>;
     getSelection(): PickerSeat[];
     clearSelection(): void;
@@ -806,10 +1141,63 @@ declare class PickerController {
         y: number;
     };
     setAccessibilityFilter(types: string[] | null): void;
+    /** Floors for the buyer's switcher (>1 ⇒ show it). Single-floor ⇒ one entry. */
+    getFloors(): {
+        id: string;
+        name: string;
+    }[];
+    getActiveFloorId(): string;
+    /** Switch the shown floor (2D), then re-apply live seat statuses onto it. */
+    setFloor(id: string): void;
+    /** 3D all-floors stacked overview ⇄ active floor. Re-applies statuses after. */
+    setStacked(on: boolean): void;
+    isMultiFloor(): boolean;
+    /** Tap-a-deck-to-enter: leave the 3D stack, drop to flat 2D on `floorId`, and
+     *  tell the host so it can sync its 2D/3D toggle + floor-switcher state. */
+    private handleDeckTap;
+    /** Switch the map projection (2D flat ⇄ 3D isometric). No-op on a flat renderer. */
+    setViewMode(mode: 'flat' | 'isometric'): void;
+    getViewMode(): 'flat' | 'isometric';
+    /** Current LOD rung (for the ZONES/SECTIONS/SEATS pill). */
+    getRung(): LodRung;
+    /** Jump to a rung; ZONES clears any focused summary (back to overview). */
+    setRung(rung: LodRung): void;
+    /** Glide in on a section and surface its summary (same path as a section tap). */
+    focusSection(id: string): void;
+    /** Zoom back out to the whole chart and clear the section-summary card. */
+    overview(): void;
+    /** Glide the camera into a tapped section and emit its computed summary. */
+    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.
+     */
+    private sectionSummary;
     destroy(): void;
     private toSeat;
     private priceFor;
+    private tiersFor;
+    /**
+     * Choose a ticket tier for a selected seat (e.g. Adult → Child). Re-emits the
+     * selection so the host's cart + the eventual hold carry the new tier + price.
+     * `tierId = null` reverts to the category's first (default) tier. No-op if the
+     * seat's category has no tiers or the id isn't one of them.
+     */
+    setSeatTier(seatId: string, tierId: string | null): void;
+    /** PickerSeats (with chosen tier) for a set of held labels. */
+    private seatsForLabels;
     private emitSelectionChange;
+    /** Whether the last emitted hint was non-null (avoids clearing repeatedly). */
+    private hintShown;
+    /**
+     * Orphan-seat advice on manual selection: when the buyer's current picks
+     * strand one (or more) single free seats between unavailable same-row
+     * neighbors, surface a localized, non-blocking hint. Cleared (null) as soon
+     * as the selection stops stranding anyone.
+     */
+    private emitOrphanHint;
+    /** Toggle colorblind-safe rendering at runtime (see PickerOptions.colorblindSafe). */
+    setColorblindSafe(on: boolean): void;
     private emitError;
     private holdCovers;
     private handle409Conflicts;
@@ -823,4 +1211,76 @@ declare class PickerController {
     private scheduleReconnect;
 }
 
-export { ACCESSIBILITY_TYPES, type AccessibilityMeta, type AccessibilityType, type BoothObject, CHART_STORAGE_KEY, type Category, type ChartDoc, type ChartObject, type ChartTheme, type ExpandedSeat, type GAAreaObject, type HoldConflict, type HoldInfo, type ISeatmapRenderer, type PickerCallbacks, PickerController, type PickerOptions, type PickerSeat, type PickerTransport, type Point, type RendererCallbacks, type RendererOptions, type RowObject, type RowSeatSlot, type SeatOverride, type SeatStatus, SeatmapRenderer, type SectionObject, type SelectionLayer, type ShapeObject, type TableObject, type TextObject, type ZoneDef, accessibilityMeta, chartBounds, createRenderer, expandBooth, expandChart, expandRow, expandRowSlots, expandTable, layerOf, objectCenter, pointInPolygon };
+/**
+ * i18n core — deliberately tiny and framework-free so the embed SDK can share
+ * it without dragging in a runtime library (the 60KB-gzipped SDK budget is a
+ * product contract).
+ *
+ * Scope (docs/design-port-plan.md): the buyer surface (picker, public event
+ * page, SDK) ships fully translated in en/es/de/fr; dashboard pages route
+ * their strings through t() as they are rebuilt but ship English this round.
+ *
+ * Keys are flat dot-namespaced strings ("picker.holdSeats"). Interpolation
+ * uses {name} placeholders. Missing keys fall back to English, then to the
+ * key itself — a page never crashes over a translation.
+ */
+type Locale = 'en' | 'es' | 'de' | 'fr';
+declare const SUPPORTED_LOCALES: Locale[];
+type Dict = Record<string, string>;
+/** explicit setting → stored preference → browser language → en */
+declare function resolveLocale(explicit?: string | null, stored?: string | null): Locale;
+declare function getLocale(): Locale;
+/**
+ * Set the active locale. Locale bundles other than English are registered by
+ * the surface that needs them (the picker imports its own es/de/fr bundles;
+ * the dashboard stays English until its translations ship).
+ */
+declare function setLocale(locale: Locale, bundle?: Dict): void;
+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;
+declare function formatDate(value: number | Date, opts?: Intl.DateTimeFormatOptions): string;
+
+/**
+ * Locale bundle loader — keeps non-English translations OUT of the initial
+ * bundle (the 60 KB SDK budget is a product contract) and code-splits each
+ * locale so a page/SDK only downloads the language it actually uses.
+ *
+ * `loadLocale('de')` dynamic-imports the German dictionary, registers it via
+ * setLocale(), and resolves once it's active. English is built in, so
+ * `loadLocale('en')` is synchronous and never fetches. Unknown/unsupported
+ * codes fall back to English without throwing.
+ */
+
+/**
+ * Resolve `code` to a supported locale, load its bundle if needed, and make it
+ * active. Returns the locale that ended up active (English on any failure).
+ */
+declare function loadLocale(code?: string | null): Promise<Locale>;
+
+/**
+ * Money formatting — the ONE place currency rendering happens.
+ *
+ * Ticket money is multi-currency: the org sets a default and each event can
+ * override it (ISO 4217 code delivered with the event/chart payload). Until
+ * those backend fields land, callers fall back to DEFAULT_CURRENCY, which is
+ * kept at EUR so live buyer pages render exactly what they rendered when the
+ * symbol was hardcoded. Flipping an org to USD/INR/… later is data, not code.
+ *
+ * Amounts are in MAJOR units (45 === €45) matching Category.price in
+ * src/core/types.ts. If/when backend money fields arrive in minor units,
+ * convert at the API boundary, not here.
+ */
+declare const DEFAULT_CURRENCY = "USD";
+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;
+/** 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 Dict, type ExpandedSeat, type Floor, type GAAreaObject, type HoldConflict, type HoldInfo, type ISeatmapRenderer, type Locale, type LodRung, type PickerCallbacks, PickerController, type PickerOptions, type PickerSeat, type PickerTransport, type Point, type RendererCallbacks, type RendererOptions, type RowObject, type RowSeatSlot, SUPPORTED_LOCALES, 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, getLocale, hiddenObjectIds, isSectionHidden, layerOf, loadLocale, objectCenter, pointInPolygon, resolveLocale, setLocale, setMoneyLocale, setStringOverrides, stackFloors, t, tCount };