@seatlayer/js 0.104.1 → 0.105.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -19,6 +19,49 @@ import { ChartDoc, AvailabilityRule, ExpandedSeat, ChartTheme } from '@seatlayer
19
19
  */
20
20
  type ThemeMode = 'light' | 'dark' | 'auto';
21
21
 
22
+ interface SeatStoryEntry {
23
+ id: number;
24
+ at: number;
25
+ action: string;
26
+ origin?: {
27
+ kind: 'buyer' | 'api_key' | 'staff' | 'system';
28
+ label: string | null;
29
+ } | null;
30
+ via?: 'control_room' | 'dashboard' | 'api' | null;
31
+ by?: string | null;
32
+ byYou?: boolean;
33
+ note?: string | null;
34
+ ref?: string | null;
35
+ buyer?: string | null;
36
+ }
37
+ interface SeatStoryPage {
38
+ label: string;
39
+ total: number;
40
+ counts: {
41
+ action: string;
42
+ count: number;
43
+ }[];
44
+ entries: SeatStoryEntry[];
45
+ nextBefore: number | null;
46
+ /** Absent on an API before v2. */
47
+ booking?: {
48
+ ref: string;
49
+ displayRef?: string | null;
50
+ order: {
51
+ id: string;
52
+ displayRef: string;
53
+ buyerName: string | null;
54
+ buyerEmailDomain: string | null;
55
+ } | null;
56
+ } | null;
57
+ /** The cart the seat is in right now (CR15): when it runs out, where it was made, how many seats. Never who. */
58
+ cart?: {
59
+ expiresAt: number;
60
+ seats: number;
61
+ where: string | null;
62
+ } | null;
63
+ }
64
+
22
65
  /**
23
66
  * Sales-channel planning — the pure, DOM-free half of Channels mode.
24
67
  *
@@ -416,33 +459,6 @@ declare function dropReviewRows(details: AssignmentDropDetails | null | undefine
416
459
  /** Plain-language state badge text (§9: no internal vocabulary on user surfaces). */
417
460
  declare function stateBadge(state: ChannelState | 'builtin'): string;
418
461
 
419
- /**
420
- * Organizer manage-surface client for workers/api (the `/v1/events/:key/*`
421
- * inventory routes + the public realtime channel). Companion to api.ts (the
422
- * buyer `/pub/*` client) — kept separate because the manage surface is
423
- * token-authed (Bearer) and cross-origin from the CMS:
424
- *
425
- * - Writes + reports send `Authorization: Bearer <token>`. Browser code must
426
- * use a short-lived, event-scoped organizer grant (`mse_…`, minted by a
427
- * trusted backend). The low-level client retains tenant-secret (`sk_…`)
428
- * compatibility for trusted server runtimes only; never pass one to
429
- * SeatManager or any other browser bundle.
430
- * - `credentials: 'omit'` — there is no session cookie; the CMS runs
431
- * cross-origin. The worker's credentialed CORS still echoes the CMS origin.
432
- * - chart geometry and authored media use authenticated organizer Event
433
- * routes. A manage bearer is not buyer authority and is never sent to
434
- * `/pub`. The seat STATE reads are private too. `/pub/.../objects` and an unticketed
435
- * `/pub/.../subscribe` both answer with the BUYER projection, which shows
436
- * inventory the caller may not buy as a neutral `blocked` — so an organizer
437
- * reading them sees its own channel allocations as blocked seats. Both now
438
- * go through the token: `/v1/events/:key/objects` for the snapshot, and a
439
- * `/v1/events/:key/subscribe-tickets` mint for the socket's scope.
440
- *
441
- * Managed sales are deliberately not exposed by this browser client. Create
442
- * them from trusted server code through the inventory booking API; SeatManager
443
- * exposes only the organizer operations it can actually complete itself.
444
- */
445
-
446
462
  /** One page of the organizer-only label → channel projection. */
447
463
  interface ChannelAllocationPage {
448
464
  assignmentVersion: number;
@@ -497,6 +513,7 @@ interface ChannelPreviewProjection {
497
513
  };
498
514
  }
