@seatlayer/js 0.77.2 → 0.79.0

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { PickerSeat, PickerGAArea, PickerMapTheme, PickerTransport, PickerSelectionValidator, RendererViewMode, PickerSelectionValidity, ChartTheme, AccessibilityType, FloorLabelStyle, LodRung, SectionSummary, PickerAccessNeed, SeatHoverDetails, AccessibleSectionStep, AvailabilityRefreshOutcome, PickerController, ExpandedSeat } from '@seatlayer/core';
+import { PickerSeat, PickerGAArea, PickerMapTheme, PickerTransport, PickerSelectionValidator, RendererViewMode, PickerSelectionValidity, ChartTheme, AccessibilityType, FloorLabelStyle, LodRung, SectionSummary, PickerAccessNeed, SeatHoverDetails, AccessibleSectionStep, AvailabilityRefreshOutcome, PickerController, ExpandedSeat, TableSelectionDetails, SeatStatus } from '@seatlayer/core';
 export { ExpandedSeat, PickerMapTheme, PickerSelectionValidator, PickerSelectionValidity, PickerSelectionViolation, RendererViewMode, SeatHoverDetails } from '@seatlayer/core';
 import { T as ThemeMode } from './channelsMode-goczEzyt.js';
 export { A as AccessIntentForbidsDetails, a as AccessLinkRecord, b as AccessLinkReveal, c as AccessLinkState, d as AccessLinkStatus, e as AccessLinkStatusRecord, f as ArchiveBlockedDetails, g as AssignmentBuckets, h as AssignmentDropDetails, i as AssignmentResult, B as BucketRow, C as ChannelAccessIntent, j as ChannelAccessSummary, k as ChannelAllocationPage, l as ChannelAttribution, m as ChannelAuditEntry, n as ChannelAuditPage, o as ChannelCounts, p as ChannelListResult, q as ChannelPreviewProjection, r as ChannelRecord, s as ChannelReport, t as ChannelReportLinkRecord, u as ChannelReportLinkReveal, v as ChannelReportResult, w as ChannelReportRow, x as ChannelSeatStatus, y as ChannelState, z as ChannelsCapabilities, D as ChannelsClient, E as ChannelsMode, F as ChannelsModeHost, G as ChannelsRowView, H as ChannelsSeatView, I as ControlRoomActivityEntry, J as ControlRoomSectionMetric, K as ControlRoomSnapshot, L as EventCategoryAssignmentResult, M as EventScopedManageToken, N as EventTableBookingMode, O as EventTableBookingResult, P as IntentSwitchBlockedDetails, Q as InventoryBooking, R as InventoryBookingActivity, S as InventoryBookingDetail, U as InventoryBookingObject, V as InventoryBookingState, W as InventoryBookingsPage, X as InventoryBookingsQuery, Y as LogEntry, Z as LogPage, _ as ManageApi, $ as ManageApiError, a0 as ReportByStatus, a1 as ReportCategoryMeta, a2 as ReportCategoryRow, a3 as ReportResult, a4 as SeatManager, a5 as SeatManagerActionResult, a6 as SeatManagerActivity, a7 as SeatManagerCapability, a8 as SeatManagerConnection, a9 as SeatManagerFilteredSection, aa as SeatManagerMode, ab as SeatManagerOptions, ac as SeatManagerSelectionValidity, ad as SeatManagerTallies, ae as SelectionSourceRow } from './channelsMode-goczEzyt.js';
 import * as _seatlayer_core_core_seatConfidence from '@seatlayer/core/core/seatConfidence';
 import { SeatConfidenceDisclosure } from '@seatlayer/core/core/seatConfidence';
