@seatlayer/core 0.24.0 → 0.26.0

package/dist/index.d.cts

@@ -95,7 +95,7 @@ interface CategoryTier {
  * venues (and seats.io) expose so buyers can filter for exactly what they need
  * and organizers can mark seats precisely. `wheelchair` is the legacy default.
  */
-type AccessibilityType = 'wheelchair' | 'companion' | 'semi-ambulatory' | 'hearing' | 'sign-language' | 'plus-size' | 'lift-armrest';
+type AccessibilityType = 'wheelchair' | 'companion' | 'semi-ambulatory' | 'hearing' | 'cart' | 'sign-language' | 'plus-size' | 'lift-armrest';
 interface AccessibilityMeta {
     key: AccessibilityType;
     /** Full descriptive label (designer checkbox, picker legend). */
@@ -135,6 +135,13 @@ interface SeatOverride {
     accessible?: boolean;
     /** Accessibility accommodations of this seat (empty/absent = none). */
     accessibility?: AccessibilityType[];
+    /**
+     * Physical wheelchair provision. Absent keeps legacy seat rendering;
+     * `seat-present` is an explicit removable/fixed accessible chair, while
+     * `no-seat` is an empty wheelchair bay that remains one sellable inventory
+     * unit. This is deliberately distinct from `skip`, which removes inventory.
+     */
+    wheelchairSpaceType?: 'seat-present' | 'no-seat';
     /** Commercial selling/view attributes are deliberately not accessibility. */
     commercial?: SeatCommercialAttributes;
     /** Seat-specific view photo; falls back to the row photo. */
@@ -218,10 +225,23 @@ interface ChartTheme {
 interface RowObject {
     type: 'row';
     id: string;
+    /** Present when this row was materialized by the in-canvas reference scan.
+     *  A re-scan of the same asset replaces rows carrying this marker and NEVER
+     *  touches hand-authored rows — the same replace-generated-only invariant as
+     *  applyReferenceInventory. */
+    referenceScan?: {
+        assetId: string;
+    };
     /** Row label, e.g. "A". Seat labels are `${label}-${n}`. */
     label: string;
     /** Buyer-facing row name. `label` remains the legacy inventory prefix. */
     displayLabel?: string;
+    /**
+     * Buyer-facing type word override (seats.io "Displayed type"). Replaces the
+     * hardcoded "Row" in the picker tooltip/confirm/cart, e.g. "Table", "Bench",
+     * "Aisle". ≤24 chars; absent = the default "Row". Pure presentation.
+     */
+    displayType?: string;
     labelPresentation?: LabelPresentation;
     /** Position of the FIRST seat. */
     origin: Point;
@@ -273,6 +293,48 @@ interface RowObject {
         rowIndex: number;
         segmentIndex: number;
     };
+    /**
+     * Membership in one buyer-facing segmented row. Physical component rows and
+     * their `${rowId}:${slotIndex}` inventory ids remain authoritative; this
+     * metadata only supplies logical ordering/presentation and explicit aisle
+     * continuity. The descriptor is repeated on every component so selecting any
+     * one can resolve the complete logical row without a chart-level side table.
+     */
+    segmentedRow?: {
+        kind: 'segmented-row-v1';
+        groupId: string;
+        componentIndex: number;
+        componentCount: number;
+        /** The first component must use `start`; later boundaries are explicit. */
+        boundaryBefore: 'start' | 'continuous' | 'break';
+        /** Buyer-facing row name; technical component `label` values never change. */
+        displayLabel: string;
+        displayType?: string;
+        labelPresentation?: LabelPresentation;
+        viewFromSeatUrl?: string;
+        /** Presentation intent for a continuous node-defined centreline. */
+        smoothing?: boolean;
+    };
+    /**
+     * Versioned provenance for rows created by the multiple/intertwined block
+     * generator. Manual geometry edits remove this marker rather than allowing a
+     * later regeneration to overwrite hand-authored work.
+     */
+    rowBlockGeneration?: {
+        kind: 'row-block-v1';
+        groupId: string;
+        style: 'multiple' | 'intertwined';
+        rowIndex: number;
+        rowCount: number;
+        seatsPerRow: number;
+        origin: Point;
+        rotation: number;
+        rowGap: number;
+        seatSpacing: number;
+        curve: number;
+        /** Stable canonical generator signature shared by every intact member. */
+        signature: string;
+    };
     /** First seat number (default 1). Roman/letters read it as a 1-based ordinal
      *  (start 1 → I / A). */
     seatLabelStart?: number;
@@ -291,13 +353,16 @@ interface RowObject {
          *  - `even`         2,4,6         — even numbers from the first even ≥ start.
          *  - `updown`       1,3,5,…,6,4,2 — odd-up-even-back; REPLACES direction (uses
          *                                   physical left→right order); start shifts.
+         *  - `updown-descending` …5,3,1,2,4,6 — odd-back-even-up; the distinct
+         *                                   reverse up/down sequence. Also replaces
+         *                                   direction and uses physical order.
          *  - `roman`        I,II,III      — honours direction + step + start (uppercase).
          *  - `letters-upper` A,B,C…Z,AA   — honours direction + step + start.
          *  - `letters-lower` a,b,c…z,aa   — honours direction + step + start.
          * Like `step`/`direction` today, the scheme changes the seat's inventory
          * label (its booking identity), by design.
          */
-        scheme?: 'decimal' | 'odd' | 'even' | 'updown' | 'roman' | 'letters-upper' | 'letters-lower';
+        scheme?: 'decimal' | 'odd' | 'even' | 'updown' | 'updown-descending' | 'roman' | 'letters-upper' | 'letters-lower';
         /** Optional prefix prepended to every seat number, e.g. 'R' → 'R1', 'R2'. */
         prefix?: string;
         /**
@@ -328,15 +393,42 @@ interface RowObject {
 interface GAAreaObject {
     type: 'gaArea';
     id: string;
+    /** Stable technical/inventory label. */
     label: string;
+    /** Buyer-facing area name; technical `label` and GA unit ids stay stable. */
+    displayLabel?: string;
+    /** Buyer-facing type word override (seats.io "Displayed type"), ≤24 chars.
+     * Absent = the default type word. Pure presentation. */
+    displayType?: string;
     /** Closed polygon, in chart units. */
     points: Point[];
     /** Explicit aisles/pillars/cutouts excluded from the sellable GA surface. */
     holes?: Point[][];
     capacity: number;
     categoryKey: string;
+    /**
+     * Durable inventory provenance for a surface produced by Join Areas.
+     *
+     * A GA unit is identified by the id and zero-based range of the area that
+     * originally authored it, not by the current polygon which happens to own
+     * it.  Keeping those source ranges means a geometric join never renumbers an
+     * already published/booked unit.  Ordinary (never-joined) areas omit this
+     * field and implicitly own `[0, capacity)` under their own id.
+     *
+     * The ranges must be non-overlapping, contain positive whole counts, and sum
+     * exactly to `capacity`; validation rejects malformed metadata.  Capacity
+     * growth appends a new range under the surviving area id, while shrinking a
+     * joined area is deliberately refused because it would silently destroy
+     * stable inventory identities.
+     */
+    inventorySegments?: GAInventorySegment[];
     referenceInventorySource?: ReferenceInventorySource;
 }
+interface GAInventorySegment {
+    sourceAreaId: string;
+    startIndex: number;
+    count: number;
+}
 /**
  * Durable evidence link for sellable objects generated from a private reference.
  * The client supplies facts and stable logical-section ids, never coordinates.
@@ -385,20 +477,46 @@ interface ReferenceInventoryExclusionSource {
     evidence: 'user-confirmed' | 'authoritative-source';
     sourceDescription: string;
 }
+/** Open-path stroke semantics. Optional ShapeObject fields retain the legacy
+ * round/round/no-ending rendering when absent. */
+type ShapeLineCap = 'butt' | 'round' | 'square';
+type ShapeLineJoin = 'miter' | 'round' | 'bevel';
+type ShapeLineEnding = 'none' | 'arrow';
 /** Non-bookable décor: stage, walls, exits. */
 interface ShapeObject {
     type: 'shape';
     id: string;
-    kind: 'rect' | 'ellipse' | 'polygon';
+    /**
+     * Closed area shapes (`rect`/`ellipse`/`polygon`) take a `fill`; open path
+     * primitives (`line` = two points, `polyline` = n points) are stroke-only and
+     * never filled. All kinds honour the optional `stroke`.
+     */
+    kind: 'rect' | 'ellipse' | 'polygon' | 'line' | 'polyline';
     label?: string;
     /** For rect/ellipse: bounding box. For a stage polygon: the base (pre-shape) box, so its kind can be regenerated. */
     x?: number;
     y?: number;
     width?: number;
     height?: number;
-    /** For polygon. */
+    /** For polygon/line/polyline. */
     points?: Point[];
     fill?: string;
+    /** Optional outline. `width` is in chart units; both fields are required together. */
+    stroke?: {
+        color: string;
+        width: number;
+    };
+    /** Open line/polyline only. Absent fields preserve round/round/no-ending legacy rendering. */
+    lineCap?: ShapeLineCap;
+    /** Controls corners between open-path segments. */
+    lineJoin?: ShapeLineJoin;
+    /** Independent open-path start/end decorations. Closed outlines never use these fields. */
+    startEnding?: ShapeLineEnding;
+    endEnding?: ShapeLineEnding;
+    /** Rect only — corner rounding radius in chart units, clamped to half the short side at edit time. */
+    cornerRadius?: number;
+    /** Whole-shape opacity 0.1–1 (default 1). */
+    opacity?: number;
     /** Degrees clockwise about the shape's center (default 0). Applied at render time. */
     rotation?: number;
     /**
@@ -411,18 +529,45 @@ interface ShapeObject {
     /** For a stage: which `StageKind` its polygon was generated from. */
     stageKind?: string;
 }
-/** Seats arranged around a table; bookable per-seat or as a whole. */
+type RectTableSide = 'top' | 'bottom' | 'left' | 'right';
+/** Exact rectangular-table chair distribution. The four keys are deliberately
+ * required: zero means that edge has no chair, while the sum is the authored
+ * `seatCount`. Numeric chair identity remains `${table.id}:${index}` in the
+ * canonical top, bottom, left, right expansion order. */
+interface RectTableSeatCounts {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+/** Seats arranged around a table. Grouped selling is activated only by an
+ * event's explicit inventory-model-2 snapshot; model-1 events continue to
+ * treat every authored chair as an independent unit. */
 interface TableObject {
     type: 'table';
     id: string;
     /** e.g. "T1" — seat labels are `${label}-${n}`. */
     label: string;
+    /** Buyer-facing table name; technical chair/group labels stay stable. */
+    displayLabel?: string;
+    /** Buyer-facing type word override (seats.io "Displayed type"), ≤24 chars.
+     * Absent = the default "Row"/"Table" word. Pure presentation. */
+    displayType?: string;
     center: Point;
     shape: 'round' | 'rect';
     /** Seats around the perimeter (round) or along the enabled edges (rect). */
     seatCount: number;
     /** Rect tables: which edges get seats (default ['top','bottom']). */
-    sides?: Array<'top' | 'bottom' | 'left' | 'right'>;
+    sides?: RectTableSide[];
+    /**
+     * Rect tables only: exact chairs on every edge. Absent preserves the legacy
+     * `seatCount` + `sides` round-robin distribution byte-for-byte. When present,
+     * all four values are whole numbers >= 0 and their sum equals `seatCount`.
+     */
+    seatCountsBySide?: RectTableSeatCounts;
+    /** Individual-chair semantic overrides. Grouped whole/variable tables cannot
+     * author these because their only sellable identity is the table itself. */
+    overrides?: SeatOverride[];
     rotation: number;
     /** Round tables. */
     radius?: number;
@@ -437,15 +582,26 @@ interface TableObject {
     width?: number;
     height?: number;
     categoryKey: string;
-    /** Whole-table booking: buyers get all seats or none (per-event override later). */
+    /** One buyer owns the complete table at exactly `seatCount` guests. */
     bookAsWhole?: boolean;
+    /** One buyer owns the complete table and chooses a bounded guest quantity. */
+    variableOccupancy?: boolean;
+    /** Required inclusive guest bounds when `variableOccupancy` is true. */
+    minOccupancy?: number;
+    maxOccupancy?: number;
     referenceInventorySource?: ReferenceInventorySource;
 }
 /** A booth: one bookable unit rendered as a block (trade shows, VIP boxes). */
 interface BoothObject {
     type: 'booth';
     id: string;
+    /** Stable technical/inventory label. */
     label: string;
+    /** Buyer-facing booth name; technical `label` stays stable. */
+    displayLabel?: string;
+    /** Buyer-facing type word override (seats.io "Displayed type"), ≤24 chars.
+     * Absent = the default type word. Pure presentation. */
+    displayType?: string;
     center: Point;
     width: number;
     height: number;
@@ -466,6 +622,18 @@ interface SectionObject {
     label: string;
     /** Buyer-facing section name; logical/id fields remain stable. */
     displayLabel?: string;
+    /**
+     * Buyer-facing entrance/door hint shown in the picker section card
+     * ("Entrance X"). ≤40 chars; absent = no entrance line. Pure presentation.
+     */
+    entrance?: string;
+    /**
+     * Organizer-supplied view image inherited by buyer inventory whose owning
+     * row/table/booth sits in this logical section. Seat and row photos take
+     * precedence; multipart components are kept in sync by the shared section
+     * metadata operation.
+     */
+    viewFromSeatUrl?: string;
     labelPresentation?: LabelPresentation;
     /**
      * Stable management/inventory identity shared by disconnected visual
@@ -512,11 +680,35 @@ interface SectionObject {
      * Tier height. 0 = floor (default). Higher values lift the section in the
      * picker's isometric ("3D") view, drawn on extruded side faces. Same field a
      * future multi-floor mode reuses — authored in 2D, never drawn by the user.
+     *
+     * This is the coarse, back-compat source for {@link height}/{@link rake}: when
+     * those are absent, {@link sectionGeometry} derives real geometry from this
+     * tier so legacy charts render pixel-identical.
      */
     elevation?: number;
+    /**
+     * 3D foundations (Phase A, additive — no migration; charts are JSON blobs).
+     * Metres the section's **front edge** sits above floor 0 (a balcony/tier floor
+     * height). Absent ⇒ derived from the coarse {@link elevation} tier via
+     * {@link sectionGeometry}. Deliberately two scalars, not a foundation polygon:
+     * front-height + {@link rake} fully determine a rectangular tier's back-height.
+     *
+     * NOTE: no consumer reads this raw field directly — all callers go through
+     * {@link sectionGeometry}. Phase B consumers (iso view lift in
+     * `SeatmapRenderer`, per-seat eye-height in the `generatePanorama` 360°
+     * generator) are intentionally NOT wired in Phase A. Range 0–120 m.
+     */
+    height?: number;
+    /**
+     * Degrees of seating incline within the section (0 = flat; typical stalls
+     * 5–15°, steep tiers 25–35°). Absent ⇒ 0. Consumed alongside {@link height}
+     * by the future Phase B iso-lift shear and 360° sightline math — never in
+     * Phase A. Range 0–45°.
+     */
+    rake?: number;
     /** Uniform scale about the outline centroid (1 = as drawn). Scales members too. */
     scale?: number;
-    /** 0–1: how strongly member-row curves are bent toward a common arc fitted to the outline. */
+    /** 0–100: reviewed strength last used to bend member rows toward a common fitted arc. */
     smoothing?: number;
     /** Degrees clockwise about the outline centroid (default 0). Rotates members too. */
     rotation?: number;
@@ -530,23 +722,42 @@ interface ZoneDef {
     id: string;
     label: string;
     color?: string;
+    /**
+     * Authored point this zone faces. Optional only for legacy documents: runtime
+     * consumers fall back to the active floor/chart focal, while publication of
+     * a zone-mode draft requires every used zone to carry an explicit point.
+     */
+    focalPoint?: Point;
 }
 /**
  * Selection layer — a hit-test/dim filter in the designer, NOT z-order management.
  * Fixed set of four; derived from object type via `layerOf()` (no per-object field yet).
  */
 type SelectionLayer = 'interactive' | 'background' | 'foreground' | 'surroundings';
+/** Shape roles emitted by the curated venue-landmark palette. Keep this list in
+ * lockstep with `DECOR_PRESETS`; the selection-layer unit test fails if either
+ * vocabulary changes without an explicit routing decision. `reference-focal`
+ * is source-backed venue context rather than an authoring-palette preset. */
+declare const SURROUNDINGS_SHAPE_ROLES: readonly ["reference-focal", "bar", "entrance", "exit", "restroom", "screen", "sound", "concession", "coat", "wall"];
 /** Derive an object's selection layer from its type. */
 declare function layerOf(obj: ChartObject): SelectionLayer;
 /** Free-standing text on the chart (aisle names, door labels…). */
 interface TextObject {
     type: 'text';
     id: string;
+    /** Persisted provenance for objects created from the venue-icon palette. */
+    semanticKind?: 'icon';
     text: string;
     position: Point;
     fontSize: number;
+    /** Optional CSS family stack for this annotation; absent inherits ChartTheme.fontFamily. */
+    fontFamily?: string;
     rotation: number;
     color?: string;
+    /** Render weight (default false). Maps to Konva fontStyle bold. */
+    bold?: boolean;
+    /** Render slant (default false). Maps to Konva fontStyle italic. */
+    italic?: boolean;
 }
 /**
  * A raster/vector decor graphic drawn IN the chart, beneath the seats and
@@ -570,6 +781,12 @@ interface DecorImageObject {
     rotation?: number;
     /** 0–1 (default 1). Multiplied by any chart-theme dimming at render time. */
     opacity?: number;
+    /**
+     * Z-layer relative to the interactive seat layer. `background` (default)
+     * draws beneath the seats/sections; `foreground` draws above them (a roof
+     * canopy, an overlay graphic). Absent = background — no migration needed.
+     */
+    layer?: 'background' | 'foreground';
     /** Optional caption for the designer inspector / accessibility (not drawn). */
     label?: string;
 }
@@ -583,8 +800,25 @@ type ChartObject = RowObject | GAAreaObject | ShapeObject | TableObject | BoothO
 interface Floor {
     id: string;
     name: string;
+    /**
+     * Absolute physical deck height in metres above the venue/stage datum.
+     * Optional for backwards compatibility; an absent value resolves to ground
+     * level (0 m). Section tiers and rakes are separate, section-local metadata.
+     * Range 0–120 m.
+     */
+    baseHeightM?: number;
     objects: ChartObject[];
     focalPoint: Point;
+    /**
+     * Private organizer trace/calibration layer. This is authoring evidence and
+     * must never be served to, or rendered by, a buyer surface.
+     */
+    referenceImage?: ChartReferenceImage;
+    /**
+     * Buyer-visible aesthetic background. Canonical documents store URL-only
+     * images here. Historical `assetId` values are interpreted as a trace layer
+     * by the background compatibility helpers.
+     */
     backgroundImage?: ChartDoc['backgroundImage'];
 }
 interface ReferenceCalibration {
@@ -598,6 +832,64 @@ interface ReferenceCalibration {
     /** Derived and stored for deterministic geometry compilers. */
     pixelsPerUnit: number;
 }
+/**
+ * A single human-placed seat probe: the author clicks one seat on the reference
+ * image and the server reads the surrounding seat lattice from it.
+ *
+ * COORDINATE-POLICY CARVE-OUT (owner decision 2026-07-21). The reference
+ * blueprint pipeline runs `coordinatePolicy: 'opaque-region-ids-only'` — the
+ * server is the sole source of chart coordinates and MCP clients select opaque
+ * `reg_*` ids, never points. This type is a deliberate, narrow exception on the
+ * same grounds as `ReferenceCalibration`: the point is placed by a human in the
+ * designer canvas, not proposed by a model.
+ *
+ * Therefore this is DESIGNER-ONLY and is intentionally NOT exposed over MCP.
+ * That is an accepted, documented exception to the MCP-parity rule — the
+ * server-is-sole-source guarantee for model-driven edits is worth more than
+ * parity here. Do not "fix" it by adding a seed point to an MCP tool schema.
+ */
+interface ReferenceSeatSeed {
+    /** Seed centre in immutable source-image pixels (never chart coordinates). */
+    source: Point;
+    /** Half-width of the author's sizing ring, in source pixels — the "this is how
+     *  big one seat is" hint that replaces seats.io's zoom-until-it-matches step. */
+    radius: number;
+    /** Whether `radius` was fitted from image pixels or set by hand. Detection
+     *  weights an author-set radius more heavily than one we guessed. */
+    origin: 'auto-fit' | 'manual';
+}
+/** One detected row in a scan proposal — a straight seat run in CHART
+ *  coordinates (the server maps source pixels through referencePixelToChart;
+ *  clients never see source-pixel geometry back). */
+interface ReferenceScanRowProposal {
+    start: Point;
+    end: Point;
+    seatCount: number;
+}
+/** Detected rows attributed to one compiled section (or unattributed when the
+ *  lattice extends outside every compiled polygon). */
+interface ReferenceScanSectionProposal {
+    /** Id of the compiled SectionObject the rows landed in; null = unattributed. */
+    sectionId: string | null;
+    name: string;
+    rows: ReferenceScanRowProposal[];
+    seatCount: number;
+    /** 0..1 — how well this section's lattice agreed with the probe's pitch. */
+    confidence: number;
+    /** Index of the seed (multi-probe) whose pitch produced these rows. */
+    seedIndex: number;
+}
+/** Server response for an in-canvas reference scan. A PROPOSAL — nothing is
+ *  committed until the author applies it in the designer (chartOps + undo). */
+interface ReferenceScanProposal {
+    assetId: string;
+    /** Measured seat diameter / centre-to-centre pitch, in chart units. */
+    seatDiameter: number;
+    seatPitch: number;
+    totalSeats: number;
+    totalRows: number;
+    sections: ReferenceScanSectionProposal[];
+}
 /** Coordinate-free physical scale derived by server code from a confirmed
  * semantic feature. Unlike manual two-point calibration, no source points pass
  * through an MCP client or language model. */
@@ -649,7 +941,16 @@ interface ChartDoc {
      *  is kept mirroring floor 0 so single-floor readers never branch. */
     floors?: Floor[];
     objects: ChartObject[];
-    /** Floor-plan photo the organizer traces over (designer-only aid, also rendered dimly in picker if kept). */
+    /**
+     * Private floor-plan source used for tracing, calibration, scanning and
+     * reference-backed generation. Buyer projections always remove this field.
+     */
+    referenceImage?: ChartReferenceImage;
+    /**
+     * Buyer-visible aesthetic background. Canonical values are URL-only.
+     * Compatibility: a historical value containing `assetId` is trace-only and
+     * is never rendered or exposed to buyers.
+     */
     backgroundImage?: ChartReferenceImage;
     /** Brand/venue theming (colors); categories carry their own colors separately. */
     theme?: ChartTheme;
@@ -671,6 +972,18 @@ interface ExpandedSeat {
     x: number;
     y: number;
     rowId: string;
+    /** Owning logical section and navigation zone, resolved once at expand time. */
+    sectionId?: string;
+    zoneId?: string;
+    /** Zone focal when authored, otherwise the active floor/chart legacy fallback. */
+    focalPoint?: Point;
+    /** Buyer-facing segmented-row identity. `rowId` stays the physical owner id. */
+    logicalRowId?: string;
+    /**
+     * Seat order inside the logical row. A deliberate missing integer is inserted
+     * at every aisle boundary, so numerical adjacency cannot bridge a gap.
+     */
+    logicalSeatIndex?: number;
     categoryKey: string;
     /** 'booth' units render as blocks (dimensions looked up via rowId = booth id). */
     kind?: 'seat' | 'booth';
@@ -678,13 +991,24 @@ interface ExpandedSeat {
     accessible?: boolean;
     /** Specific accessibility accommodations (absent = none) — picker badges/filters these. */
     accessibility?: AccessibilityType[];
+    /** Physical wheelchair provision resolved from the seat override. */
+    wheelchairSpaceType?: 'seat-present' | 'no-seat';
     commercial?: SeatCommercialAttributes;
     /** Organizer-supplied view-from-seat image (inherited from the row). */
     viewUrl?: string;
     /** Per-seat label size/color override; absent = inherit the row/theme default. */
     labelStyle?: LabelStyle;
+    /**
+     * Real-world eye height in metres above the focal/stage datum, resolved at
+     * expand time from the owning section's `{height, rake}` + drawn depth (Phase B2).
+     * Feeds the auto-360° generator's stage-pitch math. Absent ⇒ flat seated eye
+     * height (legacy / seats in no section) — so old charts stay pixel-identical.
+     */
+    eyeHeightM?: number;
 }
 type SeatStatus = 'free' | 'held' | 'booked' | 'not_for_sale';
+/** Buyer canvas projection. Perspective is a view-only projected-2.5D lane. */
+type RendererViewMode = 'flat' | 'isometric' | 'perspective';
 interface RendererCallbacks {
     onSelect?: (seat: ExpandedSeat) => void;
     onDeselect?: (seat: ExpandedSeat) => void;
@@ -759,6 +1083,11 @@ interface RenderedBookableLabelEvidence {
     seatId: string;
     label: string;
     kind: 'seat' | 'booth';
+    /** Painted inventory silhouette. Empty wheelchair bays are deliberately
+     * square, while physical seats retain the ordinary circular marker. */
+    markerShape: 'circle' | 'square' | 'booth';
+    /** Physical wheelchair provision represented by this inventory unit. */
+    wheelchairSpaceType?: 'seat-present' | 'no-seat';
     categoryKey: string;
     sectionId?: string;
     zoneId?: string;
@@ -769,6 +1098,13 @@ interface RenderedBookableLabelEvidence {
     fill: string;
     ink: string;
     opacity: number;
+    /** Buyer-visible accessibility glyph evidence. Filter emphasis uses a
+     * screen-space minimum so wheelchair provision remains recognizable at fit. */
+    accessibilityMarker?: {
+        glyphVisible: boolean;
+        glyphWidthPx: number;
+        emphasizedByFilter: boolean;
+    };
     /** Direct Konva shape bounds and the production near-miss rescue combined. */
     pointerTarget: {
         active: boolean;
@@ -849,6 +1185,15 @@ interface RendererQualityEvidence {
         width: number;
         height: number;
     };
+    /** Runtime projection actually used for the pixels and hit graph below. */
+    projection: RendererViewMode;
+    /** Phase-C proof metadata. Present only in the projected-2.5D lane. */
+    perspective?: {
+        model: 'pinhole-exact-seat-anchors';
+        sectionSurfaceModel: 'tangent-plane';
+        exactSeatAnchorCount: number;
+        depthSorted: true;
+    };
     canvasBackground: string;
     effectiveScale: number;
     rung: LodRung;
@@ -1033,13 +1378,14 @@ interface ISeatmapRenderer {
      */
     setColorblindSafe?(on: boolean): void;
     /**
-     * Switch the projection. `'flat'` = normal top-down; `'isometric'` = the "3D"
-     * view (affine skew/rotate + elevation lift), hit-testing preserved in screen
-     * space. Purely visual — the chart is authored flat. Animated unless reduced-motion.
+     * Switch the projection. `'flat'` = normal top-down; `'isometric'` = the
+     * legacy affine preview; `'perspective'` = projected 2.5D with exact pinhole
+     * seat anchors/native hit shapes and bounded per-section tangent surfaces.
+     * Purely visual — the chart is authored flat.
      */
-    setViewMode?(mode: 'flat' | 'isometric'): void;
+    setViewMode?(mode: RendererViewMode): void;
     /** Current projection (defaults to 'flat' when unimplemented). */
-    getViewMode?(): 'flat' | 'isometric';
+    getViewMode?(): RendererViewMode;
     /** Multi-floor (Batch 5): switch the shown floor; list floors; read the active id. */
     setActiveFloor?(floorId: string): void;
     getFloors?(): {
@@ -1108,6 +1454,8 @@ declare const CHART_STORAGE_KEY = "seatmap.chart";
  */
 /** Base (pre-override) seat centre per index — shared by expandRow + designer edit mode. */
 declare function rowSeatPositions(row: RowObject): Point[];
+/** Sellable row slots: skipped slots are absent; empty wheelchair bays remain. */
+declare function rowInventoryCount(row: RowObject): number;
 /**
  * Every seat slot of a row INCLUDING skipped ones (designer seat-edit mode uses
  * this to draw un-skip handles). Overrides (dx/dy/label/categoryKey) are applied
@@ -1123,10 +1471,17 @@ interface RowSeatSlot {
     skipped: boolean;
     accessible: boolean;
     accessibility: AccessibilityType[];
+    wheelchairSpaceType?: SeatOverride['wheelchairSpaceType'];
     commercial?: RowObject['commercial'];
     viewUrl?: string;
     labelStyle?: LabelStyle;
 }
+/** Every authored table-chair slot, including skipped inventory. This mirrors
+ * row seat slots so Designer, MCP and buyer/event expansion share one semantic
+ * source while retaining the table's stable numeric slot identity. */
+interface TableSeatSlot extends RowSeatSlot {
+    side?: RectTableSide;
+}
 /**
  * The seat NUMBER part of a row seat's label (the row prefix is prepended by the
  * caller). Applies the row's numbering scheme, direction, step, start and label
@@ -1143,6 +1498,15 @@ declare function expandRow(row: RowObject): ExpandedSeat[];
  * bottom edges (split evenly, any remainder to the top), 16u outside the edge,
  * the whole set rotated about the table centre.
  */
+/** Legacy rect tables distribute aggregate capacity round-robin across enabled
+ * sides, then emit chairs in canonical top/bottom/left/right order. */
+declare function tableSeatCountsBySide(t: TableObject): RectTableSeatCounts;
+/** Expand every authored table chair, including skipped slots needed by the
+ * Designer to restore inventory. */
+declare function expandTableSlots(t: TableObject): TableSeatSlot[];
+/** Sellable individual table chairs. Grouped tables own one atomic inventory
+ * unit elsewhere and therefore retain their full authored chair capacity. */
+declare function tableInventoryCount(t: TableObject): number;
 declare function expandTable(t: TableObject): ExpandedSeat[];
 /** Expand a booth into its single bookable block unit. */
 declare function expandBooth(b: BoothObject): ExpandedSeat[];
@@ -1158,6 +1522,14 @@ declare function polygonLabelPoint(outer: Point[], holes: Point[][] | undefined)
  * shape: bbox centre; text: its position.
  */
 declare function objectCenter(o: ChartObject): Point;
+/**
+ * Resolve one bookable object's owning physical section using the canonical
+ * first-match rule. Generated reference inventory may name a logical section,
+ * but that provenance is trusted only when the stored geometry confirms it.
+ * Keeping this primitive in layout lets section inventory, category painting,
+ * and buyer view inheritance share one ownership decision.
+ */
+declare function owningSectionForObject(objects: ChartObject[], object: ChartObject): SectionObject | undefined;
 /**
  * Normalized floor list (Batch 5): a multi-floor chart's `floors`, or a synthetic
  * single floor wrapping a single-floor chart's `objects`. Every consumer that needs
@@ -1175,8 +1547,15 @@ declare function allObjects(doc: ChartDoc): ChartObject[];
  * only for the 3D overview render — 2D still shows one floor via `floorObjects`.
  */
 declare function stackFloors(doc: ChartDoc, spread?: number): ChartDoc;
-/** Expand every seat-bearing object across all floors (rows, tables, booths). */
-declare function expandChart(doc: ChartDoc): ExpandedSeat[];
+interface ExpandChartOptions {
+    /** Physical height for a single-floor projection extracted from a multi-floor
+     * document. Full multi-floor documents resolve each floor directly. */
+    floorBaseHeightM?: number;
+}
+/** Expand every seat-bearing object across all floors (rows, tables, booths).
+ * Multi-floor ownership is resolved one floor at a time: local coordinates may
+ * overlap between floors and must never assign a seat to another floor's section. */
+declare function expandChart(doc: ChartDoc, options?: ExpandChartOptions): ExpandedSeat[];
 /** Axis-aligned bounds over every object plus the background image, with padding. */
 declare function chartBounds(doc: ChartDoc): {
     x: number;
@@ -1189,10 +1568,63 @@ declare const MAX_GA_CAPACITY = 100000;
 declare const MAX_EVENT_INVENTORY = 100000;
 /** Stable internal inventory label for one unit of a GA area's capacity. */
 declare function gaUnitLabel(areaId: string, index: number): string;
+/** Strict, bounded validation for durable Join Areas inventory provenance. */
+declare function validGAInventorySegments(area: GAAreaObject): boolean;
+/** Canonical source ranges. Invalid explicit provenance intentionally yields no
+ * labels: chart validation blocks publication instead of inventing identities. */
+declare function gaInventorySegments(area: GAAreaObject): GAInventorySegment[];
 declare function gaUnitLabels(area: GAAreaObject): string[];
+/** Append-only capacity semantics for an already joined GA surface. */
+declare function growJoinedGAInventory(area: GAAreaObject, nextCapacity: number): GAInventorySegment[] | undefined;
 declare function gaAreasOf(doc: ChartDoc): GAAreaObject[];
 declare function isGaUnitLabel(label: string): boolean;
 
+/**
+ * Real-world scale primitives — the ONE place the app fixes chart-unit ↔ metre ↔
+ * renderer-world scale, and the section 3D-geometry resolver that rides on it.
+ *
+ * Everything that converts between chart units, metres, and renderer "world"
+ * units derives from {@link METRES_PER_CHART_UNIT}. Renderer world units and
+ * chart units are 1:1, so metres → world is exactly {@link CHART_UNITS_PER_METRE}
+ * (the single m→world conversion constant Phase B consumers use).
+ *
+ * This is a leaf module (types only) so both `layout.ts` and `sections.ts` can
+ * import it without the two forming an import cycle.
+ */
+
+/**
+ * Metres of front-edge height one elevation tier represents. Chosen (not guessed)
+ * so `elevation × TIER_HEIGHT_M` metres, scaled back through
+ * {@link CHART_UNITS_PER_METRE}, equals the legacy `elevation × LIFT_PER_STEP`
+ * world lift exactly — an un-authored chart stays pixel-identical. ≈ 1.329 m/tier.
+ */
+declare const TIER_HEIGHT_M: number;
+/**
+ * Resolve a section's real 3D geometry, applying the legacy-elevation fallback so
+ * old charts and new charts share ONE code path. Every consumer (iso lift, 360°
+ * eye-height, author lint, any 2D depth cue) must call this and never read the raw
+ * {@link SectionObject.height}/{@link SectionObject.rake} fields — that is what
+ * keeps un-authored charts rendering identically to today.
+ *
+ * - `height`: authored absolute metres if present, else owning-floor base height
+ *   plus `elevation × TIER_HEIGHT_M`.
+ * - `rake`: authored degrees if present, else 0 (flat).
+ *
+ * Malformed values are bounded here as a last defensive barrier. Structural
+ * validation still reports them so drafts can be repaired instead of silently
+ * persisting a renderer-only interpretation.
+ *
+ * Pure — no document mutation, no side effects.
+ */
+interface SectionGeometryContext {
+    /** Absolute physical height of the owning floor above the venue datum. */
+    floorBaseHeightM?: number;
+}
+declare function sectionGeometry(section: Pick<SectionObject, 'elevation' | 'height' | 'rake'>, context?: SectionGeometryContext): {
+    height: number;
+    rake: number;
+};
+
 /**
  * Section membership + hide/show resolution (Batch 3.3).
  *
@@ -1267,6 +1699,116 @@ declare function hiddenObjectIds(doc: ChartDoc, hidden: ReadonlySet<string>): Se
  */
 declare function applyHidden(doc: ChartDoc, hidden: ReadonlySet<string>): ChartDoc;
 
+declare const RENDERED_QUALITY_REPORT_VERSION = 3;
+type RenderedEvidenceState = 'overview' | 'interaction';
+type RenderedQualityFindingCode = 'bookable-label-undersized' | 'bookable-label-contrast-low' | 'bookable-label-collision' | 'hierarchy-label-undersized' | 'hierarchy-label-contrast-low' | 'hierarchy-label-outside-section' | 'hierarchy-label-collision' | 'hierarchy-bookable-collision' | 'overview-section-category-paint' | 'overview-category-detail-visible' | 'overview-row-hints-visible' | 'overview-availability-clutter' | 'overview-ga-detail-visible' | 'free-text-undersized' | 'free-text-contrast-low' | 'free-text-collision' | 'free-text-bookable-collision' | 'free-text-hierarchy-collision' | 'ga-contrast-low' | 'detail-rung-missing' | 'detail-inventory-not-visible' | 'pointer-target-undersized' | 'pointer-target-inactive' | 'selected-state-missing' | 'selected-state-contrast-low' | 'held-state-missing' | 'booked-state-missing' | 'status-state-indistinct' | 'section-focus-missing' | 'category-filter-missing' | 'category-filter-ineffective' | 'target-category-not-visible' | 'target-category-filter-mismatch';
+interface RenderedQualitySample {
+    primaryId: string;
+    primaryLabel: string;
+    secondaryId?: string;
+    secondaryLabel?: string;
+    measured?: number;
+    minimum?: number;
+}
+interface RenderedQualityFinding {
+    code: RenderedQualityFindingCode;
+    message: string;
+    count: number;
+    samples: RenderedQualitySample[];
+}
+interface RenderedQualityReport {
+    version: typeof RENDERED_QUALITY_REPORT_VERSION;
+    passed: boolean;
+    state: RenderedEvidenceState;
+    /** Server-selected category exercised by a category-specific detail scene. */
+    targetCategoryKey: string | null;
+    /** Exact overview checks discharged by this browser-rendered report. */
+    resolvedRules: string[];
+    viewport: {
+        width: number;
+        height: number;
+    };
+    canvasBackground: string;
+    effectiveScale: number;
+    rung: RendererQualityEvidence['rung'];
+    inventory: {
+        totalBookableUnits: number;
+        totalLabelledBookableUnits: number;
+        visibleBookableLabels: number;
+        hiddenBookableLabels: number;
+        visibleHierarchyLabels: number;
+        visibleFreeTextLabels: number;
+        visibleGAAreas: number;
+    };
+    overviewStyle?: RendererQualityEvidence['overviewStyle'];
+    /**
+     * Coordinate-free identity evidence from the exact buyer scene. The Worker
+     * uses this to compare persisted reference semantics with what Chromium
+     * actually painted, without exposing screen boxes or accepting geometry.
+     */
+    composition: {
+        hierarchy: Array<{
+            id: string;
+            kind: 'section' | 'zone';
+            label: string;
+            visible: boolean;
+        }>;
+        labelledObjects: Array<{
+            objectId: string;
+            kind: RenderedFreeTextEvidence['kind'];
+            text: string;
+            visible: boolean;
+        }>;
+        gaAreas: Array<{
+            areaId: string;
+            label: string;
+            categoryKey: string;
+            sectionId?: string;
+            visible: boolean;
+        }>;
+        bookableSectionIds: string[];
+        categoryKeys: string[];
+        /** Categories whose non-dimmed bookable paint is visible in this scene. */
+        activeCategoryKeys: string[];
+    };
+    metrics: {
+        minimumRenderedBookableLabelPx: number | null;
+        minimumBookableLabelContrast: number | null;
+        minimumRenderedHierarchyLabelPx: number | null;
+        minimumHierarchyLabelContrast: number | null;
+        minimumRenderedFreeTextPx: number | null;
+        minimumFreeTextContrast: number | null;
+        minimumGAContrast: number | null;
+        minimumEffectivePointerTargetPx: number | null;
+        selectedRingContrast: number | null;
+    };
+    interaction: {
+        applicable: {
+            detail: boolean;
+            pointer: boolean;
+            held: boolean;
+            booked: boolean;
+            sectionFocus: boolean;
+            categoryFilter: boolean;
+        };
+        selectedUnits: number;
+        heldUnits: number;
+        bookedUnits: number;
+        activePointerTargets: number;
+        focusedSectionId: string | null;
+        focusBackdropVisible: boolean;
+        categoryFilterKeys: string[] | null;
+    };
+    findings: RenderedQualityFinding[];
+}
+/**
+ * Inspect what the buyer renderer actually decided to paint at one exact
+ * viewport. This is deliberately downstream of ChartDoc validation: screen
+ * size, LOD visibility, fitted hierarchy text, transient paint, and label
+ * collisions cannot be proven from stored geometry alone.
+ */
+declare function inspectRenderedQualityEvidence(evidence: RendererQualityEvidence, state?: RenderedEvidenceState, targetCategoryKey?: string | null): RenderedQualityReport;
+
 /**
  * SeatmapRenderer — the shared canvas rendering core (buyer picker shell).
  *
@@ -1285,8 +1827,17 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private seatLayer;
     private overlayLayer;
     private labelGroup;
+    /** Per-elevated-section label containers. Keeping the labels grouped lets the
+     *  Phase-B lift move thousands of seat labels with one transform per section
+     *  instead of rewriting every label on every tween frame. */
+    private labelLiftGroups;
+    /** Foreground decor images — drawn on the overlay layer, ABOVE the seats. */
+    private fgDecorGroup;
     private seats;
     private seatById;
+    /** One build per chart/floor; section membership queries only inspect seats in
+     *  the section bounds instead of rescanning the full 13k venue per section. */
+    private seatIndex;
     /** Multi-floor (Batch 5): the last-set chart + which floor we're rendering. */
     private chartDoc;
     private activeFloorId;
@@ -1302,13 +1853,11 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private seatLabelById;
     /** Coloured accommodation ring per accessible seat (few per chart). */
     private accessRingById;
-    /** Centred accessibility glyph per accessible seat — shown once the seat is
-     *  big enough on-screen (see {@link SEAT_GLYPH_MIN_PX}); the ring is the
-     *  smaller-zoom fallback. Kept in a map so zoom toggles touch only the handful
-     *  of accessible seats, never all 13k nodes. */
+    /** Centred ♿ glyph per physical wheelchair provision. It keeps a small
+     *  screen-space floor at every LOD and grows when the Wheelchair filter is
+     *  active. Kept in a map so zoom updates touch only the handful of matching
+     *  seats, never all 13k nodes. */
     private accessGlyphById;
-    /** Whether the accessibility glyph is legible at the current camera scale. */
-    private accessGlyphVisible;
     /** Authored free-text nodes obey the same rendered-size visibility floor. */
     private freeTextById;
     /** Stage/rink landmarks retain a readable screen-space caption at overview. */
@@ -1334,6 +1883,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /** One selected seat being inspected before it is committed to the cart. */
     private selectionFocusId;
     private hoverRing;
+    /** Seat currently owning the shared hover ring (null while not hovering). */
+    private hoveredId;
     /** Keyboard-navigation focus ring + the currently focused seat id. */
     private focusRing;
     private focusedId;
@@ -1352,6 +1903,8 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private sections;
     private zones;
     private seatSection;
+    /** Seats outside every authored section retain the legacy path in one group. */
+    private unsectionedSeatGroup;
     private catPrice;
     /** ISO 4217 currency for on-map "FROM …" prices (undefined ⇒ money default). */
     private currency;
@@ -1366,6 +1919,9 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private focusedSectionId;
     /** Light backdrop panel drawn behind the focused section (removed on clear). */
     private focusBackdrop;
+    /** Non-listening visual dim outside the focused section. One overlay replaces
+     *  descendant opacity mutations across every seat in the venue. */
+    private focusDimOverlay;
     /** Object id → floor id (multi-floor only) — resolves a deck tap in the 3D stack. */
     private objectFloor;
     /** Zone id → colour (drives extruded side faces in iso view). */
@@ -1377,10 +1933,33 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private isoT;
     private isoTarget;
     private isoRaf;
+    /** Public view target; perspective is a separate non-affine Phase-C lane. */
+    private viewMode;
+    private perspectiveCamera;
+    /** Ground-plane tangent applied once to every renderer layer. */
+    private perspectiveBaseAffine;
+    private perspectiveBaseInverse;
+    /** Exact pinhole anchor expressed in the overlay tangent-layer coordinates. */
+    private perspectiveSeatLocal;
+    /** Exact projected point (before Stage pan/zoom), keyed by seat. */
+    private perspectiveSeatProjected;
+    /** Positive camera depth, used for deterministic far→near paint order. */
+    private perspectiveSeatDepth;
+    /** Exact pinhole size ratio at each seat anchor. */
+    private perspectiveSeatScale;
+    /** Seats whose native Konva nodes currently carry the exact projected pose.
+     * Large sectioned venues apply these lazily as a section enters the live-seat
+     * viewport; the overview rung hides the seat layer completely. */
+    private perspectiveAppliedSeats;
+    private perspectiveBounds;
     /** Chart centre the iso projection pivots about (bounds centre). */
     private isoCentre;
     /** rAF for an in-flight camera glide (focusRegion / setRung); 0 = none. */
     private glideRaf;
+    /** While the camera tween is active, defer polygon label fitting/collision to
+     *  the settled frame. Geometry remains smoothly stage-scaled, while expensive
+     *  point-in-polygon text work no longer repeats at 120 Hz. */
+    private glideInProgress;
     /** Set in destroy() so an in-flight iso tween bails. */
     private destroyed;
     /** Cached scale the section/zone labels were last sized for (scale-compensation). */
@@ -1407,6 +1986,28 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private panStarted;
     /** Maximum displacement from gesture start — suppress taps only after a real pan/pinch. */
     private moved;
+    /**
+     * Ghost-click guard. Konva binds `_pointerup` to mouseup, touchend AND
+     * pointerup, so `on('click tap')` is two handlers for one finger tap unless
+     * the browser's synthesized compatibility click is suppressed. Konva only
+     * suppresses it when the touch lands on a LISTENING SHAPE (Stage.js returns
+     * early before its preventDefault() when `!shape || !shape.isListening()`),
+     * so a near-miss rescued by nearestSeatToScreen used to fire `tap` (select)
+     * then `click` (deselect) 1-3ms apart and net to nothing. With
+     * SEAT_TAP_SLOP_PX=14 against a ~12px seat radius, that broken annulus is
+     * ~3.7x the area of the seat itself — i.e. most successful mobile taps.
+     * `touch-action: none` does NOT suppress compatibility mouse events.
+     */
+    private lastTapAt;
+    /**
+     * True when this is the browser's synthesized compatibility click following a
+     * finger tap we already handled. Discriminates on `e.type` deliberately —
+     * `PointerEvent extends MouseEvent`, so an `instanceof MouseEvent` test
+     * matches genuine pointer taps too. One shared timestamp across the layer and
+     * stage handlers: a tap consumed at the layer must also suppress the ghost at
+     * the stage, and only `click` is ever rejected, so bubbling stays intact.
+     */
+    private isGhostClick;
     /**
      * Manage-mode rubber-band marquee (option-gated). `start`/`cur` are WORLD-space
      * points (overlayLayer rides the stage transform); `rect` is the on-canvas
@@ -1421,6 +2022,9 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     /** The chart to render: all floors stacked (3D overview), the active floor, or
      *  the whole chart for single-floor charts. */
     private floorView;
+    /** Physical floor height is authored data; the 900-unit stacked overview
+     * spread is presentation-only and must never leak into real 3D geometry. */
+    private floorBaseHeightMFor;
     /** Toggle the 3D all-floors stacked overview (Batch 5). Re-renders; no-op on
      *  single-floor charts. The caller re-applies statuses + animates the iso view. */
     setStacked(on: boolean): void;
@@ -1533,9 +2137,9 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * geometry stays flat, so hit-testing (Konva's own, plus the manual section
      * inverse) keeps landing on the projected seats/sections.
      */
-    setViewMode(mode: 'flat' | 'isometric'): void;
+    setViewMode(mode: RendererViewMode): void;
     /** Current projection — reflects the tween target, not the mid-tween isoT. */
-    getViewMode(): 'flat' | 'isometric';
+    getViewMode(): RendererViewMode;
     /** Iso angle (rad) + y-squash for the current isoT. */
     private isoParams;
     /** Effective vertical scale = stage scale × iso squash — legibility math uses this. */
@@ -1544,14 +2148,40 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     private isoForward;
     /** Inverse of isoForward (iso-world → world) for screen-space hit-testing. */
     private isoInverse;
+    /** Precompute the Phase-C pinhole camera and every exact seat anchor. */
+    private buildPerspectiveProjection;
+    /** Apply an affine to a Konva container while keeping `pivot` fixed logically. */
+    private setContainerAffine;
+    private resetContainerTransform;
+    /** Exact raked surface height used for the bounded section tangent plane. */
+    private sectionSurfaceHeight;
+    /** Desired perspective-space point for a section surface, before Stage pan/zoom. */
+    private projectedSectionPoint;
+    /** Shared-layer local point which the ground affine paints at `projected`. */
+    private perspectiveLocalPoint;
     /**
      * Local-space offset that, once the layer applies the iso affine, lifts an
-     * object straight UP in iso-world by `elevation × LIFT_PER_STEP × isoT`
-     * (= inverse-linear of the pure vertical lift). Zero at isoT=0.
+     * object straight UP in iso-world by `liftWorld × isoT` world units
+     * (= inverse-linear of the pure vertical lift). Zero at isoT=0. `liftWorld` is
+     * the section's resolved real height in world units (Phase B1).
      */
     private isoLiftLocal;
-    /** Restore the three layers to identity (flat) — byte-for-byte the original. */
+    /** Restore projection layers to identity (flat) — byte-for-byte the original.
+     * `seatLayer` can be skipped when entering perspective from flat: assigning a
+     * top-level transform invalidates all 14k descendant absolute transforms even
+     * while the semantic overview keeps that layer fully transparent. */
     private resetLayerTransforms;
+    /** Restore section-owned containers before applying another projection. */
+    private resetSectionProjection;
+    /** Move native seat/booth hit shapes to or from their exact pinhole anchors. */
+    private applyExactSeatAnchors;
+    /**
+     * Phase C projected 2.5D. Seat/booth anchors are exact pinhole projections;
+     * section top surfaces use one explicitly bounded tangent plane per authored
+     * section. Native Konva shapes move with the anchors, so direct hit testing is
+     * the same graph that paints the buyer-visible unit.
+     */
+    private applyPerspective;
     /**
      * Apply the current isoT to the scene: the base rotate+squash as a decomposed
      * layer transform (so seats/décor/rings project together and Konva's own
@@ -1571,6 +2201,32 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      * tier shifts with one offset in iso view) or the seat layer directly.
      */
     private seatContainer;
+    /** True when a section belongs to the active logical section/zone focus. */
+    private sectionMatchesFocus;
+    /** Visual opacity after the section-focus overlay is composed. */
+    private focusedSeatOpacity;
+    /** Project a section outline through elevation + the active affine view and
+     *  then into viewport pixels. The result is conservative (AABB), so a visible
+     *  section is never clipped even for rotated or isometric outlines. */
+    private sectionScreenBounds;
+    /** Hide only section groups wholly outside a padded viewport at the live-seat
+     *  rung. Overview caching always restores all groups first, so panning a
+     *  cached whole-venue bitmap can never reveal missing inventory. */
+    private updateSeatGroupVisibility;
+    /** Seats worth considering for viewport labels. Section culling is a safe
+     *  coarse index; the later screen test remains the exact filter. */
+    private visibleSeatCandidates;
+    private seatViewportCulled;
+    /** Local world coordinate at which an elevated seat is actually painted for
+     *  the current iso tween. Flat seats and the 2D endpoint are unchanged. */
+    private renderedSeatPoint;
+    /** Overlay labels mirror the seat-layer lift without an O(seats) per-frame
+     *  rewrite. The groups are rebuilt with the zoom-dependent label set. */
+    private seatLabelContainer;
+    /** Shared overlay furniture is not parented to section lift groups, so keep
+     *  the small transient set aligned explicitly. Selection is capped in buyer
+     *  mode, making this constant-sized work during the iso tween. */
+    private syncSeatOverlayPositions;
     private renderSeats;
     /** A booth renders as a click-selectable rounded block (dims from the doc). */
     private renderBoothUnit;
@@ -1581,12 +2237,14 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
      */
     private buildAccessGlyph;
     /**
-     * Toggle the accessibility glyphs for the current camera scale: shown once the
-     * effective on-screen seat radius clears {@link SEAT_GLYPH_MIN_PX}, otherwise
-     * hidden so only the ring remains. Iterates the (small) accessible-seat set,
-     * never the full node graph, so it is cheap to call on every view change.
+     * Keep physical wheelchair provision readable in screen space at every map
+     * LOD. The active Wheelchair filter promotes it further. Iterates the small
+     * wheelchair-seat set, never the full node graph.
      */
     private updateAccessGlyphs;
+    /** True only for a physical wheelchair provision matching an active buyer filter. */
+    private accessGlyphFilterEmphasized;
+    private accessGlyphShouldShow;
     /**
      * Whether an accessible seat's glyph should show for its current status. It is
      * hidden on seats a buyer cannot take (sold, or another buyer's hold) where the
@@ -1639,6 +2297,11 @@ declare class SeatmapRenderer implements ISeatmapRenderer {
     getFocusedSection(): string | null;
     /** Draw (or replace) the light backdrop panel behind the focused section. */
     private drawFocusBackdrop;
+    /** Dim everything outside the active section with one paint-only shape. Group
+     *  opacity would make Konva recursively invalidate absolute-opacity caches on
+     *  all 14k descendants. The cut-out follows the live elevation offset and is
+     *  non-listening, so direct seat hit-testing is unchanged. */
+    private drawFocusDimOverlay;
     /** Repaint every seat + section block to reflect closed/focus state, then redraw. */
     private repaintSectionsAndSeats;
     /** The world-space rectangle currently visible in the viewport (minimap F3). */
@@ -1864,6 +2527,16 @@ interface PickerSeat {
     /** Buyer-facing label (row `displayLabel` applied). Falls back to `label`;
      *  never use for booking — `label` is the inventory/booking identity. */
     displayLabel?: string;
+    /** Buyer-facing object type word authored in Designer. Pure presentation. */
+    displayType?: string;
+    /** @deprecated Use `displayType`; retained for source compatibility. */
+    rowType?: string;
+    /** Stable parent chart-object id (row/table/booth), separate from seat id. */
+    objectId?: string;
+    /** Buyer-facing spatial context shared by selection, hold, and hover callbacks. */
+    sectionLabel?: string;
+    rowLabel?: string;
+    seatNumber?: string;
     categoryKey: string;
     /** Price for the chosen tier when the category has tiers, else the base price. */
     price: number;
@@ -1875,6 +2548,29 @@ interface PickerSeat {
      *  note) resolved for this seat; absent when the seat carries none. Lets the
      *  buyer cart + confirm surface flag limited-view/premium seats. */
     commercial?: SeatCommercialAttributes;
+    /** Accessibility semantics exposed to SDK callbacks and buyer summaries. */
+    accessibility?: AccessibilityType[];
+    /** Explicit physical wheelchair chair/bay distinction. */
+    wheelchairSpaceType?: 'seat-present' | 'no-seat';
+    /** Physical/bookable source kind; booking identity remains `label`. */
+    objectType?: 'seat' | 'booth' | 'table';
+    /** Grouped-table booking contract; absent for normal chair inventory. */
+    bookingMode?: 'whole' | 'variable';
+    /** Guest quantity represented by this one atomic table line. */
+    quantity?: number;
+    capacity?: number;
+    minOccupancy?: number;
+    maxOccupancy?: number;
+}
+/** Accessible quantity/confirmation payload for one model-2 table selection. */
+interface TableSelectionDetails extends PickerSeat {
+    objectType: 'table';
+    bookingMode: 'whole' | 'variable';
+    quantity: number;
+    capacity: number;
+    minOccupancy: number;
+    maxOccupancy: number;
+    physicalSeatIds: string[];
 }
 /**
  * Rich hover payload for seat tooltips — the PickerSeat plus everything a
@@ -1886,10 +2582,20 @@ interface SeatHoverDetails extends PickerSeat {
     categoryColor: string;
     status: SeatStatus;
     currency: string;
-    /** Human-readable spatial context for hover and confirmation UI. */
-    sectionLabel?: string;
-    rowLabel?: string;
-    seatNumber?: string;
+}
+interface PickerGAArea {
+    id: string;
+    /** Stable technical/inventory prefix. */
+    label: string;
+    /** Buyer-facing area name and type; absent fields use UI defaults. */
+    displayLabel?: string;
+    displayType?: string;
+    capacity: number;
+    available: number;
+    categoryKey: string;
+    price: number;
+    currency: string;
+    tiers?: CategoryTier[];
 }
 interface HoldConflict {
     label: string;
@@ -1923,6 +2629,8 @@ interface SectionSummary {
     label: string;
     /** Zone label (from ChartDoc.zones); '' when the section has no zone. */
     zoneLabel: string;
+    /** Buyer-facing entrance/door hint ("Entrance X"); absent when unset. */
+    entrance?: string;
     /** Mix/section colour for the card's dot (section.color → zone colour → dominant category). */
     color: string;
     /** Free member seats right now. */
@@ -1943,7 +2651,7 @@ interface ResumeHoldResponse extends HoldResponse {
 interface HoldServerItem {
     label: string;
     objectId: string;
-    objectType: 'seat' | 'booth' | 'ga';
+    objectType: 'seat' | 'booth' | 'ga' | 'table';
     categoryKey: string;
     tierId: string | null;
     unitPrice: number;
@@ -1953,6 +2661,7 @@ interface HoldServerItem {
 interface HoldSelectionRequest {
     label: string;
     tierId?: string | null;
+    quantity?: number;
 }
 interface BestAvailableResponse extends HoldResponse {
     labels: string[];
@@ -1969,6 +2678,7 @@ interface PickerTransport {
             startsAt?: number | null;
             currency?: string;
             mode?: string;
+            inventoryModelVersion?: 1 | 2;
         };
     }>;
     objects(key: string): Promise<{
@@ -1977,7 +2687,7 @@ interface PickerTransport {
         closed?: string[];
     }>;
     hold(key: string, selections: HoldSelectionRequest[], ttlMs?: number, replaceHoldId?: string): Promise<HoldResponse>;
-    bestAvailable(key: string, qty: number, categoryKey?: string): Promise<BestAvailableResponse>;
+    bestAvailable(key: string, qty: number, categoryKey?: string, zoneId?: string): Promise<BestAvailableResponse>;
     release(key: string, labels: string[], holdId: string): Promise<unknown>;
     /** Optional capability-style lookup used to restore an active browser hold. */
     resume?(key: string, holdId: string): Promise<ResumeHoldResponse>;
@@ -1994,6 +2704,8 @@ interface PickerTransport {
 interface PickerCallbacks extends RendererCallbacks {
     /** Selection changed (manual clicks or a server best-available pick). */
     onSelectionChange?: (seats: PickerSeat[]) => void;
+    /** A grouped table was selected and needs buyer confirmation/guest quantity. */
+    onTableSelectionRequest?: (table: TableSelectionDetails) => void;
     /** A hold opened (manual hold or best-available). */
     onHold?: (hold: HoldInfo) => void;
     /** A prior active hold was restored from its opaque hold id. */
@@ -2075,6 +2787,14 @@ declare class PickerController {
     /** id → buyer-facing spatial metadata used by every tooltip/confirm surface. */
     private seatContext;
     private allIds;
+    /** Model-2 tables are one booking unit whose chairs remain renderer geometry. */
+    private groupedTablesByObject;
+    private groupedTablesByLabel;
+    private groupedTableBySeatId;
+    private tableQuantities;
+    /** Variable quantity is a buyer contract, never an inferred default. */
+    private confirmedVariableTables;
+    private groupedSelectionOverhead;
     private ws;
     private reconnectTimer;
     private attempt;
@@ -2102,6 +2822,10 @@ declare class PickerController {
     getRenderer(): ISeatmapRenderer | null;
     seatByLabel(label: string): ExpandedSeat | undefined;
     idForLabel(label: string): string | undefined;
+    private idsForLabel;
+    private idsForLabels;
+    /** Resolve a physical chair id (or table inventory label) to its table unit. */
+    tableSelection(seatIdOrLabel: string): TableSelectionDetails | null;
     /** Fetch chart, build label maps, mount the renderer, seed statuses, go live. */
     render(host: HTMLDivElement): Promise<{
         doc: ChartDoc;
@@ -2120,6 +2844,17 @@ declare class PickerController {
     deselect(ids: string[]): void;
     setMaxSelection(maxSelection: number): void;
     select(ids: string[]): PickerSeat[];
+    /** Confirm/update the guest quantity for a selected variable table. */
+    setTableQuantity(label: string, quantity: number): boolean;
+    /** Atomically replace an active variable-table hold with a new guest count. */
+    replaceTableQuantity(label: string, quantity: number): Promise<HoldInfo | null>;
+    private rendererSelectionCap;
+    private selectionGuestCount;
+    private handleRendererSelect;
+    private handleRendererDeselect;
+    private resetUnheldTableQuantities;
+    private resetTableQuantitiesForLabels;
+    private tableQuantityRequest;
     /**
      * Hold the current selection (or a given label set). The controller does the
      * renderer/hold side (409 → deselect + repaint the taken seats held) and then
@@ -2146,16 +2881,7 @@ declare class PickerController {
     categoryAvailability(): Record<string, number>;
     /** Seat ids belonging to a currently-closed section (excluded from counts). */
     private closedMemberIds;
-    getGAAreas(): {
-        id: string;
-        label: string;
-        capacity: number;
-        available: number;
-        categoryKey: string;
-        price: number;
-        currency: string;
-        tiers?: CategoryTier[];
-    }[];
+    getGAAreas(): PickerGAArea[];
     /** Select a quantity from one GA area and hold it atomically. */
     holdGA(areaId: string, qty: number, options?: {
         tierId?: string | null;
@@ -2165,6 +2891,11 @@ declare class PickerController {
      *  flag — gates the buyer widget's "★ Best seats" premium quick-pick (chip is
      *  present-only, exactly like the accessibility filter chips). */
     hasPremiumSeats(): boolean;
+    /** Zones which still own visible buyer inventory, in authored order. */
+    getBestAvailableZones(): Array<{
+        id: string;
+        label: string;
+    }>;
     /**
      * Client-side premium pre-pass: find the best contiguous block of `qty`
      * PREMIUM-flagged free seats (orphan-avoiding, closest to the focal point)
@@ -2182,6 +2913,7 @@ declare class PickerController {
      */
     bestAvailable(qty: number, categoryKey?: string, opts?: {
         preferPremium?: boolean;
+        zoneId?: string;
     }): Promise<HoldInfo | null>;
     /**
      * Complete a booking. Requires a transport that supports book() (the SDK
@@ -2237,9 +2969,9 @@ declare class PickerController {
     /** Tap-a-deck-to-enter: leave the 3D stack, drop to flat 2D on `floorId`, and
      *  tell the host so it can sync its 2D/3D toggle + floor-switcher state. */
     private handleDeckTap;
-    /** Switch the map projection (2D flat ⇄ 3D isometric). No-op on a flat renderer. */
-    setViewMode(mode: 'flat' | 'isometric'): void;
-    getViewMode(): 'flat' | 'isometric';
+    /** Switch the map projection. No-op on a flat-only renderer. */
+    setViewMode(mode: RendererViewMode): void;
+    getViewMode(): RendererViewMode;
     /** Current LOD rung (for the ZONES/SECTIONS/SEATS pill). */
     getRung(): LodRung;
     /** Jump to a rung; ZONES clears any focused summary (back to overview). */
@@ -2286,6 +3018,7 @@ declare class PickerController {
     private sectionSummary;
     destroy(): void;
     private toSeat;
+    private toTableSeat;
     /** Tooltip payload for a hovered seat — see PickerCallbacks.onSeatHover. */
     private describeSeat;
     private priceFor;
@@ -2438,4 +3171,4 @@ declare function formatMoney(amount: number, currency?: string, fractionDigits?:
 /** Bare symbol for input adornments ("€", "$", "₹"). */
 declare function currencySymbol(currency?: string): string;
 
-export { ACCESSIBILITY_RING_COLOR, ACCESSIBILITY_TYPES, type AccessibilityMeta, type AccessibilityType, type AvailabilityRule, type BoothObject, CHART_STORAGE_KEY, type Category, type CategoryTier, type ChartDoc, type ChartObject, type ChartReferenceImage, type ChartTheme, type CubicPath, DEFAULT_CURRENCY, type DecorImageObject, type Dict, type ExpandedSeat, type Floor, type GAAreaObject, type HoldConflict, type HoldInfo, type HoldSelectionRequest, type HoldServerItem, type ISeatmapRenderer, LABEL_STYLE_MAX_SIZE, LABEL_STYLE_MIN_SIZE, type LabelPresentation, type LabelStyle, type Locale, type LodRung, MAX_EVENT_INVENTORY, MAX_GA_CAPACITY, type PanoramaResult, type PickerCallbacks, PickerController, type PickerOptions, type PickerSeat, type PickerTransport, type Point, type ReferenceAccessibilitySource, type ReferenceCalibration, type ReferenceCategorySource, type ReferenceDerivedScale, type ReferenceInventoryExclusionSource, type ReferenceInventorySource, type RenderedBookableLabelEvidence, type RenderedFreeTextEvidence, type RenderedGAAreaEvidence, type RenderedHierarchyLabelEvidence, type RenderedLabelHiddenReason, type RendererCallbacks, type RendererOptions, type RendererQualityEvidence, type RowObject, type RowSeatSlot, SUPPORTED_LOCALES, type SeatCommercialAttributes, type SeatHoverDetails, type SeatOverride, type SeatStatus, SeatmapRenderer, type SectionCategory, type SectionNode, type SectionObject, type SectionOutlinePath, type SectionPathSegment, type SectionSummary, type SelectionLayer, type ShapeObject, type TableObject, type TextObject, UNGROUPED_ID, type ZoneDef, accessibilityMeta, accessibilityRingColor, allObjects, applyHidden, chartBounds, computeSections, createRenderer, currencySymbol, expandBooth, expandChart, expandRow, expandRowSlots, expandTable, floorObjects, floorsOf, formatDate, formatMoney, gaAreasOf, gaUnitLabel, gaUnitLabels, generateSeatPanorama, generateSeatThumb, getLocale, hiddenObjectIds, isGaUnitLabel, isSectionHidden, layerOf, loadLocale, objectCenter, pointInPolygon, pointInPolygonWithHoles, polygonLabelPoint, resolveLocale, rowSeatPositions, seatLabelPart, setLocale, setMoneyLocale, setStringOverrides, stackFloors, t, tCount };
+export { ACCESSIBILITY_RING_COLOR, ACCESSIBILITY_TYPES, type AccessibilityMeta, type AccessibilityType, type AvailabilityRule, type BoothObject, CHART_STORAGE_KEY, type Category, type CategoryTier, type ChartDoc, type ChartObject, type ChartReferenceImage, type ChartTheme, type CubicPath, DEFAULT_CURRENCY, type DecorImageObject, type Dict, type ExpandChartOptions, type ExpandedSeat, type Floor, type GAAreaObject, type GAInventorySegment, type HoldConflict, type HoldInfo, type HoldSelectionRequest, type HoldServerItem, type ISeatmapRenderer, LABEL_STYLE_MAX_SIZE, LABEL_STYLE_MIN_SIZE, type LabelPresentation, type LabelStyle, type Locale, type LodRung, MAX_EVENT_INVENTORY, MAX_GA_CAPACITY, type PanoramaResult, type PickerCallbacks, PickerController, type PickerGAArea, type PickerOptions, type PickerSeat, type PickerTransport, type Point, RENDERED_QUALITY_REPORT_VERSION, type RectTableSeatCounts, type RectTableSide, type ReferenceAccessibilitySource, type ReferenceCalibration, type ReferenceCategorySource, type ReferenceDerivedScale, type ReferenceInventoryExclusionSource, type ReferenceInventorySource, type ReferenceScanProposal, type ReferenceScanRowProposal, type ReferenceScanSectionProposal, type ReferenceSeatSeed, type RenderedBookableLabelEvidence, type RenderedEvidenceState, type RenderedFreeTextEvidence, type RenderedGAAreaEvidence, type RenderedHierarchyLabelEvidence, type RenderedLabelHiddenReason, type RenderedQualityFinding, type RenderedQualityFindingCode, type RenderedQualityReport, type RenderedQualitySample, type RendererCallbacks, type RendererOptions, type RendererQualityEvidence, type RendererViewMode, type RowObject, type RowSeatSlot, SUPPORTED_LOCALES, SURROUNDINGS_SHAPE_ROLES, type SeatCommercialAttributes, type SeatHoverDetails, type SeatOverride, type SeatStatus, SeatmapRenderer, type SectionCategory, type SectionNode, type SectionObject, type SectionOutlinePath, type SectionPathSegment, type SectionSummary, type SelectionLayer, type ShapeLineCap, type ShapeLineEnding, type ShapeLineJoin, type ShapeObject, TIER_HEIGHT_M, type TableObject, type TableSeatSlot, type TableSelectionDetails, type TextObject, UNGROUPED_ID, type ZoneDef, accessibilityMeta, accessibilityRingColor, allObjects, applyHidden, chartBounds, computeSections, createRenderer, currencySymbol, expandBooth, expandChart, expandRow, expandRowSlots, expandTable, expandTableSlots, floorObjects, floorsOf, formatDate, formatMoney, gaAreasOf, gaInventorySegments, gaUnitLabel, gaUnitLabels, generateSeatPanorama, generateSeatThumb, getLocale, growJoinedGAInventory, hiddenObjectIds, inspectRenderedQualityEvidence, isGaUnitLabel, isSectionHidden, layerOf, loadLocale, objectCenter, owningSectionForObject, pointInPolygon, pointInPolygonWithHoles, polygonLabelPoint, resolveLocale, rowInventoryCount, rowSeatPositions, seatLabelPart, sectionGeometry, setLocale, setMoneyLocale, setStringOverrides, stackFloors, t, tCount, tableInventoryCount, tableSeatCountsBySide, validGAInventorySegments };