499
515
  declare class ManageApiError extends Error {
516
+ static [Symbol.hasInstance](value: unknown): value is ManageApiError;
500
517
  status: number;
501
518
  code?: string;
502
519
  /** Present when a block/unbook 409s because seats were just taken. */
@@ -585,12 +602,22 @@ interface ControlRoomActivityEntry {
585
602
  interface ControlRoomSnapshot {
586
603
  version: number;
587
604
  currency: string;
605
+ /** In guests: a flexible table of 6 booked for 2 is 2 booked and 4 blocked. */
588
606
  totals: {
589
607
  free: number;
590
608
  held: number;
591
609
  booked: number;
592
610
  blocked: number;
593
611
  };
612
+ /** The same moment in seats, every chair in its table's status (newer APIs). The room counts these.
613
+ * `reserved`: the seats in an active reservation, a subset of `blocked` (newer APIs). */
614
+ seatTotals?: {
615
+ free: number;
616
+ held: number;
617
+ booked: number;
618
+ blocked: number;
619
+ reserved?: number;
620
+ };
594
621
  /** Configured value attached to booked inventory, never payment revenue. */
595
622
  bookedValue: {
596
623
  gross: number;
@@ -619,6 +646,8 @@ interface ControlRoomSnapshot {
619
646
  };
620
647
  /** Present on workers that support reload-safe activity hydration. */
621
648
  activity?: ControlRoomActivityEntry[];
649
+ /** label → name where it differs, e.g. a standing place's area (newer APIs; only when such labels are in `activity`). */
650
+ displayLabels?: Record<string, string>;
622
651
  event: {
623
652
  key: string;
624
653
  name: string;
@@ -636,6 +665,8 @@ interface LogEntry {
636
665
  interface LogPage {
637
666
  entries: LogEntry[];
638
667
  nextBefore: number | null;
668
+ /** label → name where it differs, e.g. a standing place's area (newer APIs). */
669
+ displayLabels?: Record<string, string>;
639
670
  }
640
671
  interface EventCategoryAssignmentResult {
641
672
  ok: true;
@@ -896,6 +927,11 @@ declare class ManageApi {
896
927
  ok: true;
897
928
  freed: number;
898
929
  }>;
930
+ /** An event-scoped call for a lazily loaded tool (the manager-extras chunk keeps its own paths). */
931
+ eventRequest<T>(key: string, path: string, init?: {
932
+ method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
933
+ body?: unknown;
934
+ }): Promise<T>;
899
935
  /** Cancel bookings — return BOOKED seats to free (credit not refunded).
900
936
  * Guarded by the original booking reference. */
901
937
  unbook(key: string, labels: string[], bookingRef: string): Promise<{
@@ -916,6 +952,20 @@ declare class ManageApi {
916
952
  * chart currently does — what "Reset to chart defaults" would put back.
917
953
  * Requires `event:view`.
918
954
  */
955
+ /** The Control room's ⌘K bookings: orders matching a reference, ticket code,
956
+ * name, email or phone (at most 20, newest first). Requires
957
+ * `event:orders:read` on a SeatLayer-checkout event. */
958
+ lookupOrders(key: string, q: string): Promise<{
959
+ orders: Array<{
960
+ id: string;
961
+ displayRef: string;
962
+ status: string;
963
+ buyerName: string | null;
964
+ buyerEmail: string | null;
965
+ seatLabels: string[];
966
+ }>;
967
+ more: boolean;
968
+ }>;
919
969
  categoryDifferences(key: string): Promise<EventCategoryDifferences>;
920
970
  /** Put every unit (or only `labels`) back on the chart's category, in one
921
971
  * write. Requires `event:categories:manage`. */
@@ -1111,6 +1161,8 @@ declare class ManageApi {
1111
1161
  }[];
1112
1162
  nextBefore: number | null;
1113
1163
  }>;
1164
+ /** One seat's history with who, how, the note and the booking (board CR22). An older API answers the plain rows. */
1165
+ seatStory(key: string, label: string, before?: number, action?: string): Promise<SeatStoryPage>;
1114
1166
  controlRoom(key: string, windowMinutes?: number): Promise<ControlRoomSnapshot>;
1115
1167
  /** Allocation beside immutable booking-time channel attribution. */
1116
1168
  channelReport(key: string): Promise<ChannelReportResult>;
@@ -1153,19 +1205,19 @@ declare class ManageApi {
1153
1205
  */
1154
1206
 
1155
1207
  /**
1156
- * What the map's colours mean: how full each place is, or its ticket type.
1157
- * ONE setting drives the blocks, the seats and the minimap together, so a
1158
- * colour never changes meaning as the organizer zooms. It is the View menu's
1159
- * category-colours state, shown as a choice (`type` = category colours on).
1208
+ * What the map's colours mean. ONE setting drives the blocks, the seats and
1209
+ * the minimap together. Each tool opens in the mode that answers its question
1210
+ * (Categories in `type`, Channels in `channel`, the rest in `status`), and the
1211
+ * organizer's own choice is remembered per tool.
1160
1212
  */
1161
- type ColourBy = 'full' | 'type';
1213
+ type ColourBy = 'status' | 'type' | 'channel';
1162
1214
 
1163
1215
  /**
1164
1216
  * The control room's View menu (plan item 5, slice D).
1165
1217
  *
1166
1218
  * Toggles that change how the map READS, never what it holds: seat labels,
1167
- * row labels, channel colours, booking momentum — and category colours, which
1168
- * the legend offers as "Colour by: How full · Ticket type".
1219
+ * row labels and booking momentum. What the colours mean is the map's own
1220
+ * Colour by menu (Status · Ticket type · Channel), not this one.
1169
1221
  * The letters are the ones seats.io operators already know (S · R · G · H ·
1170
1222
  * M), ridden on Shift because the tool tabs own the bare letters (S is
1171
1223
  * Sections, G is Categories, M is Monitor).
@@ -1197,7 +1249,7 @@ interface MapView {
1197
1249
  * nothing here emits a byte of runtime JavaScript.
1198
1250
  */
1199
1251
 
1200
- type SeatManagerMode = 'view' | 'inspect' | 'select' | 'filterSections' | 'block' | 'sections' | 'categories' | 'tables' | 'channels';
1252
+ type SeatManagerMode = 'view' | 'inspect' | 'select' | 'filterSections' | 'block' | 'reserve' | 'sections' | 'categories' | 'tables' | 'channels';
1201
1253
  /** Short-lived, event-scoped browser credential minted by a trusted backend. */
1202
1254
  type EventScopedManageToken = `mse_${string}`;
1203
1255
  /**
@@ -1209,6 +1261,17 @@ type EventScopedManageToken = `mse_${string}`;
1209
1261
  type SeatManagerCapability = 'event:view' | 'event:block' | 'event:categories:manage' | 'event:tables:manage' | 'event:cancel' | 'event:reports' | 'event:channels:view' | 'event:channels:manage';
1210
1262
  /** DO seat status — 'blocked' has no engine analogue (→ 'not_for_sale'). */
1211
1263
  type DoStatus = 'free' | 'held' | 'booked' | 'blocked';
1264
+ /** What the host knows about the sale (board CR18). Every field is optional. */
1265
+ interface SeatManagerSale {
1266
+ /** The host's own words for the sale, as a pill beside the event name in full screen: "On sale", "Paused". */
1267
+ status?: string;
1268
+ /** The pill's colour: `ok` green (the default), `warn` amber, `muted` grey. */
1269
+ tone?: 'ok' | 'warn' | 'muted';
1270
+ /** When sales opened, epoch ms: Watch before the first sale says "Sales went live 4 minutes ago". */
1271
+ openedAt?: number;
1272
+ /** The buyers' event page: Watch before the first sale offers "Open the event page". Leave it out while buyers cannot open it. */
1273
+ pageUrl?: string;
1274
+ }
1212
1275
  /** Live KPI snapshot pushed to `onTallies` on every state change. */
1213
1276
  interface SeatManagerTallies {
1214
1277
  free: number;
@@ -1387,17 +1450,110 @@ interface SeatManagerOptions {
1387
1450
  */
1388
1451
  themeMode?: ThemeMode;
1389
1452
  /**
1390
- * What the map's colours mean when it opens: `full` (how full each block and
1391
- * seat is) or `type` (ticket type, as buyers see it). Defaults to the
1392
- * organizer's last choice, else `full`. The legend beside the map switches it.
1453
+ * What the map's colours mean when a tool opens: `status` (what a buyer can
1454
+ * buy now), `type` (ticket type) or `channel` (who can sell each seat; the
1455
+ * Channels tool only). Without it each tool opens in its own mode —
1456
+ * Categories by ticket type, Channels by channel, the rest by status — and
1457
+ * the organizer's choice per tool is remembered. The map's Colour by menu
1458
+ * switches it. `full` is the old name of `status`.
1459
+ */
1460
+ colourBy?: 'status' | 'type' | 'channel' | 'full';
1461
+ /**
1462
+ * "Open order" on a booking the ⌘K search found (needs `event:orders:read`).
1463
+ * The host shows the order its own way — the dashboard opens its Orders
1464
+ * drawer. `displayRef` is the number printed on the ticket, which the host
1465
+ * can search by. Without it the search still shows and selects the seats.
1466
+ */
1467
+ onOpenOrder?: (order: {
1468
+ id: string;
1469
+ displayRef: string;
1470
+ }) => void;
1471
+ /**
1472
+ * The live numbers strip under the bar (sold, in a cart, free, blocked,
1473
+ * value, viewing). Default true. Pass false when your page already shows
1474
+ * these numbers, e.g. in its own event header (board CR04): the map gets
1475
+ * the room. Read once at mount.
1476
+ */
1477
+ kpis?: boolean;
1478
+ /**
1479
+ * Open at one section (its id or its name), as a link from a report does
1480
+ * (board CR24): the room frames it once the map is up. Arriving never
1481
+ * switches task or selects seats; a section that is gone, closed or hidden
1482
+ * says so.
1483
+ */
1484
+ focusSection?: string;
1485
+ /**
1486
+ * Open at one seat, by its label (board CR24): the room frames it, selects
1487
+ * it and shows its card — in Watch, its facts and history. A label that is
1488
+ * not on the chart says so.
1393
1489
  */
1394
- colourBy?: 'full' | 'type';
1490
+ focusSeat?: string;
1491
+ /**
1492
+ * Open at several seats, by label — an order's (audit m43): the room frames
1493
+ * them together and selects them all. With more than one it takes the place
1494
+ * of `focusSeat`; a host may send both, and an older SDK keeps the one seat.
1495
+ */
1496
+ focusSeats?: string[];
1497
+ /** Open at the seats of one ticket type (its key or name), framed together (board CR24). */
1498
+ focusCategory?: string;
1499
+ /**
1500
+ * Where the organizer came from, for a line at the top of the map — "From
1501
+ * Performance · Arena B · selling fast" — with the way back (board CR24).
1502
+ */
1503
+ arrivedFrom?: {
1504
+ from: string;
1505
+ where?: string;
1506
+ why?: string;
1507
+ back?: {
1508
+ label: string;
1509
+ go: () => void;
1510
+ };
1511
+ };
1512
+ /**
1513
+ * "See the trend in Performance" on the header numbers' card (board CR24).
1514
+ * `sectionId` is the section that moved most lately, when one did. Without
1515
+ * it the numbers keep their plain title.
1516
+ */
1517
+ onOpenTrend?: (focus: {
1518
+ kpi: string;
1519
+ sectionId?: string;
1520
+ }) => void;
1395
1521
  /**
1396
1522
  * Keep the canvas painting even when the tab is hidden/backgrounded (a war-room
1397
1523
  * board on a second monitor). Calls `forceDraw()` after each delta so Chrome's
1398
1524
  * rAF throttling on occluded tabs never leaves the board stale. Default true.
1399
1525
  */
1400
1526
  keepLiveWhileHidden?: boolean;
1527
+ /**
1528
+ * The event's time zone (IANA, e.g. `Europe/London`). Every time the room
1529
+ * shows — feed, alerts, Find blocked, reservations, seat history, section
1530
+ * schedules — reads in it, so the room agrees with the event's own pages.
1531
+ * Unset or unknown: the browser's zone, as before.
1532
+ */
1533
+ timeZone?: string;
1534
+ /**
1535
+ * The organisation the event belongs to. Words that send the operator to an
1536
+ * admin name it: "Ask an admin of Jazz Nights Ltd for “Block seats”" (board
1537
+ * CR16). Unset: "Ask an admin", as before. Read once at mount.
1538
+ */
1539
+ organizationName?: string;
1540
+ /**
1541
+ * What the host knows about the sale: its status words in full screen, and
1542
+ * when it opened and the buyers' page in Watch before the first sale (board
1543
+ * CR18). Unset: the room reads as it always has. Change it with `setSale()`.
1544
+ */
1545
+ sale?: SeatManagerSale;
1546
+ /**
1547
+ * Room the host's own overlays take over the map, in CSS px — a strip along
1548
+ * its bottom, a panel down one side. The fitted venue stays clear of them, as
1549
+ * it does of the room's own Colour by bar. Change it with `setMapInsets()`.
1550
+ */
1551
+ mapInsets?: {
1552
+ top?: number;
1553
+ right?: number;
1554
+ bottom?: number;
1555
+ left?: number;
1556
+ };
1401
1557
  /**
1402
1558
  * Opt in to camera-following for new buyer holds/bookings. Off by default so
1403
1559
  * a live event never steals an operator's current map context.
@@ -1455,8 +1611,19 @@ interface SeatManagerOptions {
1455
1611
  * arbitrarily old numbers that looked exactly like fresh ones.
1456
1612
  */
1457
1613
  onConnectionChange?: (state: SeatManagerConnection) => void;
1614
+ /**
1615
+ * What the room itself shows about live updates, as it changes: `connecting`
1616
+ * before the first live moment, `live`, `paused` (updates stopped for 5 s),
1617
+ * `offline` (2 minutes without them), `ended` (the session cannot be renewed).
1618
+ * Additive: `onConnectionChange` keeps its three statuses exactly as before,
1619
+ * so a host that switches on them is unaffected; this is for a host that
1620
+ * wants its own header to say what the room says.
1621
+ */
1622
+ onRoomStateChange?: (state: SeatManagerRoomState) => void;
1458
1623
  onError?: (err: unknown) => void;
1459
1624
  }
1625
+ /** The live-updates state the room shows (see `onRoomStateChange`). */
1626
+ type SeatManagerRoomState = 'connecting' | 'live' | 'paused' | 'offline' | 'ended';
1460
1627
  /** Realtime link state, as reported to the embedding host. */
1461
1628
  interface SeatManagerConnection {
1462
1629
  /**
@@ -1475,6 +1642,8 @@ interface SeatManagerConnection {
1475
1642
  * would overstate freshness.
1476
1643
  */
1477
1644
  lastMessageAt: number | null;
1645
+ /** The room's own finer state (additive; see `onRoomStateChange`). */
1646
+ room?: SeatManagerRoomState;
1478
1647
  }
1479
1648
 
1480
1649
  /**
@@ -1513,6 +1682,17 @@ declare class SeatManager {
1513
1682
  private doc;
1514
1683
  private selectObserver;
1515
1684
  private seatHistoryPanel;
1685
+ /** Your changes today, each with Undo (CR22, extras): mounted on the first change or the first look at Watch → You. */
1686
+ private changes;
1687
+ private changesLoading;
1688
+ /** Watch's feed: everything, sales, carts, or your own changes (CR22). */
1689
+ private feedFilter;
1690
+ /** Saved selections (CR23, extras): the list's handle, how many are saved, and the one just used while it is still what is picked. */
1691
+ private saved;
1692
+ private savedCount;
1693
+ private savedApplied;
1694
+ /** Arriving from a report, and the header numbers' trend cards (CR24, extras). */
1695
+ private arrival;
1516
1696
  private activityPanel;
1517
1697
  private navigation;
1518
1698
  private movingMap;
@@ -1530,6 +1710,10 @@ declare class SeatManager {
1530
1710
  /** Host-listed labels painted as held while the event has them free. */
1531
1711
  private unavailableLabels;
1532
1712
  private lastSelectionLabels;
1713
+ /** Selection undo and redo (boards CR04, CR10): earlier picks, newest last; cleared when the tool changes. */
1714
+ private selBack;
1715
+ private selAhead;
1716
+ private selRestoring;
1533
1717
  private selectionWasValid;
1534
1718
  private initialSelectionApplied;
1535
1719
  private labelToId;
@@ -1550,11 +1734,18 @@ declare class SeatManager {
1550
1734
  * every chair, so a sold whole table reads as sold, not as eight free seats.
1551
1735
  */
1552
1736
  private tableChairIds;
1737
+ /** A label's name where it differs: a standing place reads as its area (audit M1), from the chart and the server's `displayLabels`. */
1738
+ private labelNames;
1553
1739
  private status;
1554
- /** Live non-free counters, moved by each delta rather than re-walked. */
1740
+ /**
1741
+ * Live non-free counters in SEATS, moved by each delta rather than re-walked:
1742
+ * a table sold whole weighs its chairs (audit B3), never 1.
1743
+ */
1555
1744
  private counts;
1556
- /** Bumped whenever the seat model is replaced wholesale (a full snapshot). */
1557
- private modelVersion;
1745
+ /** The seat model has taken a full snapshot since the chart was built. */
1746
+ private modelSynced;
1747
+ /** The first control-room read has answered, or failed, since the chart was built. */
1748
+ private controlRoomSettled;
1558
1749
  private currency;
1559
1750
  /** Currency read from the event/control-room projection; host currency is fallback only. */
1560
1751
  private authoritativeCurrency;
@@ -1572,6 +1763,8 @@ declare class SeatManager {
1572
1763
  * client tallies — themselves a fresh authenticated read — take over.
1573
1764
  */
1574
1765
  private serverBaseline;
1766
+ /** The reservations list has been read at least once (so `reservedBy` is not just empty). */
1767
+ private reservationsLoaded;
1575
1768
  /** Latest presence frame, held whether or not a snapshot has landed yet. */
1576
1769
  private livePresence;
1577
1770
  /** Latest cumulative booked gross pushed on a delta frame. */
@@ -1582,8 +1775,42 @@ declare class SeatManager {
1582
1775
  private heatEnabled;
1583
1776
  /** The View menu (plan item 5, slice D): labels, colours, momentum — remembered per browser. */
1584
1777
  private mapView;
1778
+ /** The panel's state for Ticket types: the chosen type, a write in flight, and the last inline message. */
1779
+ private categoryChoice;
1780
+ /** The last section block clicked at the overview, for click-again-to-zoom. */
1781
+ private lastSectionTap;
1782
+ /** The press in progress (CR10): Shift held, where it went down, and whether a seat or block answered it. */
1783
+ private press;
1784
+ /** The last seat a click picked or read, for Shift + click runs and double-click rows. */
1785
+ private lastPick;
1786
+ private categoryBusy;
1787
+ private blockBusy;
1788
+ private panelAlert;
1789
+ private categoryTotalsCache;
1790
+ private rowLabelCache;
1791
+ /** The organizer's Colour by choice per tool (Status · Ticket type · Channel). */
1792
+ private colourChoices;
1585
1793
  /** The bar's Find box — its chooser reads every seat, not just the tool's selectable ones. */
1586
- private barFind;
1794
+ /** The ⌘K palette's lazy module (the manager-extras chunk), and the palette when open. */
1795
+ private extras;
1796
+ /** The Reserve tool's panel (manager-extras), while that tool is open. */
1797
+ private reserve;
1798
+ private alerts;
1799
+ private sectionsPanel;
1800
+ private tablesPanel;
1801
+ private findBlocked;
1802
+ /** Reserved seats by label (CR14): a blocked seat with a name. Drives the map's ring, the legend and the hover card. */
1803
+ private reservedBy;
1804
+ /** Seats this room has asked to reserve, until the reservation list names them (audit M7). */
1805
+ private reserving;
1806
+ private reservedIds;
1807
+ private reservationsTimer;
1808
+ /** Find blocked's groups, read for Watch's blocked-seat card and ⌘K's "N reasons"; re-read when blocks change. */
1809
+ private blockGroups;
1810
+ /** The event's start, from the chart read; the Reserve tool's "before the start" ends need it. */
1811
+ private eventStartsAt;
1812
+ private search;
1813
+ private searchSeatList;
1587
1814
  /** The venue overview in the map's corner (plan item 7); null under the compact breakpoint. */
1588
1815
  private minimap;
1589
1816
  private followLive;
@@ -1591,6 +1818,9 @@ declare class SeatManager {
1591
1818
  private activeKpiDeltas;
1592
1819
  private ws;
1593
1820
  private reconnectTimer;
1821
+ /** Liveness (CR18): a ping every 10 s; no pong within 5 s means the socket is gone, even if the browser has not noticed. */
1822
+ private pingTimer;
1823
+ private pongTimer;
1594
1824
  private attempt;
1595
1825
  private closed;
1596
1826
  /** Mirrors the `live` root class, so the getter never has to read the DOM. */
@@ -1607,10 +1837,18 @@ declare class SeatManager {
1607
1837
  private followLiveTimer;
1608
1838
  private followSeatTimer;
1609
1839
  private releaseAt;
1840
+ /** Block's "Put back on sale" choice (CR15). */
1841
+ private blockEnd;
1842
+ /** The last block, for its Undo (30 s) or, when some seats sold meanwhile, its Done. */
1843
+ private blockDone;
1844
+ private blockFailedNow;
1610
1845
  private layoutObserver;
1611
1846
  /** Height the minimal chrome's zoom column takes from the map's bottom edge. */
1612
1847
  private chromeClearance;
1613
1848
  private chromeClearanceWidth;
1849
+ /** The fit's top inset under Colour by, in px; -1 until measured. */
1850
+ /** The insets last handed to the renderer ("top,right,bottom,left"); '' before the first. */
1851
+ private legendInset;
1614
1852
  private tokenExpiresAt;
1615
1853
  private tokenRefreshTimer;
1616
1854
  private tokenRefreshInFlight;
@@ -1618,6 +1856,15 @@ declare class SeatManager {
1618
1856
  private tokenRefreshFailures;
1619
1857
  /** The manage session cannot be renewed: every poll and socket is down until `retrySession()`. */
1620
1858
  private sessionEnded;
1859
+ /** Compact and touch (CR19): the folded task picker, and the sheet's height per task. */
1860
+ private taskGroups;
1861
+ private taskMenuOpen;
1862
+ private detents;
1863
+ /** Live updates as the operator sees them (CR18): LIVE, PAUSED after 5 s without, OFFLINE after 2 min. */
1864
+ private linkState;
1865
+ private linkTimers;
1866
+ private everLive;
1867
+ private announcedRoomState;
1621
1868
  private sectionByObject;
1622
1869
  private sectionLabelById;
1623
1870
  private sectionsBase;
@@ -1625,13 +1872,8 @@ declare class SeatManager {
1625
1872
  private availabilityRules;
1626
1873
  private effectiveHidden;
1627
1874
  private effectiveClosed;
1628
- private availabilitySaving;
1629
1875
  private lastSyncedAt;
1630
1876
  private blockBrowse;
1631
- private blockedQuery;
1632
- private blockedSection;
1633
- private blockedResultLimit;
1634
- private unblockAllConfirmTimer;
1635
1877
  /**
1636
1878
  * Sales channels (M6b).
1637
1879
  *
@@ -1656,6 +1898,8 @@ declare class SeatManager {
1656
1898
  */
1657
1899
  private chooser;
1658
1900
  private chooserDialog;
1901
+ /** The lazy chunk once it is in: a picker then opens at once. */
1902
+ private extrasReady;
1659
1903
  /** GET /category-assignments for the Categories tool's Reset count; null until read. */
1660
1904
  private categoryDifferences;
1661
1905
  private channelCaps;
@@ -1668,11 +1912,25 @@ declare class SeatManager {
1668
1912
  private channelsLoading;
1669
1913
  private readonly onFullscreenChange;
1670
1914
  private readonly onKeyDown;
1915
+ /**
1916
+ * ⌘A anywhere in the room (B8, board CR10), answered on the way down so it
1917
+ * means the same whether the map, the panel or a button has focus: a picking
1918
+ * tool takes every seat it can change that is on screen, Select (the host's
1919
+ * tool) takes every seat, and Watch takes nothing. The page's text is never
1920
+ * selected; a text field keeps its own ⌘A.
1921
+ */
1922
+ private readonly onSelectAllKey;
1923
+ /** Every seat this tool can change that is on screen. */
1924
+ private selectInView;
1925
+ /** "How it works ›" in a panel, ? in the bar, How colours work in the Colour by menu (boards CR12, CR25). */
1926
+ private readonly onHowClick;
1671
1927
  private readonly onRailClick;
1672
1928
  constructor(options: SeatManagerOptions);
1673
1929
  private assertSelectionOptions;
1674
1930
  /** Build the DOM, load the chart, subscribe to realtime, mount the board. */
1675
1931
  render(): Promise<this>;
1932
+ /** Load the chart and the live state into the chrome; a failure says why on a card over the room. */
1933
+ private load;
1676
1934
  setMode(mode: SeatManagerMode): void;
1677
1935
  /**
1678
1936
  * Decide what this token may do with sales channels.
@@ -1716,7 +1974,19 @@ declare class SeatManager {
1716
1974
  * the current tool could select it — and Enter selects on the choosing
1717
1975
  * tools, frames on Inspect and Monitor. Highlight rides the renderer.
1718
1976
  */
1977
+ /** The bar's search field opens the ⌘K palette (board CR09: one search, keyboard first). */
1719
1978
  private wireBarFind;
1979
+ /** The manager-extras chunk and its styles, loaded the first time a secondary feature needs them. */
1980
+ private loadExtras;
1981
+ /** Run a lazy-chunk extra when the chunk is in; the room's plain paint never waits, and a failed load keeps it. */
1982
+ private withExtras;
1983
+ /** A picker's dialog could not load: say so, with a retry that fetches it again. */
1984
+ private pickerFailed;
1985
+ /** Load the search (first time only: the manager-extras chunk and its styles) and open it. */
1986
+ openSearch(initial?: string): Promise<void>;
1987
+ private canReadOrders;
1988
+ /** Every seat for the search, once per chart. */
1989
+ private searchSeats;
1720
1990
  private isChoosingTool;
1721
1991
  /** Move the camera to these seats — Enter in the bar's Find on Inspect/Monitor. */
1722
1992
  private frameLabels;
@@ -1746,9 +2016,12 @@ declare class SeatManager {
1746
2016
  * who works with labels off keeps them off tomorrow.
1747
2017
  */
1748
2018
  setMapView(patch: Partial<MapView>): void;
1749
- /** What the map's colours mean now: how full, or ticket type (the legend's switch). */
2019
+ /** What the map's colours mean now: Status, Ticket type or Channel (the map's Colour by menu). */
1750
2020
  getColourBy(): ColourBy;
1751
- setColourBy(mode: ColourBy): void;
2021
+ /** Colour the map by `mode`; `remember` keeps it as this tool's choice on this browser. */
2022
+ setColourBy(mode: ColourBy | 'full', remember?: boolean): void;
2023
+ /** The tool's opening colours: the host's pick when it gave one, else the mode that answers the tool's question. */
2024
+ private startingColourBy;
1752
2025
  getMapView(): MapView;
1753
2026
  private toggleMapView;
1754
2027
  /** Channel colours are the Channels tool's overlay; outside it there is nothing to colour by. */
@@ -1761,6 +2034,8 @@ declare class SeatManager {
1761
2034
  setKeepLiveWhileHidden(enabled: boolean | undefined): void;
1762
2035
  /** Update the host fallback currency; an event/control-room currency still wins. */
1763
2036
  setCurrency(currency: string | undefined): void;
2037
+ /** The host's sale facts (CR18): the full-screen pill, and when sales opened and the buyers' page before the first sale. */
2038
+ setSale(sale: SeatManagerSale | undefined): void;
1764
2039
  /** Apply organizer chrome tokens in place without losing camera or selection. */
1765
2040
  setTheme(theme: ChartTheme | undefined): void;
1766
2041
  /**
@@ -1838,6 +2113,8 @@ declare class SeatManager {
1838
2113
  reason?: string;
1839
2114
  }): Promise<void>;
1840
2115
  unblock(labels?: string[]): Promise<void>;
2116
+ /** A failed block or unblock says so in the panel when it is open, else as a message. */
2117
+ private blockFailed;
1841
2118
  unblockAll(): Promise<void>;
1842
2119
  /** Cancel bookings (BOOKED → free), guarded by the original booking ref. */
1843
2120
  cancelBooking(labels: string[], bookingRef: string): Promise<void>;
@@ -1850,8 +2127,31 @@ declare class SeatManager {
1850
2127
  minOccupancy?: number;
1851
2128
  maxOccupancy?: number;
1852
2129
  }): Promise<void>;
2130
+ /** The table change itself; the Tables panel words the outcome, the public call toasts it. */
2131
+ private saveTableBooking;
1853
2132
  private reloadEventChart;
1854
2133
  selectAll(): ExpandedSeat[];
2134
+ /** Section of each seat id and each section's centre, built once per chart (for bands at the overview). */
2135
+ private bandIndex;
2136
+ /**
2137
+ * CR10: a band at the overview (seats not drawn) takes every section it
2138
+ * touches, whole — one of its seats or its centre inside the band. With
2139
+ * seats drawn the renderer's own rule stands (the seats it covers). Alt
2140
+ * takes them out instead.
2141
+ */
2142
+ private applyBand;
2143
+ /** A click took a seat back out; with Shift it still extends the run to it (CR10). */
2144
+ private handleSeatDeselect;
2145
+ /** Every seat of one row, in the row's own order. */
2146
+ private rowSeats;
2147
+ /**
2148
+ * The gestures the engine leaves to the room (CR10): a click a few pixels
2149
+ * outside every block takes the nearest; a double-click on a seat takes its
2150
+ * row in a picking tool and zooms to it in Watch.
2151
+ */
2152
+ private wireGestures;
2153
+ /** A click on a section block (the renderer's onSectionTap). */
2154
+ private handleSectionTap;
1855
2155
  selectSection(sectionId: string): ExpandedSeat[];
1856
2156
  /** Filter every section whose public label matches, then frame their union. */
1857
2157
  setFilteredSection(label: string): SeatManagerFilteredSection[];
@@ -1901,6 +2201,8 @@ declare class SeatManager {
1901
2201
  setNumberOfPlacesToSelect(required: number | undefined): void;
1902
2202
  getSelectionValidity(): SeatManagerSelectionValidity | null;
1903
2203
  clearSelection(): void;
2204
+ /** Step the selection back (-1, ⌘Z) or forward again (1, ⌘⇧Z); false when there is nowhere to go. */
2205
+ private stepSelection;
1904
2206
  getSelection(): ExpandedSeat[];
1905
2207
  getReport(): Promise<ReportResult>;
1906
2208
  getControlRoomSnapshot(windowMinutes?: number): Promise<ControlRoomSnapshot>;
@@ -1933,13 +2235,55 @@ declare class SeatManager {
1933
2235
  * view change, so the crumb and the pills never lag the camera.
1934
2236
  */
1935
2237
  private paintMapChrome;
2238
+ /**
2239
+ * Nothing left to sell because every unsold seat is kept aside (the Sections
2240
+ * tab's rule), and how: blocked, reserved (CR14, audit M7), or both. Never
2241
+ * "Sold out". Undefined when a seat is free or in a cart, or none is kept.
2242
+ */
2243
+ private sectionKeptAside;
1936
2244
  /** Section id → the ticket type most of its seats carry, rebuilt with the sections. */
1937
2245
  private typeKeyBySection;
1938
2246
  private typeKeyBase;
1939
2247
  private sectionTypeKeys;
1940
2248
  /** A block's ticket-type colour, exactly as the map paints that type. */
1941
2249
  private sectionTypeTint;
1942
- /** The ticket types this chart sells, named and coloured as the map shows them. */
2250
+ private legendSeats;
2251
+ /** Re-read the reservations soon: a burst of blocks and releases costs one read. */
2252
+ private scheduleReservations;
2253
+ private refreshReservations;
2254
+ /** Swap in a new reservation map and repaint only the seats whose look changed. */
2255
+ private setReservations;
2256
+ /** The blocks grouped by reason (GET /blocks), at most once per 30 s unless blocks changed. */
2257
+ private loadBlockGroups;
2258
+ private reservedBlockedCount;
2259
+ /**
2260
+ * Seats kept aside under a name, of `blocked`: the server's `reserved` when it
2261
+ * gives one, carried forward by what the room has seen change since (audit B4),
2262
+ * else the room's own count from the reservations list.
2263
+ */
2264
+ private reservedTally;
2265
+ /**
2266
+ * The Colour by legend with its live counts. Called when the colours, the
2267
+ * zoom rung (blocks or seats) or the statuses change — once per burst of
2268
+ * status changes, never per camera move — so an arena pays one walk of its
2269
+ * non-free seats per burst, not per frame.
2270
+ */
2271
+ private paintColourLegend;
2272
+ /** The ticket types this chart sells, named and coloured as the map shows them, with their free seats. */
2273
+ /** The legend chip whose seats are lit up (CR06). */
2274
+ private litChip;
2275
+ /** Seats the host asked to show (CR18), lit as the `shown` chip. */
2276
+ private shownObjects;
2277
+ /**
2278
+ * Light these seats and frame them, the rest stepping back, as a legend chip
2279
+ * does (CR06); the legend names them ("Lighting up Resale · 12"). Esc, the
2280
+ * chip's × or `null` clears. For the host's own sets, such as resale (CR18).
2281
+ */
2282
+ showObjects(labels: readonly string[] | null, name?: string): void;
2283
+ /** The seats a legend chip stands for. */
2284
+ private chipLabels;
2285
+ /** Click lights a chip's seats and the rest step back; again, × or Esc clears; ⇧ click selects them in a picking tool. */
2286
+ private onLegendChip;
1943
2287
  private legendTypes;
1944
2288
  /**
1945
2289
  * Re-ask the block paint and carry it to the minimap. The minimap paints
@@ -1971,13 +2315,6 @@ declare class SeatManager {
1971
2315
  * available for large charts. */
1972
2316
  /** A tap on a row label takes the row in every tool that chooses seats. */
1973
2317
  private rowLabelSelectable;
1974
- /**
1975
- * The two map intents a choosing tool offers beside the chooser's pickers:
1976
- * drag a box, or draw a lasso. One is always on; the choice survives a
1977
- * repaint and a tool switch (an operator who prefers the lasso keeps it).
1978
- */
1979
- private marqueeShapeChipsHtml;
1980
- private wireMarqueeShapeChips;
1981
2318
  private isBulkSelectMode;
1982
2319
  /**
1983
2320
  * Block never touches held or booked inventory, so it cannot select it.
@@ -2022,6 +2359,15 @@ declare class SeatManager {
2022
2359
  * visibly offline while the host refreshes authority or upgrades the API.
2023
2360
  */
2024
2361
  private connect;
2362
+ /**
2363
+ * A dropped network often closes nothing: the socket sits open, or CLOSING,
2364
+ * for minutes. The server answers `ping` with `pong` without waking the event
2365
+ * (socket-level auto-response), so a missing pong is the room's own proof
2366
+ * that live updates stopped. It drops the socket itself and says PAUSED at
2367
+ * once, since the pong's grace already covered the 5 s.
2368
+ */
2369
+ private startKeepalive;
2370
+ private stopKeepalive;
2025
2371
  private scheduleReconnect;
2026
2372
  private onMessage;
2027
2373
  /**
@@ -2048,8 +2394,19 @@ declare class SeatManager {
2048
2394
  * the mode really is free, wrong the moment it is not.
2049
2395
  */
2050
2396
  private applySnapshot;
2397
+ /**
2398
+ * Live inventory moved under the organizer's selection (control room audit
2399
+ * 2026-09-29, B7). A seat sold or held elsewhere while it sat in a Block
2400
+ * selection stayed selected, and "Block N" kept counting it: nothing on the
2401
+ * socket path told the selection. Seats the current tool can no longer
2402
+ * select leave it (Select keeps its own policy), and the rail repaints when
2403
+ * anything selected changed status. `changed` null = a whole-model snapshot.
2404
+ */
2405
+ private reconcileSelectionWithStatus;
2051
2406
  /** The one O(n) walk left: a wholesale model replacement re-bases the counters. */
2052
2407
  private recountAll;
2408
+ /** Seats behind one inventory label: a table sold whole is its chairs. */
2409
+ private seatWeight;
2053
2410
  /** Optimistic local write shared by organizer actions. Paint and tally once,
2054
2411
  * even when an arena-sized operation changes hundreds of seats. */
2055
2412
  private setSeatsLocal;
@@ -2076,17 +2433,23 @@ declare class SeatManager {
2076
2433
  * they survive it; anything older defers to the read.
2077
2434
  */
2078
2435
  private refreshControlRoom;
2079
- /** Pin the server's totals to the client model they were read against. */
2436
+ /**
2437
+ * Pin the server's totals to the client model they were read against: in
2438
+ * seats where the server gives them (`seatTotals`, what the dashboard header
2439
+ * shows), else its guest-weighted `totals` (an older API).
2440
+ */
2080
2441
  private rebaseServerTotals;
2442
+ /** The client picture a server read is paired with; `reserved` waits for the reservations list. */
2443
+ private pairedClient;
2081
2444
  /** What the client's own model says — GA units included since `render()`. */
2082
2445
  private clientTallies;
2083
2446
  /**
2084
2447
  * The numbers the KPI bar and rail render.
2085
2448
  *
2086
2449
  * The server is the authority: its totals land exactly as read, and the
2087
- * delta-driven client model carries them forward until the next read. Before
2088
- * the first snapshot — and after a wholesale model replacement invalidates the
2089
- * pairing — the client model stands alone.
2450
+ * delta-driven client model carries them forward until the next read. The
2451
+ * client model stands alone only where the server gives no totals (an older
2452
+ * worker, or a read that failed) — and then in seats, like the server.
2090
2453
  */
2091
2454
  private buildTallies;
2092
2455
  /**
@@ -2099,9 +2462,17 @@ declare class SeatManager {
2099
2462
  * rather than dropping the update.
2100
2463
  */
2101
2464
  private recomputeTallies;
2465
+ /**
2466
+ * A count is seat-accurate once the server's totals are in, or, without
2467
+ * them, once the model has a snapshot and the server has had its say.
2468
+ * Before that nothing is emitted and the strip waits (audit B3).
2469
+ */
2470
+ private talliesReady;
2102
2471
  private flushTallies;
2103
2472
  private verbFor;
2104
2473
  private pushActivity;
2474
+ /** The server's names for labels (`displayLabels`, audit M1); absent on an older API. */
2475
+ private adoptLabelNames;
2105
2476
  private seedFeed;
2106
2477
  private startFeedClock;
2107
2478
  private selectionCap;
@@ -2114,9 +2485,23 @@ declare class SeatManager {
2114
2485
  private trimSelectionToCap;
2115
2486
  private reconcileSelectPolicy;
2116
2487
  private selectionLabels;
2488
+ /** The folded task picker (below 1,000 px): the current task, and all of them when open. */
2489
+ private paintTaskPicker;
2490
+ private isSheet;
2491
+ private sheetDetent;
2492
+ private setDetent;
2493
+ /** The panel as a sheet: peek, half or full, remembered per task; the map waits under full. */
2494
+ private applyDetent;
2495
+ /** The sheet's peek line: what is selected, and in which task. */
2496
+ private paintPeek;
2497
+ /** Tap the grab to raise the sheet a step; swipe it up or down; Esc lowers it from full. */
2498
+ private wireSheet;
2117
2499
  private syncSelection;
2118
2500
  private buildChrome;
2119
- private navigationTargets;
2501
+ /** The Colour by menu: opens from its button, picks a mode, closes on Escape or a press elsewhere. */
2502
+ private wireColourMenu;
2503
+ /** Show what the search found: one seat is zoomed to and flashed; more are framed together. */
2504
+ private showLabels;
2120
2505
  /**
2121
2506
  * With `chrome: 'minimal'` the zoom column is the only chrome over the map,
2122
2507
  * in its bottom-right corner. The fit lifts a picture that reaches under it
@@ -2124,6 +2509,31 @@ declare class SeatManager {
2124
2509
  * ends left of the column, or is too tall to lift, keeps its fit.
2125
2510
  */
2126
2511
  private applyChromeClearance;
2512
+ /**
2513
+ * The bottom lane (hint, live note, crumb) is centred in the room left of the
2514
+ * zoom pills and minimap, so it never runs under them; with too little room
2515
+ * it rides above them instead (audit m16).
2516
+ */
2517
+ private applyLaneRoom;
2518
+ /**
2519
+ * Colour by and its legend sit over the map's top-left (CR06). The fit keeps
2520
+ * the venue below them, so the bar never covers the stage or the first
2521
+ * rows (audit M9). The host's own overlays (`mapInsets`, e.g. the resale
2522
+ * strip) join in the same way. Measured on build and on layout changes only
2523
+ * — a refit then is expected — never while the operator is working the map.
2524
+ */
2525
+ private applyLegendInset;
2526
+ /** Room the host's own overlays take over the map, in CSS px (e.g. a strip along the bottom); the fitted venue stays clear of it. `null` clears. */
2527
+ setMapInsets(insets: SeatManagerOptions['mapInsets'] | null): void;
2528
+ /** Per step, the width the bar's actions needed when they last did not fit; a step undoes only once there is that much room. */
2529
+ private barNeed;
2530
+ /**
2531
+ * Between compact and a wide screen (a laptop with the dashboard's sidebar)
2532
+ * the bar's actions can run past its edge, taking Full screen with them.
2533
+ * First Follow live and View keep only their icons; then search folds to
2534
+ * its icon, as in compact. Each step undoes only when there is room again.
2535
+ */
2536
+ private fitBar;
2127
2537
  private updateContainerLayout;
2128
2538
  private sectionOptions;
2129
2539
  private filterableSections;
@@ -2149,6 +2559,8 @@ declare class SeatManager {
2149
2559
  /** Every table object on the chart, across floors. */
2150
2560
  private tables;
2151
2561
  private paintModeTabs;
2562
+ /** A declared grant without `event:block` cannot change seats; an undeclared (secret-key) host can. */
2563
+ private canBlock;
2152
2564
  /**
2153
2565
  * Every rail opens the same way: what the tool is called, whether it changes
2154
2566
  * anything (and for whom), and one plain sentence on how to use it. An
@@ -2163,6 +2575,18 @@ declare class SeatManager {
2163
2575
  private paintFullscreenButton;
2164
2576
  private paintTrendWindow;
2165
2577
  private setLive;
2578
+ /**
2579
+ * LIVE turns PAUSED within 5 s of losing updates and OFFLINE after 2 minutes,
2580
+ * each with a line under the bar that says what it means (board CR18). A blip
2581
+ * shorter than 5 s changes nothing an operator sees.
2582
+ */
2583
+ private trackLink;
2584
+ /** The live-updates state the room shows, for the host (`onRoomStateChange`). */
2585
+ private roomState;
2586
+ private announceRoomState;
2587
+ private paintLink;
2588
+ /** Full screen for the wall: what is on and how it sells, and the way out (CR18). */
2589
+ private paintFullscreenLine;
2166
2590
  private updateZoomHint;
2167
2591
  private formatKpiDelta;
2168
2592
  private paintKpis;
@@ -2189,8 +2613,30 @@ declare class SeatManager {
2189
2613
  /** One click, no confirm (owner, 2026-09-20): the button already says what it will move. */
2190
2614
  resetCategoriesToChart(): Promise<void>;
2191
2615
  private paintCategorySelection;
2616
+ /** The organizer opened "Add seats by" while seats were selected: keep it open until the selection empties. */
2617
+ private addByPinned;
2618
+ /** "Add seats by": open while nothing is picked, folded once seats are, so the choice sits under the card. */
2619
+ private addByHtml;
2620
+ private paintAddBy;
2621
+ /** Seats per ticket type, counted once per chart or move, never per selection change. */
2622
+ private categoryTotals;
2623
+ /** The selection card's reading: how many, where, in what state, of which types. */
2624
+ private selectionSummary;
2625
+ /** Row or table label per object id, built once per chart. */
2626
+ private rowLabels;
2627
+ /** Tables (board CR16): the head here; the list, its switches and states from the extras chunk. */
2192
2628
  private renderTablesRail;
2193
- private renderInspectRail;
2629
+ /** A task's head and an empty mount under it, for a panel that comes from the extras chunk. */
2630
+ private mountTask;
2631
+ private panelKit;
2632
+ private extrasFailed;
2633
+ /** Every table as the Tables panel reads it; a table is locked while any chair carries live inventory (the server enforces it too). */
2634
+ private tableInfos;
2635
+ /**
2636
+ * Watch's seat card (board CR15; Inspect folded in): what the clicked seat is,
2637
+ * who has it and what you can do from here. Nothing picked: how to read one.
2638
+ */
2639
+ private paintWatchSeat;
2194
2640
  /** Pull the organizer's availability rules (event:view). Called on load and on
2195
2641
  * every WS (re)connect, mirroring how the other panels re-hydrate. `closed` is
2196
2642
  * deterministic from the rules; `hidden` (which folds in already-due timed /
@@ -2207,33 +2653,246 @@ declare class SeatManager {
2207
2653
  private applySectionCanvasTreatment;
2208
2654
  /** The five cockpit fields the pure row model (managerSections.ts) reads. */
2209
2655
  private sectionRowsInput;
2656
+ /** Sections (board CR16): the head here; the list, its menu and states from the extras chunk. */
2210
2657
  private renderSectionsRail;
2211
- private wireSectionRail;
2212
- /** Change one row's availability mode. A zone rule subsumes its child section
2213
- * rules, so those are dropped from the map (the zone window is the truth). */
2214
- private setSectionMode;
2215
- /** Edit a timed reveal time / threshold percent on an existing row rule. */
2216
- private setSectionRulePatch;
2217
- /** Optimistically adopt the new rules, then reconcile with the server-cleaned
2218
- * map + effective hidden/closed sets. Rolls back the rules on failure. */
2658
+ /**
2659
+ * Save one row's change. A zone rule subsumes its sections' rules, so those
2660
+ * are dropped (the zone window is the truth). Resolves to what the change
2661
+ * replaced, per id, for Undo; null when it failed.
2662
+ */
2663
+ private changeSection;
2664
+ /** Share of the rest of the venue sold now: booked among seats no rule keeps off sale (what a threshold waits for). */
2665
+ private soldShareRest;
2666
+ /** Adopt the new rules, then reconcile with the server-cleaned map and the
2667
+ * effective hidden/closed sets. Rolls back on failure; resolves to success.
2668
+ * A null entry (an Undo of a rule that did not exist) is dropped. */
2219
2669
  private persistAvailability;
2220
- private paintLegend;
2221
2670
  private paintFeed;
2222
2671
  private renderBlockRail;
2223
2672
  /** A category/filter is a real toggle: add the missing seats, or remove the
2224
2673
  * whole group when every eligible seat in it is already selected. */
2225
2674
  private toggleLabels;
2675
+ private isReserveSelectable;
2676
+ /**
2677
+ * The Reserve tool (board CR11). The shared skeleton is drawn here so the
2678
+ * selection card and Add seats by behave exactly as in Block; step 2 and the
2679
+ * reservations list come from the manager-extras chunk.
2680
+ */
2681
+ private renderReserveRail;
2682
+ /**
2683
+ * Reserve's calls, through one door: a reservation made or released is
2684
+ * recorded for Watch → You (CR22) with what Undo needs to put it back.
2685
+ */
2686
+ private reserveRequest;
2687
+ /** Arriving from Performance at a section, and the header numbers' way back to their trend (CR24). */
2688
+ private mountArrival;
2689
+ /** Select similar (CR10): grow the selection by rows, section, ticket type, status in view or seat numbers. */
2690
+ private openSimilar;
2691
+ /** Saved selections (CR23), from the extras chunk: loaded once the room is up, for the card's count and ⌘K. */
2692
+ private ensureSaved;
2693
+ /** Use a saved selection: pick its seats as they are now (or, in Watch, show them), and say where they came from. */
2694
+ private applySaved;
2695
+ /** Record a change for Watch → You (CR22). The list lives in the extras chunk; a change never waits for it. */
2696
+ private recordChange;
2697
+ private ensureChanges;
2698
+ /** Watch's feed filter (CR22): All, Sales, Carts, or You — your own changes today, each with Undo. */
2699
+ private paintFeedFilter;
2700
+ /**
2701
+ * Alerts (board CR21): the bell, the rules each person keeps on this event,
2702
+ * and the alerts the open room works out from the live feed. In the open
2703
+ * room only; loaded once the room is up so the first paint never waits.
2704
+ */
2705
+ private mountAlerts;
2706
+ /** Why the map moved, in the lane over it, for a few seconds. */
2707
+ private showWhy;
2708
+ /** Block's Find blocked tab (CR15), from the extras chunk: blocks grouped by reason; reservations stay Reserve's. */
2709
+ private mountFindBlocked;
2710
+ private paintReserveSelection;
2226
2711
  private isBlockSelectable;
2227
2712
  private paintSelBar;
2228
- private filteredBlockedSeats;
2229
- private paintBlockedInventory;
2230
- private confirmUnblockAll;
2231
- private resetUnblockAllConfirm;
2713
+ private selectionFree;
2714
+ /** After the server said yes, the feed and totals must never turn a saved change into a failure on screen. */
2715
+ private doneQuietly;
2232
2716
  private done;
2233
2717
  private toastOk;
2234
2718
  private toastErr;
2235
2719
  private toast;
2720
+ /** The room could not open: say why on a card over it, with the one next step there is. */
2236
2721
  private fail;
2722
+ private showRoomCard;
2723
+ /** Try opening again after a failed start: the frame stays; the data is fetched anew. */
2724
+ private reopen;
2725
+ }
2726
+
2727
+ /**
2728
+ * Categories, as a checkable list with the count each would add — additive
2729
+ * like every picker. A category no seat, table or area uses is shown and
2730
+ * disabled: kept because an integration may reference its key, marked
2731
+ * because choosing it would select nothing (#808 `used`).
2732
+ */
2733
+ /**
2734
+ * Choose ticket types (board CR20): every free seat of a ticked type is added
2735
+ * to what is already selected. Names are whole; the footer says what will be
2736
+ * added before the press; nothing free at all is said, not shown as a list.
2737
+ */
2738
+ declare function openCategory(c: SeatChooser): void;
2739
+ declare function openRows(c: SeatChooser): void;
2740
+ /**
2741
+ * The Seat list (board CR20): the same selection as the map, as checkboxes,
2742
+ * one section at a time beside the list of sections — every row, no paging.
2743
+ * A row takes its free seats; a seat toggles itself; seats that cannot be
2744
+ * picked here are shown, greyed. A pick past the limit is refused and said.
2745
+ */
2746
+ declare function openSeatList(c: SeatChooser, filter?: string): void;
2747
+
2748
+ declare const __managerPickers_openCategory: typeof openCategory;
2749
+ declare const __managerPickers_openRows: typeof openRows;
2750
+ declare const __managerPickers_openSeatList: typeof openSeatList;
2751
+ declare namespace __managerPickers {
2752
+ export { __managerPickers_openCategory as openCategory, __managerPickers_openRows as openRows, __managerPickers_openSeatList as openSeatList };
2753
+ }
2754
+
2755
+ interface SeatChooserRow {
2756
+ id: string;
2757
+ label: string;
2758
+ sectionId: string;
2759
+ sectionLabel: string;
2760
+ /** Every selectable seat label in the row. */
2761
+ labels: string[];
2762
+ /** Every seat in the row, whatever its state (the seat list greys the ones that cannot be picked). */
2763
+ all?: string[];
2764
+ }
2765
+ interface SeatChooserCategory {
2766
+ key: string;
2767
+ label: string;
2768
+ color?: string;
2769
+ /** Seats of this type on the map, whatever their state ("N free of M"). */
2770
+ total?: number;
2771
+ }
2772
+ interface SeatChooserHost {
2773
+ selectionLabels(): string[];
2774
+ /** Adds to the selection (the renderer's selectByLabels is additive). */
2775
+ selectByLabels(labels: string[]): void;
2776
+ clearSelection(): void;
2777
+ selectSection(sectionId: string): void;
2778
+ sections(): Array<{
2779
+ id: string;
2780
+ label: string;
2781
+ }>;
2782
+ /** A section's size and colour for the pickers ("N free of M", its dot). */
2783
+ sectionInfo?(sectionId: string): {
2784
+ total: number;
2785
+ color?: string;
2786
+ };
2787
+ labelsInSection(sectionId: string): string[];
2788
+ rows(): SeatChooserRow[];
2789
+ categories(): SeatChooserCategory[];
2790
+ labelsInCategory(key: string): string[];
2791
+ seats(): Array<{
2792
+ label: string;
2793
+ }>;
2794
+ statusOf(label: string): string | undefined;
2795
+ sectionOfLabel(label: string): {
2796
+ id: string;
2797
+ label: string;
2798
+ } | null;
2799
+ /** Arrow keys for a picker's dialog (board CR20), wired once the room's lazy chunk is in; Tab, Space and Enter never wait for it. */
2800
+ enhanceDialog?(dialog: HTMLElement): void;
2801
+ /** The pickers' dialogs (the lazy chunk): the module itself once it is in, else its load. */
2802
+ pickers?(): Pickers | Promise<Pickers>;
2803
+ /** A picker could not load: say so, offering `retry`. */
2804
+ pickerFailed?(retry: () => void): void;
2805
+ /** The seat list's per-seat meta ("Members · free"); default = the status. */
2806
+ seatMeta?(label: string): string;
2807
+ /** Paint dialog content inside the host's scrim and wire it. */
2808
+ openDialog(inner: string, wire: (dialog: HTMLElement) => void): void;
2809
+ closeDialog(): void;
2810
+ /** Most seats one selection may hold. Absent = no cap. */
2811
+ cap?: number;
2812
+ /**
2813
+ * Find highlights its matches on the map while the query is typed: the
2814
+ * matches keep their paint, every other seat recedes. `null` = no query,
2815
+ * which clears the highlight (an empty match list would dim the whole map).
2816
+ */
2817
+ highlight?(labels: string[] | null): void;
2818
+ /** Frame these seats on the map — what Enter does where nothing is chosen. */
2819
+ frame?(labels: string[]): void;
2820
+ }
2821
+ /** What Find matched, before anything is selected. */
2822
+ interface FindResult {
2823
+ labels: string[];
2824
+ seats: number;
2825
+ rows: number;
2826
+ sections: number;
2827
+ }
2828
+ /** The dialogs the chooser opens from the lazy chunk (managerPickers). */
2829
+ type Pickers = Pick<typeof __managerPickers, 'openCategory' | 'openRows' | 'openSeatList'>;
2830
+ declare class SeatChooser {
2831
+ readonly host: SeatChooserHost;
2832
+ private rowsCache;
2833
+ /** The section the seat list shows (board CR20: one at a time, beside the list of sections). Read by managerPickers. */
2834
+ seatListSection: string | null;
2835
+ /** The size a refused seat-list pick would have made, for its footer. Read by managerPickers. */
2836
+ seatListCap: number | null;
2837
+ private menu;
2838
+ /** A picker is loading: its chip says so and a second press does not open it twice. */
2839
+ private opening;
2840
+ constructor(host: SeatChooserHost);
2841
+ /** Rows are structural chart data; derive them once per chooser life. */
2842
+ rows(): SeatChooserRow[];
2843
+ /** The chart may have changed (mode re-entry, chart update): forget derived data. */
2844
+ reset(): void;
2845
+ /**
2846
+ * The chooser chips: the pickers this chart can offer, and Find. Map
2847
+ * intents (tap, drag box) are the host's — they arm the renderer, not a
2848
+ * dialog — so the host passes their HTML in and this row places them first.
2849
+ */
2850
+ chipsHtml(opts?: {
2851
+ intents?: string;
2852
+ find?: boolean;
2853
+ saved?: boolean;
2854
+ }): string;
2855
+ /**
2856
+ * Wire the chips inside `container`. Picker chips are dispatched here; an
2857
+ * intent chip is the host's (it is not addressed). Returns the labels Find
2858
+ * is currently matching through `onFind`, so a host can mirror them.
2859
+ */
2860
+ wire(container: HTMLElement, opts?: {
2861
+ onFind?: (result: FindResult) => void;
2862
+ }): void;
2863
+ /** A host with its own `data-ch-act` dispatch (Channels) routes the four picks itself and skips this. */
2864
+ wireChips(container: HTMLElement): void;
2865
+ /** Route a host-dispatched pick to its dialog. Returns false for an action that is not the chooser's. */
2866
+ handleAction(act: string): boolean;
2867
+ /**
2868
+ * Wire a Find box. `enter: 'select'` (default) adds the matches to the
2869
+ * selection — the choosing tools; `enter: 'frame'` moves the camera to them
2870
+ * — Inspect and Monitor, where nothing is chosen. Escape in the box clears
2871
+ * the query and the highlight with it.
2872
+ */
2873
+ wireFind(container: HTMLElement, opts?: {
2874
+ onFind?: (result: FindResult) => void;
2875
+ enter?: 'select' | 'frame';
2876
+ }): void;
2877
+ /** Pure: what a query would select. */
2878
+ find(query: string): FindResult;
2879
+ /** Choose ticket types (board CR20). */
2880
+ openCategory(): void;
2881
+ /** Choose rows, section by section (board CR20). */
2882
+ openRows(): void;
2883
+ /** The Seat list (board CR20), optionally filtered. */
2884
+ openSeatList(filter?: string): void;
2885
+ /**
2886
+ * Open a dialog from the lazy chunk: at once when it is in (it is prefetched
2887
+ * on idle), else after it loads, with the chip busy meanwhile and a second
2888
+ * press ignored. A failed load is the host's to say, with a retry.
2889
+ */
2890
+ private openPicker;
2891
+ /**
2892
+ * The Section chip's menu (board CR20): every section, whole, with its free
2893
+ * count; a press adds that section's free seats to the selection at once.
2894
+ */
2895
+ openSections(anchor?: HTMLElement | null): void;
2237
2896
  }
2238
2897
 
2239
2898
  /**
@@ -2415,9 +3074,23 @@ interface ChannelsModeHost {
2415
3074
  /** Make the canvas non-interactive behind a full-detent sheet (§13). */
2416
3075
  setMapInert(inert: boolean): void;
2417
3076
  toast(message: string, kind: 'ok' | 'err'): void;
3077
+ /** The chooser's dialogs from the room's lazy chunk (0.105.0 trim); see SeatChooserHost. */
3078
+ pickers?: SeatChooserHost['pickers'];
3079
+ pickerFailed?: SeatChooserHost['pickerFailed'];
3080
+ /** Arrow keys in the pickers, from the room's lazy chunk, as in every other tool (M13). */
3081
+ enhanceDialog?: SeatChooserHost['enhanceDialog'];
2418
3082
  onError(err: unknown): void;
3083
+ /** Seats moved between channels (or, with `restores`, an Apply undone), for Watch → You (CR22). */
3084
+ moved?(change: {
3085
+ target: string;
3086
+ labels: string[];
3087
+ back: Array<[string, string[]]>;
3088
+ restores?: boolean;
3089
+ }): void;
2419
3090
  /** Fired whenever the staged mutation count changes, for host telemetry. */
2420
3091
  onStagedChange?(staged: number): void;
3092
+ /** The allocation or channel list changed: the map's Colour by legend recounts. */
3093
+ channelsChanged?(): void;
2421
3094
  }
2422
3095
 
2423
3096
  declare class ChannelsMode {
@@ -2450,6 +3123,11 @@ declare class ChannelsMode {
2450
3123
  private assignOpen;
2451
3124
  private targetChannelId;
2452
3125
  private conflict;
3126
+ /** The last Apply (board CR16C): its receipt in the rail, the lit row, and Undo for 30 s. */
3127
+ private applied;
3128
+ /** A one-off line at the top of the list (an Undo's outcome). */
3129
+ private railNote;
3130
+ private appliedTimer;
2453
3131
  private dialog;
2454
3132
  private detent;
2455
3133
  /**
@@ -2554,6 +3232,12 @@ declare class ChannelsMode {
2554
3232
  /** Walk every allocation page. Bounded by the event's seat count, and the
2555
3233
  * server caps each page, so an arena is a handful of round trips. */
2556
3234
  private loadAllocation;
3235
+ /** Public sale and each live channel as the map colours them, with the free seats each can sell (the server's counts). */
3236
+ legendChannels(): Array<{
3237
+ label: string;
3238
+ color: string;
3239
+ free: number;
3240
+ }>;
2557
3241
  private channelById;
2558
3242
  private nameOf;
2559
3243
  /**
@@ -2733,6 +3417,20 @@ declare class ChannelsMode {
2733
3417
  * 1.2s was tuned for a confirmation the organizer was already looking at.
2734
3418
  */
2735
3419
  private showApplied;
3420
+ /** The receipt of the last Apply, in the room's words, with Details. */
3421
+ private appliedHtml;
3422
+ private undoBarHtml;
3423
+ /** Send the last Apply's seats back to the channels they came from, one channel at a time. */
3424
+ private undoApplied;
3425
+ /**
3426
+ * Send seats back to the channels they came from (the Apply's Undo, and
3427
+ * Watch → You's). Reads the assignments afresh first, so it never moves on
3428
+ * a stale version; a seat taken meanwhile is skipped by the server.
3429
+ */
3430
+ sendBack(back: Iterable<[string, string[]]>): Promise<{
3431
+ moved: number;
3432
+ failed: boolean;
3433
+ }>;
2736
3434
  private shakeStaged;
2737
3435
  /**
2738
3436
  * The ⋯ menu.
@@ -2875,4 +3573,4 @@ declare class ChannelsMode {
2875
3573
  handleBack(): boolean;
2876
3574
  }
2877
3575
 
2878
- export { ManageApiError as $, type AccessIntentForbidsDetails as A, type BucketRow as B, type ChannelAccessIntent as C, type ChannelsClient as D, ChannelsMode as E, type ChannelsModeHost as F, type ChannelsRowView as G, type ChannelsSeatView as H, type ControlRoomActivityEntry as I, type ControlRoomSectionMetric as J, type ControlRoomSnapshot as K, type EventCategoryAssignmentResult as L, type EventScopedManageToken as M, type EventTableBookingMode as N, type EventTableBookingResult as O, type IntentSwitchBlockedDetails as P, type InventoryBooking as Q, type InventoryBookingActivity as R, type InventoryBookingDetail as S, type ThemeMode as T, type InventoryBookingObject as U, type InventoryBookingState as V, type InventoryBookingsPage as W, type InventoryBookingsQuery as X, type LogEntry as Y, type LogPage as Z, ManageApi as _, type AccessLinkRecord as a, type ReportByStatus as a0, type ReportCategoryMeta as a1, type ReportCategoryRow as a2, type ReportResult as a3, SeatManager as a4, type SeatManagerActionResult as a5, type SeatManagerActivity as a6, type SeatManagerArea as a7, type SeatManagerCapability as a8, type SeatManagerCategoryPrice as a9, planAssignment as aA, retryAfterCopy as aB, selectionSources as aC, stateBadge as aD, suggestMarker as aE, type SeatManagerConnection as aa, type SeatManagerFilteredSection as ab, type SeatManagerMode as ac, type SeatManagerOptions as ad, type SeatManagerSelectionValidity as ae, type SeatManagerTallies as af, type SelectionSourceRow as ag, ACCESS_LINK_DEFAULTS as ah, PUBLIC_CHANNEL_ID as ai, PUBLIC_CHANNEL_NAME as aj, accessIntentDescription as ak, accessIntentLabel as al, accessLine as am, accessLinkBadge as an, accessLinkErrorCopy as ao, accessLinkIsLive as ap, accessLinkPolicyLines as aq, bucketRows as ar, dropReviewRows as as, intentForbidsCopy as at, intentSwitchBlockedCopy as au, isPublicChannelId as av, markerLetter as aw, markerOf as ax, mutationCount as ay, needsMoveConfirmation as az, type AccessLinkReveal as b, type AccessLinkState as c, type AccessLinkStatus as d, type AccessLinkStatusRecord as e, type ArchiveBlockedDetails as f, type AssignmentBuckets as g, type AssignmentDropDetails as h, type AssignmentResult as i, type ChannelAccessSummary as j, type ChannelAllocationPage as k, type ChannelAttribution as l, type ChannelAuditEntry as m, type ChannelAuditPage as n, type ChannelCounts as o, type ChannelListResult as p, type ChannelPreviewProjection as q, type ChannelRecord as r, type ChannelReport as s, type ChannelReportLinkRecord as t, type ChannelReportLinkReveal as u, type ChannelReportResult as v, type ChannelReportRow as w, type ChannelSeatStatus as x, type ChannelState as y, type ChannelsCapabilities as z };
3576
+ export { ManageApiError as $, type AccessIntentForbidsDetails as A, type BucketRow as B, type ChannelAccessIntent as C, type ChannelsClient as D, ChannelsMode as E, type ChannelsModeHost as F, type ChannelsRowView as G, type ChannelsSeatView as H, type ControlRoomActivityEntry as I, type ControlRoomSectionMetric as J, type ControlRoomSnapshot as K, type EventCategoryAssignmentResult as L, type EventScopedManageToken as M, type EventTableBookingMode as N, type EventTableBookingResult as O, type IntentSwitchBlockedDetails as P, type InventoryBooking as Q, type InventoryBookingActivity as R, type InventoryBookingDetail as S, type ThemeMode as T, type InventoryBookingObject as U, type InventoryBookingState as V, type InventoryBookingsPage as W, type InventoryBookingsQuery as X, type LogEntry as Y, type LogPage as Z, ManageApi as _, type AccessLinkRecord as a, type ReportByStatus as a0, type ReportCategoryMeta as a1, type ReportCategoryRow as a2, type ReportResult as a3, SeatManager as a4, type SeatManagerActionResult as a5, type SeatManagerActivity as a6, type SeatManagerArea as a7, type SeatManagerCapability as a8, type SeatManagerCategoryPrice as a9, mutationCount as aA, needsMoveConfirmation as aB, planAssignment as aC, retryAfterCopy as aD, selectionSources as aE, stateBadge as aF, suggestMarker as aG, type SeatManagerConnection as aa, type SeatManagerFilteredSection as ab, type SeatManagerMode as ac, type SeatManagerOptions as ad, type SeatManagerRoomState as ae, type SeatManagerSale as af, type SeatManagerSelectionValidity as ag, type SeatManagerTallies as ah, type SelectionSourceRow as ai, ACCESS_LINK_DEFAULTS as aj, PUBLIC_CHANNEL_ID as ak, PUBLIC_CHANNEL_NAME as al, accessIntentDescription as am, accessIntentLabel as an, accessLine as ao, accessLinkBadge as ap, accessLinkErrorCopy as aq, accessLinkIsLive as ar, accessLinkPolicyLines as as, bucketRows as at, dropReviewRows as au, intentForbidsCopy as av, intentSwitchBlockedCopy as aw, isPublicChannelId as ax, markerLetter as ay, markerOf as az, type AccessLinkReveal as b, type AccessLinkState as c, type AccessLinkStatus as d, type AccessLinkStatusRecord as e, type ArchiveBlockedDetails as f, type AssignmentBuckets as g, type AssignmentDropDetails as h, type AssignmentResult as i, type ChannelAccessSummary as j, type ChannelAllocationPage as k, type ChannelAttribution as l, type ChannelAuditEntry as m, type ChannelAuditPage as n, type ChannelCounts as o, type ChannelListResult as p, type ChannelPreviewProjection as q, type ChannelRecord as r, type ChannelReport as s, type ChannelReportLinkRecord as t, type ChannelReportLinkReveal as u, type ChannelReportResult as v, type ChannelReportRow as w, type ChannelSeatStatus as x, type ChannelState as y, type ChannelsCapabilities as z };