-import { Venue3DHandle } from '@seatlayer/core/view3d';
+import { SeatViewStopName, Venue3DHandle, SeatState3D, SeatView } from '@seatlayer/core/view3d';
 
 /**
  * Buyer access context — the browser half of the Sales Channels contract
@@ -267,6 +267,19 @@ interface StatusChange {
     label: string;
     status: WireStatus;
 }
+/**
+ * What else the frame that carried a section change was carrying.
+ *
+ * The one thing a section listener needs to decide is whether it has to go and
+ * read the map. A connect snapshot names the hidden and closed sections AND
+ * every unit's status in the same frame; a standalone `type:'hidden'` frame
+ * names only the sections. Treating the two alike cost every fresh connection
+ * one redundant HTTP inventory read.
+ */
+interface SectionsMeta {
+    /** This frame also carried the seat statuses, so no read is owed. */
+    withInventory: boolean;
+}
 /** Where reconstructed inventory goes. Implemented over PickerController. */
 interface RealtimeSink {
     /** Apply a batch of label→status changes. Implementations must paint this as
@@ -287,9 +300,15 @@ interface RealtimeSink {
      *  cannot be diffed against what we hold (first snapshot, or the scope's
      *  default itself changed, which redefines every unit we were never told
      *  about), and the sink cannot take a whole projection. */
-    resync(): void | Promise<void>;
-    /** Section availability changed (channel-agnostic; identical for every scope). */
-    onSections?(hidden: string[], closed: string[]): void;
+    resync(opts?: {
+        reason?: 'connect' | 'frame';
+    }): void | Promise<void>;
+    /** Section availability changed (channel-agnostic; identical for every scope).
+     *
+     *  `withInventory` says whether the SAME frame also carried the seat
+     *  statuses — which is the difference between "go and read the map" and
+     *  "the map is right here". See {@link SectionsMeta}. */
+    onSections?(hidden: string[], closed: string[], meta?: SectionsMeta): void;
     /** Scope-projected presence counters. */
     onPresence?(counts: {
         shoppingSessions: number;
@@ -395,15 +414,49 @@ interface PickerControllerLike {
         label: string;
     }>;
     deselect(ids: string[]): void;
+    /** FORCED re-read. Reserved for "I just changed something, tell me the truth". */
     refresh(): Promise<void>;
+    /**
+     * COALESCED re-read, and the one a socket should use.
+     *
+     * `refresh()` was this sink's only option, and it is the forced call: every
+     * connect and every section frame bypassed the controller's snapshot
+     * coalescer and issued its own `/objects?compact=1`. On the measured DesiPass
+     * open that was two redundant full snapshots landing ~1.5 s after the map was
+     * already painted from the bootstrap bundle.
+     *
+     * Optional so a host pinning an older `@seatlayer/core` still works — that
+     * engine simply keeps the forced behaviour it always had.
+     */
+    resync?(opts?: {
+        reason?: 'connect' | 'frame';
+    }): Promise<void>;
+    /**
+     * Paint a whole authoritative projection with no round trip at all.
+     *
+     * Optional for the same reason: where the engine can take one, the socket's
+     * own connect frame IS the snapshot and the HTTP resync never happens.
+     */
+    applyProjection?(projection: {
+        default: string;
+        exceptions: Record<string, string>;
+    }): void;
 }
 interface ControllerSinkOptions {
     /** Pulse seats other buyers take, as the controller's own socket does. */
     flashOnLiveChange?: boolean;
     /** Selected-but-unheld units that stopped being selectable. */
     onSelectedObjectUnavailable?: (labels: string[], reason: 'ineligible' | 'taken') => void;
+    /**
+     * Labels the buyer is holding RIGHT NOW — the hold request is in flight and
+     * `currentHold()` is still null. The server broadcasts `held` before the
+     * hold response lands, so without this the buyer's own echo reads as
+     * "someone else took your seat", the selection is evicted, and the winning
+     * hold is left with nobody attached to it.
+     */
+    ownLabels?: () => Iterable<string>;
     /** Section availability changed and the chart itself needs rebuilding. */
-    onSections?: (hidden: string[], closed: string[]) => void;
+    onSections?: (hidden: string[], closed: string[], meta?: SectionsMeta) => void;
     onStatusChange?: () => void;
 }
 declare function createControllerSink(controller: PickerControllerLike, options?: ControllerSinkOptions): RealtimeSink;
@@ -1815,6 +1868,8 @@ declare class SeatingChart {
     private readonly buyerAssetUrls;
     private readonly immersive;
     private realtime;
+    /** Labels whose hold request is in flight — see ControllerSinkOptions.ownLabels. */
+    private holdingLabels;
     constructor(options: SeatingChartOptions);
     /**
      * Camera x/y/scale is renderer-local and deliberately absent from the native
@@ -2535,6 +2590,370 @@ declare class EmbeddedDesigner {
     private handleMessage;
 }
 
+/**
+ * pickerLegend — the two places the picker explains its colours.
+ *
+ * The price LIST (`.sl-price-row`) is the detail view: colour, name, how many
+ * are left, the offer name, the exact price or spread. It lives in the side
+ * panel on desktop and behind a disclosure inside the bottom sheet on a phone.
+ *
+ * The price RAIL (`.sl-rc`) is the phone's always-visible legend: colour and
+ * price, nothing else, pinned above the map. It exists because on a narrow
+ * layout the list is two gates deep — open the sheet, then open the disclosure
+ * — so a buyer looking at five coloured sections had nothing on screen telling
+ * them what any of them cost.
+ *
+ * They are deliberately NOT the same rendering. A 34px chip cannot carry "N
+ * left" or an offer name, and a rail that truncated its categories would be
+ * worse than one that scrolls. What they must never do is disagree, so both are
+ * painted from the same `sellable`/`left` pass in `syncPrices`, and both take
+ * their dot colour from `colorOf` — which asks the RENDERER, not the document,
+ * because colorblind-safe mode remaps hues inside the renderer and never
+ * touches `doc.categories[].color`.
+ *
+ * Pure: these take values and return strings. Event wiring stays with the
+ * widget, in the same style as pickerTray.ts.
+ */
+
+/** The fields either legend needs off a category. */
+interface LegendCategory {
+    key: string;
+    label: string;
+    color: string;
+    price?: number;
+    tiers?: {
+        id?: string;
+        price: number;
+    }[];
+}
+/** An offer as the widget resolves it. `previousPrice` is nullable, not just
+ *  optional — older workers omit it and current ones send null when there is
+ *  no strike-through price. */
+interface LegendOffer {
+    previousPrice?: number | null;
+    price: number;
+    offerName?: string;
+}
+/**
+ * The half of a legend's inputs both views share. Held as one object so the
+ * widget resolves them once and the two renderings cannot be handed different
+ * answers to the same question.
+ */
+interface LegendDeps {
+    /** On-screen colour — renderer first, document as fallback. */
+    colorOf(category: LegendCategory): string;
+    /** Min/max across tiers, or undefined when the chart carries no price. */
+    rangeOf(category: LegendCategory): {
+        min: number;
+        max: number;
+    } | undefined;
+    /** Single price when there are no tiers. */
+    priceOf(category: LegendCategory): number | undefined;
+    offerOf(key: string): LegendOffer | null | undefined;
+    money(amount: number): string;
+    esc(value: string): string;
+}
+
+type BuyerAssetLoader = (eventKey: string, asset: string) => Promise<Blob>;
+/**
+ * One picker-lifetime cache. Reusing a blob URL avoids downloading an 8K
+ * panorama again when a buyer opens the same row/venue view from another seat.
+ */
+declare class BuyerAssetObjectUrls {
+    private readonly eventKey;
+    private readonly load?;
+    private readonly pending;
+    private readonly created;
+    private disposed;
+    constructor(eventKey: string, load?: BuyerAssetLoader | undefined);
+    /**
+     * External organizer/CDN URLs pass through unchanged. SeatLayer event assets
+     * never do: they require the transport, and a reference for another Event is
+     * refused instead of being loaded anonymously.
+     */
+    resolve(reference: string): Promise<string | null>;
+    dispose(): void;
+}
+
+/**
+ * One performance of the group, already formatted by the wrapper.
+ *
+ * The wrapper owns the date formatting (it has the group's timezone and the
+ * buyer's locale), so the picker never re-derives a date and the night strip in
+ * the tooltip can never disagree with the dates list in the group chrome.
+ */
+interface PerformanceGroupNight {
+    eventKey: string;
+    name: string;
+    /** Short, locale-aware date label for a pill — e.g. "Sat 23 Aug". */
+    shortDate: string;
+}
+/**
+ * A structural mirror of the engine's `SeatMark`.
+ *
+ * The engine type is not on the package barrel, and this seam must not force a
+ * deep import into `@seatlayer/core/core/contracts/renderer` (which is not an
+ * exported subpath). The shapes are identical, so `setSeatMarks` accepts this.
+ */
+interface PartialSeatMark {
+    kind: 'partial';
+    fraction?: number;
+    data?: unknown;
+}
+interface PerformanceGroupPickerInternal {
+    /** Distinguishes dynamic Performance Groups from fixed Season packages. */
+    surface?: 'performance_group' | 'season';
+    performanceCount: number;
+    selectionMode?: 'same_seat' | 'per_performance';
+    submissionState?: () => {
+        complete: number;
+        total: number;
+        ready: boolean;
+    };
+    /**
+     * Chronological performances. Present for both modes: the night strip needs
+     * every night, in order, whichever mode the buyer is in.
+     */
+    nights?: () => PerformanceGroupNight[];
+    /**
+     * PULL, not push. The widget asks for the current marks straight after it has
+     * applied a status batch, so the two always land on the same tick and in the
+     * only order that paints correctly (status first, mark second). A pushed mark
+     * would race the availability read that produced it.
+     *
+     * Returns the full desired mark set PLUS an explicit `null` for every label
+     * that has left `partial` since the last pull — `setSeatMarks` merges, so a
+     * dropped label would otherwise keep its two-tone paint forever.
+     */
+    seatMarks?: () => Record<string, PartialSeatMark | null>;
+    /**
+     * Which performance the tray's seat cards belong to, already formatted —
+     * "Matinée · Sun, Aug 30", or just the date when the performance is unnamed.
+     *
+     * Per-performance mode shows ONE night's chart and therefore one night's
+     * seats, and a card that says only "Section Arena B · Row A · Seat 3" under a
+     * four-row "Your seats by night" list reads as if the other three nights were
+     * dropped. Null in same-seat mode, where every card is every night and the
+     * eyebrow would be noise.
+     */
+    activePerformanceLabel?: () => string | null;
+    /**
+     * Exact dates represented by a same-seat card after a flexible group was
+     * narrowed. Null for an all-dates package and outside Performance Groups.
+     */
+    selectedPerformanceDates?: () => {
+        summary: string;
+        labels: string[];
+    } | null;
+    /**
+     * Switch the map to one night. The wrapper routes this into the SAME path a
+     * date tab takes, so the guards (a live hold, an undecided operation, the
+     * night already being active) are enforced once, in one place.
+     */
+    selectNight?: (eventKey: string) => void;
+    /**
+     * Per-night summary rows for the "Your seats" pane (per-performance only).
+     * `active` marks the night the map is currently showing.
+     */
+    nightSummary?: () => Array<{
+        eventKey: string;
+        name: string;
+        labels: string[];
+        active?: boolean;
+    }>;
+    /**
+     * What the buyer has chosen across the WHOLE run.
+     *
+     * Every count the picker computes for itself — the tray header, the footer,
+     * the booked overlay — is a count of the chart currently on screen, and for a
+     * group that chart is one performance out of several. "1 selected" over a
+     * four-night package is not a small imprecision; it is the wrong number, and
+     * it is the number the buyer checks before paying. Only the wrapper knows the
+     * other nights, so only the wrapper can answer this.
+     *
+     * `seats` is the run TOTAL (tickets), `perPerformance` is the per-night count
+     * when every chosen night has the same one and null when they differ, and
+     * `performancesChosen` is how many nights have any seat at all. Null (or
+     * absent) outside a group, where the picker's own counts are correct.
+     */
+    groupSelectionSummary?: () => {
+        seats: number;
+        performances: number;
+        performancesChosen: number;
+        perPerformance: number | null;
+    } | null;
+    /**
+     * The quiet way out of same-seat selection, when the host opted in with
+     * `allowSelectionModeSwitch`. Null (or absent) means the buyer is told to
+     * pick a seat that is free every night instead — never a dead end.
+     */
+    selectionModeSwitch?: {
+        label: string;
+        activate: () => void;
+    } | null;
+    /** Select one partly-available seat for exactly the dates where it is free. */
+    partialSeatSelection?: {
+        label: (availableCount: number) => string;
+        /** Use the renderer's stable id so reselect targets the exact expanded seat. */
+        activate: (seatId: string, availableEventKeys: string[]) => void;
+    } | null;
+    /** Group-only date controls inside the ordinary seat confirmation card. */
+    confirmDateSelection?: {
+        includedEventKeys: () => string[];
+        availableEventKeys: (seatId: string) => string[];
+        label: (selectedCount: number) => string;
+        apply: (seatId: string, eventKeys: string[]) => Promise<boolean>;
+    } | null;
+    /**
+     * Suppress every per-performance money surface (L7).
+     *
+     * A Performance Group is sold as ONE package: a per-performance subtotal, a
+     * tier picker, or a chip amount is a number the buyer cannot act on and
+     * cannot reconcile with what they will be charged. This used to be a
+     * `display:none` sheet in the wrapper's stylesheet, which left the prices in
+     * the DOM for screen readers, copy-paste and the accessibility tree.
+     */
+    suppressPricing?: boolean;
+}
+
+/**
+ * pickerConfirmCard — the card that stands between a tapped seat and the cart.
+ *
+ * It is one seat's whole story in one anchored popover: who the seat is (the
+ * identity grid), what it costs (the category band), what can be seen from it
+ * (the view thumbnail and the sightline line), and the two buttons that decide
+ * the matter. Raising it, placing it against the seat, wiring its six controls,
+ * committing it and taking it down are all here.
+ *
+ * Extracted from SeatPicker.ts (2026-09-03) so the widget has room to grow
+ * under the app's file-size ratchet, which pins the vendored mirror. Bodies are
+ * verbatim; the only edits are mechanical — the card's own two pieces of state
+ * (`el`, `seat`) live on this class, and every other value the code read off
+ * `this` now comes through {@link ConfirmCardHost}.
+ *
+ * THE HOST IS DELIBERATELY LATE-BOUND. Every member of it is a function the
+ * widget implements by calling its own method, never a captured value: the
+ * picker's tests replace `dismissConfirm`, `reducedMotion`, `scheduleMotion`,
+ * `syncTray`, `canOffer3d`, `enter3d` and `buyerAssetUrls` on the instance, and
+ * a card holding a bound reference from construction time would quietly ignore
+ * all of them. That seam is the same one `SectionCard` keeps for
+ * `sectionNeighbours`.
+ */
+
+/**
+ * The two questions this one card asks.
+ *
+ * `add` is the original: a seat the buyer has tapped but not yet taken.
+ * `remove` is the same card about a seat already in their cart, raised by a
+ * SECOND tap on it — which used to drop the seat silently, with no card and no
+ * notice (client report, 2026-09-04). Same layout, same identity, same price;
+ * only the primary button changes, and Cancel keeps the seat rather than
+ * dropping it.
+ *
+ * Deliberately not a separate card. A buyer taps a seat and expects the thing
+ * that seat's tap always produces; two popovers for one gesture is a second
+ * thing to learn for no gain.
+ */
+type ConfirmCardMode = 'add' | 'remove';
+
+/**
+ * pickerMinimap — the F3 venue-overview minimap: build, layout, static paint,
+ * viewport rectangle, and the pointer/keyboard interactions that pan or focus
+ * from it.
+ *
+ * Lifted out of SeatPicker.ts with the method bodies verbatim — statement for
+ * statement, including canvas call order, which matters here because a 2D
+ * context is a state machine and jsdom cannot exercise it. The ONLY edits are
+ * the indirections through {@link MinimapHost}: `this.controller` →
+ * `this.host.controller`, `this.cssVar` → `this.host.cssVar`, `this.tf` →
+ * the module-level `tfStatic` it always delegated to, and the widget root and
+ * focused-section label behind accessors (SeatPicker replaces both across a
+ * re-mount, so they must be read late, not captured).
+ *
+ * `build()` also takes its mount element as an argument rather than reading
+ * SeatPicker's region map. Everything else — the two-canvas base/blit split,
+ * the drag-capture bookkeeping, the click suppression after a drag — is
+ * unchanged.
+ */
+
+/** What the minimap needs from the widget around it. */
+interface MinimapHost {
+    readonly controller: PickerController;
+    /** The widget root — it carries `data-minimap-open`. A function, not a
+     *  field: SeatPicker rebuilds its root, and a captured one goes stale. */
+    root(): HTMLElement | null;
+    /** Resolved `--sl-*` token value (canvas needs a real colour, not `var()`). */
+    cssVar(name: string): string;
+    /** Label of the last surfaced section card. Backs the minimap caption when
+     *  the renderer snapshot reports no active section. */
+    focusedSectionLabel(): string | undefined;
+}
+declare class PickerMinimap {
+    private readonly host;
+    private miniCanvas;
+    private miniBase;
+    private miniWrap;
+    private miniToggle;
+    private miniLabel;
+    private miniTf;
+    private miniDrag;
+    private miniSuppressClick;
+    /** The buyer dismissed the overview by hand; zoom must not undo that. */
+    private userClosed;
+    constructor(host: MinimapHost);
+    /**
+     * Take the overview off the page entirely.
+     *
+     * The phone does not get a minimap at all any more, and a picker can cross
+     * that breakpoint by rotating. Hiding it with CSS would leave a canvas the
+     * widget keeps redrawing on every pan of a map it is not on screen for, plus
+     * a toggle button in the tab order for a panel nobody can open. So the
+     * instance leaves, and `SeatPicker.minimap` goes back to null.
+     */
+    dispose(): void;
+    /**
+     * Build the overview minimap: a static venue thumbnail (section outlines, or
+     * seat dots when the chart has no sections) with the live viewport rectangle
+     * drawn on top. The rect tracks pan/zoom via the constructor's onViewChange.
+     */
+    build(mount: HTMLElement): void;
+    /**
+     * Reveal or retire the overview from ZOOM rather than from a tap.
+     *
+     * A buyer deep in the seats has lost every label; a buyer at the overview is
+     * looking at the venue already and does not need a second, smaller copy of
+     * it. The toggle button stays exactly as it was — this only decides the
+     * default, and an explicit close still wins until they zoom back out, which
+     * is also where that decision is forgotten.
+     */
+    setAutoOpen(deep: boolean): void;
+    /**
+     * `moveFocus` is false for the zoom-driven reveal. Following focus into a
+     * panel is right when the buyer PRESSED something — they asked to be there.
+     * It is wrong when the panel opened by itself: the buyer is mid-pinch on the
+     * map, and taking the caret to a canvas they never asked for interrupts the
+     * gesture and strands a keyboard user somewhere they did not navigate to.
+     */
+    private setMinimapOpen;
+    /** Re-fit the thumbnail whenever the active floor or complete overview
+     * changes bounds. This is presentation-only; the source chart is untouched. */
+    private layoutMinimap;
+    private syncMinimapLabel;
+    /** Repaint the static overview + rect (floor switch, live open/close). */
+    refreshMinimap(): void;
+    /** Paint the venue overview into the offscreen base canvas. */
+    private drawMinimapStatic;
+    /** Blit the base overview, then stroke the current viewport rectangle on top. */
+    drawMinimapRect(): void;
+    private minimapWorldPoint;
+    private minimapPointerDown;
+    private minimapPointerMove;
+    private minimapPointerUp;
+    private minimapKeydown;
+    /** Minimap click → focus an available section, otherwise pan there. */
+    private minimapJump;
+}
+
 /** What the saved-seat comparison chip needs from the widget around it. */
 interface CompareChipHost {
     /** The live 3D overlay the chip mounts into, or null when 3D is down. */
@@ -2563,6 +2982,12 @@ declare class View3dCompareChip {
     mainButton(): HTMLElement | null;
 }
 
+interface SeatViewChrome {
+    /** Called with every stop change, and with null when the seat view ends. */
+    onStopChange(stop: SeatViewStopName | null): void;
+    dispose(): void;
+}
+
 /**
  * The cart's arithmetic, in ONE place.
  *
@@ -2705,14 +3130,14 @@ declare class SeatPicker implements GaPromptPicker {
     readonly opts: SeatPickerOptions;
     /** @internal */ readonly api: PickerTransport;
     /** Authenticated view media, cached only for this picker lifetime. */
-    private readonly buyerAssetUrls;
+    /** @internal */ readonly buyerAssetUrls: BuyerAssetObjectUrls;
     /** Our own public client, or null when the host injected a transport. */
     private readonly pubApi;
     /** Null for the ordinary public picker — the tokenless path is untouched. */
     private readonly access;
     private realtime;
     private accessEl;
-    private readonly apiBase;
+    /** @internal */ readonly apiBase: string;
     /** @internal */ readonly controller: PickerController;
     /** @internal */ maxTickets: number;
     /** Exact ticket count required before checkout; null keeps ordinary 1..max behavior. */
@@ -2720,9 +3145,9 @@ declare class SeatPicker implements GaPromptPicker {
     private lastSelectionValidity;
     /** Original host pricing, kept separate from live server offer overrides. */
     private readonly hostPricing;
-    private readonly performanceGroup;
+    /** @internal */ readonly performanceGroup: PerformanceGroupPickerInternal | null;
     /** Structural (not CSS) removal of per-performance money — see pickerInternal. */
-    private readonly suppressPricing;
+    /** @internal */ readonly suppressPricing: boolean;
     /** @internal */ root: HTMLDivElement | null;
     private mapHost;
     private rendered;
@@ -2736,10 +3161,14 @@ declare class SeatPicker implements GaPromptPicker {
     private localeGeneration;
     /** @internal */ els: Record<string, HTMLElement>;
     /** Feature 6 anchor regions — positioned flex containers over the map. */
-    private regions;
+    /** @internal */ regions: Record<string, HTMLElement>;
     private ro;
-    private holdTimer;
+    /** @internal */ holdTimer: ReturnType<typeof setInterval> | null;
     private toastTimer;
+    /** The availability read every other caller joins. See refreshOfferAvailability. */
+    private offerReadInFlight;
+    /** When the last SUCCESSFUL availability read landed (0 = never). */
+    private offerReadSettledAt;
     private offerRefreshTimer;
     /** Armed only when the offer schedule has a known future transition (or as a
      * bounded retry after a failed read) — never a fixed-cadence poll. */
@@ -2757,11 +3186,11 @@ declare class SeatPicker implements GaPromptPicker {
     /** @internal */ readonly pricesByChannel: Map<string, ChannelPriceOverride[]>;
     /** @internal */ hold: HoldResult | null;
     /** Latest server expiry for the open hold (moves on extend). */
-    private holdExpiresAt;
+    /** @internal */ holdExpiresAt: number;
     /** True once we handed off to checkout — arms booked-confirmation detection. */
-    private handedOff;
+    /** @internal */ handedOff: boolean;
     /** Guards single onBooked + single success overlay per hold. */
-    private bookedShown;
+    /** @internal */ bookedShown: boolean;
     /**
      * The last hold attempt lost its seats.
      *
@@ -2788,8 +3217,12 @@ declare class SeatPicker implements GaPromptPicker {
     private paymentOptions;
     /** The mounted payment card, while one is up. */
     private checkoutPanel;
-    private extendEl;
+    /** @internal */ extendEl: HTMLDivElement | null;
     private bookedEl;
+    /** The blocking "your seats were released" dialog, while it is up. */
+    private holdExpiredEl;
+    /** What that hold actually held, captured before the state was cleared. */
+    private holdExpiredUnits;
     /** @internal Pending GA units per (area, tier) — see pickerGaPrompt.ts. */
     gaQty: GaQtyMap;
     /** @internal The open quantity prompt (popover or sheet), while one is up. */
@@ -2820,14 +3253,14 @@ declare class SeatPicker implements GaPromptPicker {
     private seatsRevealed;
     private seatsRevealedReport;
     /** The seat the confirm card is about — the same facade as `confirmEl`. */
-    private get confirmSeat();
-    private set confirmSeat(value);
+    /** @internal */ get confirmSeat(): ExpandedSeat | null;
+    /** @internal */ set confirmSeat(seat: ExpandedSeat | null);
     /** The confirm card owns its element and its candidate seat. */
     private confirmCardCache;
     private suppressConfirmationSeatId;
     private tableDialogEl;
-    private tableDialog;
-    private tableDialogHeld;
+    /** @internal */ tableDialog: TableSelectionDetails | null;
+    /** @internal */ tableDialogHeld: boolean;
     private tableDialogReturnFocus;
     /** @internal */ srEl: HTMLDivElement | null;
     private baQty;
@@ -2856,24 +3289,24 @@ declare class SeatPicker implements GaPromptPicker {
     private cbSafe;
     private rungsEl;
     private projectionEl;
-    private buyerView;
+    /** @internal */ buyerView: 'map' | 'venue3d';
     /** @internal */ view3dEl: HTMLDivElement | null;
     /** @internal */ view3dHandle: Venue3DHandle | null;
     /** Monotonic token so a stale async mount (buyer left before OGL finished
      *  loading) never installs its handle over a newer state. */
-    private view3dGen;
+    /** @internal */ view3dGen: number;
     /** Seat whose 2D confirm card launched "See it in 3D"; re-shown on return. */
-    private view3dReturnSeat;
+    /** @internal */ view3dReturnSeat: ExpandedSeat | null;
     /** Current premium 3D journey depth. `null` is the venue; a seat id is the
      * fixed seat-eye state. It lets Back unwind one step before leaving 3D. */
-    private view3dTargetSeatId;
+    /** @internal */ view3dTargetSeatId: string | null;
     /** Inspection-only comparison. These ids never represent cart selection. */
     /** @internal */ view3dCompareSeatIds: string[];
     /** The saved-seat comparison chip — owned by pickerView3dNav.ts. */
     /** @internal */ readonly view3dCompareChip: View3dCompareChip;
     /** @internal */ view3dCompareEl: HTMLDivElement | null;
     /** @internal */ view3dCompareCleanup: (() => void) | null;
-    private view3dSeatViewChrome;
+    /** @internal */ view3dSeatViewChrome: SeatViewChrome | null;
     /** @internal */ view3dPassportEl: HTMLDivElement | null;
     /** @internal */ view3dPassportCleanup: (() => void) | null;
     private floorsEl;
@@ -2885,45 +3318,45 @@ declare class SeatPicker implements GaPromptPicker {
     /** The 3D "Back to map"/"Back to venue" control while 3D is on. It lives in
      *  the top-left chrome region rather than in the 3D overlay, so it outlives
      *  the overlay's own teardown and must be removed explicitly. */
-    private view3dBack;
+    /** @internal */ view3dBack: HTMLButtonElement | null;
     /** The levels/areas rail while 3D is on. Region chrome for the same reason
      *  the back control is (it shared twelve pixels with the ♿ menu), so like
      *  the back control it outlives the overlay and is removed by hand. */
-    private view3dNav;
+    /** @internal */ view3dNav: HTMLElement | null;
     /** Which chips the price rail last drew, so a repaint that changes them can
      *  send the scroller back to the start without stealing a buyer's own scroll. */
-    private lastRailSignature;
+    /** @internal */ lastRailSignature: string;
     /** The panel's price-band <select>, so the rail's reset chip can keep it in
      *  step. Null when the chart has fewer than two bands and none was built. */
-    private priceSelect;
-    private minimap;
+    /** @internal */ priceSelect: HTMLSelectElement | null;
+    /** @internal */ minimap: PickerMinimap | null;
     private pickerLayoutSize;
-    private priceBandKeys;
-    private focusedCatKey;
+    /** @internal */ priceBandKeys: Set<string> | null;
+    /** @internal */ focusedCatKey: string | null;
     /** "Hide limited-view seats" — mirrored into 3D by `seatState3dFor`. */
-    private limitedViewFilter;
-    private pricesExpanded;
+    /** @internal */ limitedViewFilter: boolean;
+    /** @internal */ pricesExpanded: boolean;
     /** The section card owns its element, collapse state and shown-at clock. */
     private sectionCardCache;
     /** Last surfaced section summary (re-rendered when the price band changes). */
     /** The tapped section the card is holding. A facade over the card in both
      *  directions: reading it must not build chrome, and writing it must not
      *  repaint — see SectionCard.adopt. */
-    private get lastSection();
-    private set lastSection(value);
+    /** @internal */ get lastSection(): SectionSummary | null;
+    /** @internal */ set lastSection(summary: SectionSummary | null);
     /** Previous tray ticket count — first 0→n transition auto-expands the mobile sheet. */
-    private lastTrayCount;
+    /** @internal */ lastTrayCount: number;
     /** The opt-in language switcher, when `languages` named at least two. */
     private langSel;
     /** Previous computed total — drives a single explanatory value bump. */
-    private lastTrayTotal;
+    /** @internal */ lastTrayTotal: number;
     /** Stable item keys prevent tray chips re-animating on unrelated realtime syncs. */
     private lastTrayKeys;
     private bestAvailableBusy;
     private releasingLabels;
     /** Selected labels awaiting the hold response; their own realtime echo can arrive first. */
     private holdingLabels;
-    private ctaPhase;
+    /** @internal */ ctaPhase: 'idle' | 'holding' | 'checkout';
     /** The ♿ control and its menu — one node, in the map's bottom-left corner. */
     private a11yMenu;
     private detachAttention;
@@ -2931,19 +3364,19 @@ declare class SeatPicker implements GaPromptPicker {
      *  part is the engine's; see pickerHoldLapse.ts. */
     private readonly lapse;
     /** Rail scroll listener attached once; the rail repaints many times. */
-    private railEdgesBound;
-    private fsFallback;
+    /** @internal */ railEdgesBound: boolean;
+    /** @internal */ fsFallback: boolean;
     private fsChangeHandler;
     private fsEscHandler;
     /** Host-level event chrome owns the duplicate identity outside full screen. */
     private eventDetailsHidden;
     /** True while the hold note reads "N more selected" — the tick must not overwrite it. */
-    private holdCopyPending;
+    /** @internal */ holdCopyPending: boolean;
     /** Wide-layout ticket panel collapsed (map owns the full width). */
     private sideCollapsed;
     private sideToggleEl;
     /** True once we've asked the host page to pin us fullscreen (framed, no native). */
-    private framedFs;
+    /** @internal */ framedFs: boolean;
     /** Last height (px) posted to a host frame; dedupes redundant reports. */
     private lastPostedHeight;
     /** See `./seatViewThumb`, which the native bridge answers from as well. */
@@ -2969,7 +3402,33 @@ declare class SeatPicker implements GaPromptPicker {
     /** Post `seatlayer:height` to the host when framed and the value changed. */
     private reportFramedHeight;
     /** Full screen via the native API, falling back to a fixed-position overlay (iOS Safari). */
-    private toggleFullscreen;
+    /** @internal */ toggleFullscreen(): void;
+    /**
+     * Is the picker already as big as the screen it is on?
+     *
+     * Measured, not inferred. A host that opens the widget inside its own
+     * full-height modal — DesiPass does exactly this on a phone — hands us a
+     * root whose rect IS the viewport, and there is nothing left for "Full
+     * screen" to give. The tolerance absorbs a hairline of host chrome, a
+     * fractional device pixel ratio and a rubber-banding iOS toolbar; anything
+     * larger than that is a real embed with page around it.
+     */
+    private fillsViewport;
+    /**
+     * Show the "Full screen" pill only where pressing it can change something.
+     *
+     * On a phone inside a host's full-height modal the pill was a dead control
+     * (client report on DesiPass, 2026-09-04): iOS Safari has no element
+     * fullscreen, so the tap fell through to the fixed-position fallback — which
+     * pins the widget to a viewport it was already filling. Nothing moved, and
+     * an affordance that does nothing is worse than one that is not there.
+     *
+     * Narrow only. A desktop embed that happens to be viewport-sized is still
+     * surrounded by browser chrome that native fullscreen removes, so the pill
+     * has something to do there. And an ACTIVE fullscreen always keeps its pill:
+     * that is the only way back out.
+     */
+    private syncFullscreenAffordance;
     private syncFullscreenButtons;
     /**
      * Native element-fullscreen was unavailable or rejected. When framed, a CSS
@@ -3112,7 +3571,9 @@ declare class SeatPicker implements GaPromptPicker {
      * falsely block standing room) — mirrors the public page. Clears live when WS
      * frees a seat up.
      */
-    private syncSoldout;
+    /** @internal */ syncSoldout(categories: Array<{
+        key: string;
+    }>, left: Record<string, number>): void;
     /**
      * Pure sold-out predicate: every SEATED category's free count is 0, there is at
      * least one seated category, and there are no GA areas (GA capacity isn't
@@ -3148,44 +3609,25 @@ declare class SeatPicker implements GaPromptPicker {
     /** Restart one finite CSS animation without leaving a permanent state class. */
     private animateOnce;
     /** Selection feedback belongs on the selected seat, not across the whole map. */
-    private flashPickedSeat;
+    /** @internal */ flashPickedSeat(id: string): void;
     /** A completed hold gets one short map ripple per concrete seat. */
     private flashHeldSeats;
     /** Update only the action affordance; selection callbacks must not refire. */
     /** @internal */ committedSelection(): PickerSeat[];
-    private pendingSelectionCount;
-    private heldTicketCount;
+    /** @internal */ pendingSelectionCount(): number;
+    /** @internal */ heldTicketCount(): number;
     /** @internal */ totalTicketCount(): number;
     /** Held tickets and standing quantities consume the same order-wide cap. */
-    private updateSelectionCapacity;
-    private syncCta;
-    /**
-     * Narrate the money path.
-     *
-     * THE PHASE BELONGS TO THE PROMISE, NOT TO A CLOCK. `checkout` used to clear
-     * itself after a fixed 1,100ms whatever the unawaited hold or handoff was
-     * doing — so the button re-armed while the request was still in flight, and a
-     * buyer could press it again into a hold that had already failed. The phase
-     * now ends where the work ends: `runCheckoutHandoff` returns it to idle when
-     * the handoff settles, and `handleCta`'s catch returns it on failure.
-     */
-    private setCtaPhase;
-    /**
-     * Hand the buyer to checkout and hold the "Opening secure checkout…" state
-     * for exactly as long as that takes.
-     *
-     * The default `onCheckout` is usually synchronous and usually navigates; the
-     * hosted path is a real promise. Awaiting both means the one visible signal
-     * that money is moving cannot expire early, and cannot outlive the work
-     * either.
-     */
+    /** @internal */ updateSelectionCapacity(): void;
+    /** @internal */ syncCta(count?: number, pending?: number): void;
+    /** @internal */ setCtaPhase(phase: 'idle' | 'holding' | 'checkout'): void;
     private runCheckoutHandoff;
     /** Session-scoped capability key: isolated by API origin and event. */
-    private holdStorageKey;
-    private rememberedHoldId;
-    private rememberHold;
-    private forgetHold;
-    private resumeHoldFromServer;
+    /** @internal */ holdStorageKey(): string;
+    /** @internal */ rememberedHoldId(): string | null;
+    /** @internal */ rememberHold(hold: HoldResult): void;
+    /** @internal */ forgetHold(): void;
+    /** @internal */ resumeHoldFromServer(holdId: string, automatic: boolean): Promise<HoldResult | null>;
     private restoreRememberedHold;
     /** Section-bearing objects on the active floor (single-floor → doc.objects). */
     private activeFloorObjects;
@@ -3222,15 +3664,15 @@ declare class SeatPicker implements GaPromptPicker {
      * this would be two ways for the map, the legend, the floors and the 3D
      * snapshot to end up disagreeing about what is filtered.
      */
-    private applyPriceBand;
+    /** @internal */ applyPriceBand(keys: string[] | null): void;
     /** Build projection, rung and floor controls for arena-scale charts. */
     private buildArenaChrome;
     /** Reflect the engine's current LOD rung onto the pill group. */
-    private syncRung;
-    private syncProjection;
+    /** @internal */ syncRung(): void;
+    /** @internal */ syncProjection(): void;
     /** Can this picker offer the 3D venue view? Requires the option (default on),
      *  WebGL2, a chart to render, and a chart small enough to render WELL. */
-    private canOffer3d;
+    /** @internal */ canOffer3d(): boolean;
     /**
      * The seat ceiling for offering 3D. See `max3DSeats` — an explicit host value
      * always wins; otherwise a small/low-core device gets half the desktop budget,
@@ -3238,16 +3680,15 @@ declare class SeatPicker implements GaPromptPicker {
      */
     private max3dSeats;
     /** Reflect the active floor onto the switcher rail. */
-    private syncFloors;
+    /** @internal */ syncFloors(): void;
     /** The tapped-section summary card in all three of its forms. Built lazily:
      *  it reads `els`/`root`, which are assigned after construction. */
     private get sectionCard();
     /** Show (or clear, on null) the tapped-section summary card. */
-    private showSectionCard;
+    /** @internal */ showSectionCard(summary: SectionSummary | null): void;
     private renderSectionCard;
     private collapseSectionCard;
     private sectionCardOnView;
-    private fitSectionStripCount;
     /**
      * Open sections next to the focused one, in authored order.
      *
@@ -3265,8 +3706,8 @@ declare class SeatPicker implements GaPromptPicker {
      */
     private markedSeatAnnouncement;
     /** aria-live readout when keyboard focus lands on a seat. */
-    private announceSeat;
-    private showTableDialog;
+    /** @internal */ announceSeat(seat: ExpandedSeat | null): void;
+    /** @internal */ showTableDialog(table: TableSelectionDetails, held: boolean, returnFocus?: HTMLElement | null): void;
     private renderTableDialogState;
     private confirmTableDialog;
     private cancelTableDialog;
@@ -3280,9 +3721,9 @@ declare class SeatPicker implements GaPromptPicker {
      * `buyerAssetUrls` on the INSTANCE, and the card has to see those.
      */
     private get confirmCard();
-    /** @internal */ showConfirm(seat: ExpandedSeat): void;
+    /** @internal */ showConfirm(seat: ExpandedSeat, mode?: ConfirmCardMode): void;
     private reanchorConfirm;
-    private dismissConfirm;
+    /** @internal */ dismissConfirm(): void;
     /** @internal The card's own button calls the card; this is the seam the
      *  widget's tests press. */
     /** @internal */ commitConfirm(): Promise<void>;
@@ -3292,7 +3733,7 @@ declare class SeatPicker implements GaPromptPicker {
      *  call and replace both on the instance. */
     private inviteCommit;
     private addSeatLabel;
-    private seatViewEnabled;
+    /** @internal */ seatViewEnabled(): boolean;
     /** Every bookable seat (cached) — neighbor heads for the generated panorama. */
     /** @internal */ allSeats(): ExpandedSeat[];
     /**
@@ -3319,7 +3760,32 @@ declare class SeatPicker implements GaPromptPicker {
      * visibilitychange handler owns catching that tab up.
      */
     private scheduleOfferBoundary;
-    /** Debounce the no-store offer read behind a burst of seat-status frames. */
+    /**
+     * Is the answer we hold current enough that asking again would learn nothing?
+     *
+     * True while a read is in flight (its answer is on its way) or while one that
+     * just settled is inside the quiet window.
+     */
+    private offerReadIsCurrent;
+    /**
+     * Debounce the no-store offer read behind a burst of seat-status frames.
+     *
+     * THE SKIP IS DECIDED HERE, WHEN THE REFRESH IS ASKED FOR — not 180 ms later
+     * when the timer fires. Deciding at fire time made the dedupe a race between
+     * this debounce and the quiet window, with 250 − 180 = 70 ms of margin: if
+     * the timer ran even that little late, the window had lapsed and a second,
+     * identical availability read went out. Seventy milliseconds of scheduler
+     * jitter is nothing on a loaded machine, and this optimisation exists for
+     * mid-range phones, where it is nothing on a good day.
+     *
+     * (Caught by the app's test/pickerOpenPathConcurrency.test.ts failing once in
+     * a 462-file parallel run and passing in isolation — the flake was real, and
+     * it was here rather than in the test.)
+     *
+     * The rule is unchanged, only the instant it is evaluated at: a refresh asked
+     * for while the answer is still current is answered by the read that just
+     * happened. A batch arriving past the window still schedules and still reads.
+     */
     private scheduleOfferRefresh;
     /**
      * Pull the server's resolved answer. A failed refresh keeps the last truthful
@@ -3327,7 +3793,9 @@ declare class SeatPicker implements GaPromptPicker {
      * offer is worse than a temporarily stale remaining count.
      */
     private refreshOfferAvailability;
-    private offerPrice;
+    /** The read itself. Never rejects — see the catch. */
+    private readOfferAvailability;
+    /** @internal */ offerPrice(categoryKey: string | undefined): TicketOfferPrice | null;
     private applyChannelPricing;
     private syncOffer;
     /**
@@ -3339,26 +3807,29 @@ declare class SeatPicker implements GaPromptPicker {
     /** @internal */ paidPrice(categoryKey: string | undefined, tierId: string | null | undefined, fallback: number, objectLabel?: string): number;
     /** The half of a legend's inputs the rail and the price list share, resolved
      *  once so the two renderings cannot be given different answers. */
-    private legendDeps;
+    /** @internal */ legendDeps(): LegendDeps;
     /** Paint the phone's always-visible legend; the chip HTML lives in
      *  pickerLegend.ts. A legend of ONE teaches nothing, so it stays away. */
-    private syncPriceRail;
-    private syncPrices;
+    /** @internal */ syncPriceRail(categories: LegendCategory[], left: Record<string, number>, deps?: LegendDeps): void;
+    /** @internal */ syncPrices(): void;
     /** Tap a price row → filter + frame that category on the map; tap again to
      *  clear. Shares `priceBandKeys` with the band selector so the row-dim state
      *  has one source of truth (and each control resets the other). */
-    private focusCategory;
+    /** @internal */ focusCategory(key: string): void;
     /**
      * Live-activity strip: turn WS availability deltas into one quiet line of
      * social proof ("2 seats just taken in VIP · 118 left"). Diffs per-category
      * counts on every status change — no per-seat payload needed. Skips the very
      * first computation (initial load is not "activity").
      */
-    private narrateAvailability;
-    private lastCatAvail;
-    private lastAvailFloorId;
-    private availQuietUntil;
-    private liveTimer;
+    /** @internal */ narrateAvailability(categories: Array<{
+        key: string;
+        label: string;
+    }>, left: Record<string, number>): void;
+    /** @internal */ lastCatAvail: Record<string, number> | null;
+    /** @internal */ lastAvailFloorId: string;
+    /** @internal */ availQuietUntil: number;
+    /** @internal */ liveTimer: ReturnType<typeof setTimeout> | null;
     /** A live delta took one of OUR selected (not yet held) seats — evict + tell the buyer. */
     private evictTakenSelections;
     /** @internal */ syncTray(): void;
@@ -3379,7 +3850,7 @@ declare class SeatPicker implements GaPromptPicker {
     private fitTranslatedRows;
     private emitSelectionValidity;
     /** Paint the bottom-sheet's collapsed one-liner (pickerTray.ts builds it). */
-    private renderPeek;
+    /** @internal */ renderPeek(count: number, total: number, pendingCount: number, bump?: boolean): void;
     /**
      * Release one buyer-visible held LINE. That is one label for a seat, and every
      * unit label behind a grouped GA line — a buyer who presses × on
@@ -3388,11 +3859,11 @@ declare class SeatPicker implements GaPromptPicker {
     private removeHeldLabels;
     private handleChangeSeats;
     /** @internal */ handleCta(): Promise<void>;
-    private startHoldTimer;
-    private stopHoldTimer;
+    /** @internal */ startHoldTimer(expiresAt: number): void;
+    /** @internal */ stopHoldTimer(): void;
     /** Show/refresh (or hide) the "Need more time?" prompt with the live seconds left. */
-    private setExtendPrompt;
-    private handleExtend;
+    /** @internal */ setExtendPrompt(show: boolean, ms: number): void;
+    /** @internal */ handleExtend(): Promise<void>;
     /**
      * Fire the booked-confirmation state once the buyer's held seats settle to
      * booked. The controller clears its own hold the moment every held label reads
@@ -3431,7 +3902,7 @@ declare class SeatPicker implements GaPromptPicker {
      * The default branch is the literal call that stood here before hosted
      * checkout existed, unchanged, so nothing about an existing integration moves.
      */
-    private checkoutHandoff;
+    /** @internal */ checkoutHandoff(hold: HoldResult, seats: PickerSeat[]): Promise<void>;
     /**
      * Take the money ourselves, through the organizer's own gateway.
      *
@@ -3457,8 +3928,8 @@ declare class SeatPicker implements GaPromptPicker {
     private openCheckoutPanel;
     private closeCheckoutPanel;
     /** Assemble the stable {@link CheckoutHandoff} from a hold's server line items. */
-    private buildHandoff;
-    private emitHoldChange;
+    /** @internal */ buildHandoff(hold: HoldResult): CheckoutHandoff;
+    /** @internal */ emitHoldChange(): void;
     /** @internal */ toast(msg: string, tone?: 'neutral' | 'success' | 'warning' | 'error', action?: {
         label: string;
         onClick: () => void;
@@ -3681,55 +4152,20 @@ declare class SeatPicker implements GaPromptPicker {
      *  source compatibility but coerce to `flat` with a one-time deprecation warn. */
     private perspectiveWarned;
     private normalizeInitialView;
+    private emitAnalytics;
+    /** @internal */ emit3dAnalytics(event: string, props?: Record<string, unknown>): void;
     /** Current buyer view: the flat map, or the interactive 3D venue. */
     getBuyerView(): SeatPickerBuyerView;
-    /**
-     * Switch between the flat seat **Map** and the interactive **3D venue** view —
-     * the same control the buyer's on-widget `Map | 3D` toggle drives.
-     *
-     * Entering `'venue3d'` with `opts.flyToSeatId` runs the cinematic tour: the
-     * camera flies to the seat and holds in the live scene (a chip offers the
-     * 360° view-from-seat). When the widget is **already** in the 3D
-     * view, the camera simply flies to the requested seat — the GL scene is not
-     * torn down or rebuilt, so there is no flash or re-entry.
-     *
-     * No-op when the view is unchanged and no `flyToSeatId` is given, or when 3D is
-     * unavailable for this chart.
-     *
-     * @param view              `'map'` for the flat picker, `'venue3d'` for the 3D venue.
-     * @param opts.flyToSeatId  When entering (or already in) `'venue3d'`, the seat
-     *                          id to fly the camera to — cinematic → live seat view.
-     *                          Ignored when `view` is `'map'`.
-     *
-     * @example
-     * // Public 3D tour entry — enter 3D and fly straight to the buyer's seat:
-     * picker.setBuyerView('venue3d', { flyToSeatId: 'A-12' });
-     */
+    /** Switch the buyer between the map and the 3D venue. */
     setBuyerView(view: SeatPickerBuyerView, opts?: SeatPickerBuyerViewOptions): void;
-    /** SeatStatus → the view3d palette state. Selection is layered separately. */
-    private seatState3dFor;
-    /** Push the full live availability snapshot into the 3D handle (selection is
-     *  preserved inside the module). Cheap enough per status delta. */
-    private pushAvailabilityTo3d;
-    /** Mirror the authoritative widget selection into the 3D handle. */
+    /** @internal */ seatState3dFor(seat: ExpandedSeat): SeatState3D;
+    /** @internal */ pushAvailabilityTo3d(): void;
     /** @internal */ syncSelectionTo3d(): void;
-    /** Build the view-from-seat panorama the cinematic dissolves into — reuses the
-     *  exact input path as the 2D `openSeatView` (organizer photo, else generated). */
-    private seatViewFor3d;
-    /** Route decoupled analytics into the host callback, tagged buyer. */
-    private emitAnalytics;
-    /** @internal */ emit3dAnalytics(event: string, props?: Record<string, unknown>): void;
-    /** A 3D seat tap runs the SAME selection path as a 2D tap: toggle through the
-     *  controller, then raise the shared confirm card (bottom-sheeted in 3D). */
-    private onView3dSeatPick;
-    /** The arrival caption for a seat-eye landing; assembled in pickerSeatViewChrome. */
-    private seatViewCaption;
-    /** Explain a 3D seat that INVENTORY refuses — never one the buyer's own
-     * filters merely dimmed, which stays buyable exactly as it is in 2D. Category
-     * colour remains visible in the venue; this card names the availability state
-     * explicitly so yellow never has to carry both meanings. */
-    private showUnavailable3dSeat;
-    private dismissUnavailable3dSeat;
+    /** @internal */ seatViewFor3d(seatId: string): Promise<SeatView | null>;
+    /** @internal */ onView3dSeatPick(seatId: string): void;
+    /** @internal */ seatViewCaption(seatId: string): string;
+    /** @internal */ showUnavailable3dSeat(seat: ExpandedSeat, visualState: SeatState3D, status: Exclude<SeatStatus, 'free'>): void;
+    /** @internal */ dismissUnavailable3dSeat(): void;
     private saveView3dComparisonSeat;
     /** @internal */ clearView3dComparison(): void;
     /** @internal */ view3dComparisonSnapshot(seatId: string): {
@@ -3746,26 +4182,14 @@ declare class SeatPicker implements GaPromptPicker {
         accessibility: string;
         confidence: _seatlayer_core_core_seatConfidence.SeatConfidenceDisclosure;
     } | null;
+    /** @internal */ enter3d(flySeatId?: string): Promise<void>;
+    /** @internal */ publish3dTopInset(): void;
+    /** @internal */ exit3d(): void;
     /** The two dialogs INSIDE the 3D overlay — see pickerView3dModals.ts. */
     private openSeatConfidencePassport;
-    private closeSeatConfidencePassport;
-    private openView3dComparison;
-    private closeView3dComparison;
-    private enter3d;
-    /**
-     * Publish how much room the picker's own top-left chrome takes, as
-     * `--sl-3d-top-inset` on the widget root.
-     *
-     * The 3D layer draws its "Live seat-eye view · …" caption in the same twelve
-     * pixels. That caption is engine surface with its position written inline, so
-     * the widget cannot move it; publishing the measurement is the seam the
-     * engine needs to read one day, and it costs nothing until it does. The
-     * widget's own rules already use it, which is why it is measured rather than
-     * assumed: the region wraps, and a chart with an accessibility flag beside
-     * the back button is two rows tall.
-     */
-    private publish3dTopInset;
-    private exit3d;
+    /** @internal */ closeSeatConfidencePassport(restoreFocus?: boolean): void;
+    /** @internal */ openView3dComparison(): void;
+    /** @internal */ closeView3dComparison(restoreFocus?: boolean): void;
     /** Current active/restored hold reflected in the tray. */
     getCurrentHold(): HoldResult | null;
     /** Explicit host-driven hold restore (automatic session restore is on by default). */
@@ -3790,6 +4214,21 @@ declare class SeatPicker implements GaPromptPicker {
      * when a fresh bearer is held; the map and the realtime feed resume with it.
      */
     refreshAccess(): Promise<boolean>;
+    /**
+     * Clear the decision surfaces before an interrupt covers them.
+     *
+     * A confirm card, a table dialog and a GA prompt are all mid-decision UI
+     * about a specific seat, and every one of them is asking a question the
+     * buyer can no longer answer once we are raising an interrupt: the hold's
+     * seats went back on sale, or the session that could see them has ended.
+     * Left up, they sit behind the veil still showing a candidate and an
+     * Add button, so the interrupt is not the only surface and the widget looks
+     * like it is asking two things at once (owner review at 390px).
+     *
+     * Focus is deliberately NOT restored by any of these: the interrupt takes it
+     * a frame later, and handing it back to the map first would fight that.
+     */
+    private clearDecisionSurfaces;
     /**
      * The buyer-facing access state. Plain language, no internal vocabulary, and
      * never a channel name, id or count — the buyer is told what happened and
@@ -3800,7 +4239,45 @@ declare class SeatPicker implements GaPromptPicker {
      * inventory and never silently drops a buyer's cart (guide §9).
      */
     private showAccessPanel;
+    /**
+     * What the recovery screen's button actually does.
+     *
+     * IN PLACE FIRST, ALWAYS. `refreshAccess` re-bootstraps the session, re-reads
+     * the chart and restarts the socket without the map ever going away, and it
+     * takes this screen down itself the moment the fresh session is live. That is
+     * the whole of the happy path, and it is the one the buyer should get: a page
+     * reload throws away the map, the scroll position and the zoom, and on a
+     * hosted checkout it can cost them the query string that got them here.
+     *
+     * A RELOAD IS THE LAST RESORT, AND ONLY WHEN NOBODY ELSE IS LISTENING. If the
+     * host passed `onAccessUnavailable` it has already been told and may be
+     * running its own recovery — navigating its page out from under it would
+     * destroy that. So the fallback fires only for an unattended embed, where
+     * there is genuinely nothing else left to try.
+     */
+    private recoverAccess;
     private dismissAccessPanel;
+    /**
+     * The hold ran out under the buyer's feet — say so, and block.
+     *
+     * A toast was the wrong shape for this: it left a map still showing the
+     * seats as theirs, a cart still totalling them and a CTA that could not
+     * work, and it was gone in four seconds. Everything the buyer can see is
+     * stale, so the picker stops until they have acknowledged it.
+     */
+    private showHoldExpired;
+    private dismissHoldExpired;
+    /**
+     * "Start again": put the picker back to the state it would have been in had
+     * the buyer just arrived.
+     *
+     * The hold state itself was already cleared by `onHoldExpired` — what is
+     * left is everything that was still SHOWING it. The selection goes (with any
+     * confirm card or table dialog on top of it), the lapse note goes, the cart
+     * and CTA are recomputed from the now-empty selection, and the map walks
+     * back out to the venue so the buyer starts where they started.
+     */
+    private restartAfterHoldExpiry;
     destroy(): void;
 }
 
@@ -4378,7 +4855,8 @@ declare class SeasonPicker {
  * picker wire contract:
  *
  *   • `{ type: 'seatlayer:height', px:number }`      — grow the iframe to `px`.
- *   • `{ type: 'seatlayer:fullscreen', on:boolean }` — pin/unpin over the host.
+ *   • `{ type: 'seatlayer:fullscreen', on:boolean, background?:string }`
+ *                                                    — pin/unpin over the host.
  *
  * A framed picker cannot escape its own iframe with CSS, so it delegates both
  * concerns to the host. `attachPickerFrame` wires those two behaviours onto a